upd

README.md

@@ -0,0 +1,46 @@
+# 📚 Exams Repository
+
+This repository contains study materials, practice tasks, and lab reports for various university courses.  
+It is organized by subject, with each subject containing theory notes, practice problems, labs, and supporting assets.
+
+## 📂 Repository Structure
+
+### Algebra
+- 📖 [Lecture Notes (lec1–lec15)](algebra/theory/)  
+- ❓ [Questions](algebra/theory/questions.pdf) | [Typst Source](algebra/theory/questions.typ)  
+- 📝 [Practice Sheets (prac0–prac6)](algebra/practice/)
+
+### Algorithms
+- 📑 [Template](algorithms/templates/template.pdf)  
+- 🧩 Labs:
+  - [Lab 6 Report](algorithms/labs/lab6/out/report.docx) | [Task](algorithms/labs/lab6/in/task.pdf) | [Code](algorithms/labs/lab6/code/)  
+  - [Lab 7 Report](algorithms/labs/lab7/out/report.docx) | [Task](algorithms/labs/lab7/in/task.pdf) | [Code](algorithms/labs/lab7/code/)  
+  - [Lab 8 Report](algorithms/labs/lab8/out/report.docx) | [Task](algorithms/labs/lab8/in/task.pdf) | [Code](algorithms/labs/lab8/code/)
+
+### Calculus
+- 📖 [Theory](calculus/theory/theory.pdf)  
+- ❓ [Questions](calculus/theory/questions.pdf) | [Typst Source](calculus/theory/questions.typ)  
+- 📝 [Practice Tasks](calculus/practice/tasks.pdf) | [Typst Source](calculus/practice/tasks.typ)
+
+### Computer Networks
+- 📖 [Lectures](computer_networks/theory/lectures.pdf) | [Typst Source](computer_networks/theory/lectures.typ)  
+- ❓ [Questions](computer_networks/theory/questions.pdf)  
+- 🧩 Labs:
+  - [Lab 1 Report](computer_networks/labs/lab1/report.pdf) | [Typst Source](computer_networks/labs/lab1/report.typ)  
+  - [Lab 2 Report](computer_networks/labs/lab2/report.pdf) | [Typst Source](computer_networks/labs/lab2/report.typ) | [Packet](computer_networks/labs/lab2/res.pkt)  
+  - [Lab 3 Report](computer_networks/labs/lab3/report.pdf) | [Typst Source](computer_networks/labs/lab3/report.typ) | [Packets](computer_networks/labs/lab3/)  
+  - [Lab 4 Report](computer_networks/labs/lab4/report.pdf) | [Typst Source](computer_networks/labs/lab4/report.typ)  
+  - [Lab 5 Report](computer_networks/labs/lab5/report.pdf) | [Typst Source](computer_networks/labs/lab5/report.typ)  
+  - [Lab 6 Report](computer_networks/labs/lab6/report.pdf) | [Typst Source](computer_networks/labs/lab6/report.typ) | [Packet](computer_networks/labs/lab6/network.pkt)
+
+### Physics
+- 📖 [Lectures (lec1–lec7)](physics/theory/)  
+- ❓ [Questions](physics/theory/questions.pdf) | [Typst Source](physics/theory/questions.typ)  
+- 📝 [Practice Tasks](physics/practice/task.pdf) | [Typst Source](physics/practice/task.typ) | [Prac1–Prac7](physics/practice/)
+
+---
+
+### Root
+- 📖 [General Theory Summary](theory.pdf)
+
+

algebra/theory/questions.typ

@@ -0,0 +1,787 @@
+= Линейная алгебра
+
+== Лекция I. Линейные формы. 
+
+=== Понятие линейной формы. 
+
+*Линейной формой* на пространстве $V$ называется такая функция $f : V arrow KK$, что $forall v, space v_1, space v_2 in V, space forall lambda in KK$ выполняется: 
+
+(а) Аддитивность: $f(v_1 + v_2) = f(v_1) + f(v_2)$.
+
+(б) Однородность: $f(lambda v) = lambda f(v)$.
+
+#line(length: 100%)
+=== Понятие коэффициентов линейной формы. 
+
+*Коэффициентами* $phi_i$ линейной формы $f$ называются значения этой линейной формы на базисных векторах пространства. 
+
+$
+f(e_i) = phi_i
+$
+
+#line(length: 100%)
+=== Теорема. 
+
+Задание линейной формы эквивалентно заданию ее значений на базисных формах, т.е. заданию ее коэффициентов. 
+
+_Доказательство._ Пусть в выбранном базисе ${e_i}_(i = 1)^n$ линейного пространства $V$ линейная форма $f$ задана набором коэффициентов ${phi_i}_(i = 1)^n$. Тогда $forall v = sum_(i = 1)^n v^i e_i in V$: 
+
+$
+f(v) = f(sum_(i = 1)^n v^i e_i) = sum_(i = 1)^n f(v^i e_i) = sum_(i = 1)^n v^i f(e_i) = sum_(i = 1)^n v^i phi_i
+$
+
+Таким образом получаем, что образ любого вектора однозначно определен координатами этого векторами и коэффициентами линейной формы, где оба набора чисел найдены _в одном и том же базисе_. 
+
+#line(length: 100%)
+=== Понятие равных линейных форм
+
+Линейные формы $f$ и $g$ будем называть *равными*, если 
+
+$
+f = g arrow.double.l.r f(v) = g(v), space.quad forall v in V 
+$
+
+#line(length: 100%)
+=== Понятие нулевой линейной формы
+
+Линейная флома $theta$ называется *нулевой (нуль-формой)*, если 
+
+$
+theta(v) = 0, space.quad forall v in V 
+$
+
+Очевидно, что мы можем определить действия на множестве форм. 
+
+#line(length: 100%)
+
+=== Понятие суммы линейных форм 
+
+*Суммой* линейных форм $f$ и $g$ называется отображение $h = f + g$, для которого справедливо 
+
+$
+h(v) = f(v) + g(v), space.quad forall v in V
+$
+
+#line(length: 100%)
+
+=== Лемма 
+
+Отображение $h$ является линейной формой. 
+
+_Доказательство_. Покажем справедливость свойства аддитивности: 
+
+$
+h(v_1 + v_2) = f(v_1 + v_2) + g(v_1 + v_2) = f(v_1) + f(v_2) + g(v_1) + g(v_2) =
+$
+
+$
+= (f(v_1) + g(v_1)) + (f(v_2) + g(v_2)) = h(v_1) + h(v_2)
+$
+
+Выполнение свойства однородности показывается аналогично. 
+
+#line(length: 100%)
+
+=== Понятие произведения линейной формы на число 
+
+*Произведением* линейной формы $f$ на число $alpha in KK$ называется отображение $l = alpha f$ такое, что 
+
+$
+l(v) = alpha dot f(v), space.quad forall v in V 
+$
+
+_Доказательство_. Аналогично лемме о сумме линейных форм.
+
+#line(length: 100%)
+
+=== Теорема 
+
+Множество линейных форм $V^*$, заданных на линейном пространстве $V$ образует линейное (сопряженное) пространство. 
+
+Рассмотрим некоторый базис ${e_i}_(i = 1)^n$ в пространстве $V$. Введем набор линейных форм ${f^j}_(j = 1)^n$ следующим образом: 
+
+$
+f^j(v) = v_j,
+$
+
+которая возвращает $j$-ю координату вектора $v in V$ в базисе ${e_i}_(i = 1)^n$. Очевидно, что для линейных форм из этого набора справедливо 
+
+$
+f^j (e_i) = delta_i^j = cases(1", если " i = j, 0", если " i eq.not j) 
+$
+
+#line(length: 100%)
+
+=== Лемма
+
+Набор линейных форм ${f^j}_(j = 1)^n$ является базисом в сопряженном пространстве $V^*$. 
+
+_Доказательство_. Чтобы показать справедливость утверждения, необходимо доказать полноту и линейную независимость этого набора. Покажем сначала полноту: 
+
+$
+f(v) = sum_(i = 1)^n phi_i v^i = sum_(i = 1)^n phi_i f^i (v) = (sum_(i = 1)^n phi_i f^i) (v)
+$
+
+Аналогично с линейной независимостью. Предположим, что линейная комбинация форм с некоторыми коэффициентами $alpha_i$ равна нуль-форме. 
+
+$
+sum_(i = 1)^n alpha_i f^i = theta
+$
+
+Применяя эту нуль-форму к произвольному базисному вектору, получим 
+
+$
+(sum_(i = 1)^n alpha_i f^i) (e_k) = theta(e_k) = 0
+$
+
+Учитывая также свойства линейности и их определение 
+
+$
+sum_(i = 1)^n alpha_i f^i (e_k) = 0 space.quad arrow.double space.quad alpha_k f^k (e_k) = 0 space.quad arrow.double space.quad alpha_k = 0
+$
+
+#line(length: 100%)
+
+=== Теорема
+
+Пусть ${f^i}_(i = 1)^n$ и ${tilde(f^l)}_(l = 1)^n$ - базисы $V^*$, сопряженные соответственно базисам ${e^j}_(j = 1)^n$ и ${tilde(e)^k}_(k = 1)^n$. Тогда 
+
+$
+tilde(f^l) = sum_(i = 1)^n sigma_i^l f^i 
+$
+
+где $(sigma_i^l) = S$ - элементы обратной матрицы перехода, полагая $(tau_k^j) = T$ - матрица перехода из ${e^j}_(j = 1)^n$ в ${tilde(e)^k}_(k = 1)^n$. 
+
+_Доказательство_. По определению сопряженных базисов имеем 
+
+$
+tilde(f^l)(tilde(e)_k) = sum_(i = 1)^n sigma_i^l f^i (sum_(i = 1)^n tau_k^j e_j) = sum_(i = 1)^n sum_(j = 1)^n sigma_i^l tau_k^j f^i (e_j) = 
+$
+
+$
+= sum_(i = 1)^n sum_(j = 1)^n sigma_i^l tau_k^j delta_j^i = sum_(i = 1)^n sum_(j = 1)^n sigma_i^l tau_k^i = delta_k^l 
+$
+
+Откуда следует, что произведение матрицы, составленной из $sigma_i^l$, на матрицу перехода с элементами $tau_k^i$ должно быть равно единичной матрице. А это есть не что иное как определение обратной матрицы. 
+
+#line(length: 100%)
+
+=== Теорема 
+
+Преобразование координат формы в $V^*$ при переходе от базиса ${f^i}_(i = 1)^n$ к базису ${tilde(f)}_(l = 1)^n$ имеет вид 
+
+$
+tilde(eta_l) = f(tilde(e_l)) = sum_(i = 1)^n eta_i f^i (sum_(j = 1)^n tau_l^j e_j) = sum_(i = 1)^n sum_(j = 1)^n eta_i tau_l^j f^i (e_j) = 
+$
+
+$
+sum_(i = 1)^n sum_(j = 1)^n eta_i tau_l^j delta_j^i = sum_(i = 1)^n tau_l^i eta_i 
+$
+
+#line(length: 100%)
+
+=== Лемма 
+
+Пространство $V$ и сопряженное пространство $V^*$ изоморфны. 
+
+_Доказательство_. Справедливость утверждения следует из того, что $dim V = dim V^*$ (мощности базисов равны), а следовательно 
+
+$
+V tilde.eq KK_n tilde.eq V^*
+$
+
+Изоморфизм устанавливается введенным соответствием между базисами пространств $V$ и $V^*$. 
+
+Отметим, что операцию нахождения сопряженного пространства можно применять итеративно. 
+
+#line(length: 100%)
+
+=== Понятие второго сопряженного пространства 
+
+Элементами второого сопряженного пространства являются функции, также обладающие линейностью, от линейных форм. 
+
+#line(length: 100%)
+
+=== Теорема 
+
+Между пространствами $V$ и $V^(**)$ можно установить изоморфизм без использования базиса (канонический изоморфизм). 
+
+_Доказательство_. Рассмотрим элементы второго сопряженного пространства $hat(v), hat(u) in V^(**)$: 
+
+$
+hat(v) : V^* arrow KK, space.quad hat(v)(f) in KK
+$
+
+$
+hat(v)(f + g) = hat(v)(f) + hat(v)(g), space.quad hat(v)(alpha f) = alpha hat(v) (f)
+$
+
+$
+(hat(v) + hat(u))(f) = hat(v)(f) + hat(u)(f), space.quad (alpha hat(v))(f) = alpha hat(v)(f)
+$
+
+Канонический изоморфизм устанавливается отношением 
+
+$
+hat(x) arrow.l.r x : space.quad hat(v)(f) = f(v) space.quad forall f in V^* 
+$
+
+#line(length: 100%)
+
+=== Понятие билинейной формы 
+
+*Билинейной формой* на линейном пространстве $V(KK)$ называется такая функция $b : V times V arrow KK$, что $forall x, x_1, x_2, y, y_1, y_2 in V, forall lambda_1, lambda_2 in KK$ выполняется: 
+(а) Линейность по первому аргументу: 
+
+$
+b(lambda_1 x_1 + lambda_2 x_2, y) = lambda_1 b(x_1, y) + lambda_2 b(x_2, y)
+$
+
+(б) Линейность по второму аргументу: 
+
+$
+b(x, lambda_1 y_1 + lambda_2 y_2) = lambda_1 b(x, y_1) + lambda_2 b(x, y_2)
+$
+
+#line(length: 100%)
+
+=== Замечание 
+
+Билинейная форма при фиксировании одного из аргументов есть ничто иное как линейная форма согласно определению, которое было введено ранее. Отсюа сразу следует первый пример. 
+
+#line(length: 100%)
+
+=== Пример 
+
+Пусть $f, g in V^*$ - линейные формы в пространстве $V(KK)$. Билинейная форма может быть задана как 
+
+$
+b : V times V arrow KK, space.quad b(x, y) = f(x) dot g(y)
+$
+
+#line(length: 100%)
+
+=== Пример 
+
+Скалярное произведение геометрических векторов на плоскости (в пространстве) линейно по каждому из аргументов, а следовательно является билинейной формой.  
+
+#line(length: 100%)
+
+=== Пример 
+
+Пусть $V eq KK^n$ - арифметическое пространство. Билинейную форму можно задать как 
+
+$
+b(x, y) = sum_(i = 1)^n sum_(j = 1)^n beta_(i j)epsilon^i eta^j, 
+$
+
+где $x eq (epsilon^1, epsilon^2, dots, epsilon^n)^T in V$ и $y = (eta^1, eta^2, dots, eta^n)^T in V$. 
+
+#line(length: 100%)
+
+=== Замечание 
+
+Последний пример примечателен тем, что любую билинейную форму можно представить в таком виде. 
+
+Рассмотрим $"Bil"_KK(V)$ - множество всех билинейных форм с аргументами из $V$. Для этого множества справедливо следующее. 
+
+(а) Билинейные формы $b, b' in "Bil"_KK (V)$ равны тогда и только тогда, когда принимают равные значения на одинаковых парах аргументов: 
+
+$
+b = b' space.quad arrow.double.l.r space.quad b(x, y) = b'(x, y) space.quad forall x, y in V 
+$
+
+(б) Существует нулевая билинейная форма $theta in "Bil"_KK (V)$, принимающая $0 in KK$ на любой паре аргументов. 
+
+$
+theta in "Bil"_KK (V) : space.quad theta(x, y) = 0, space.quad forall x, y in V 
+$
+
+(в) Может быть определена сумма билинейных форм $b, b' in "Bil"_KK (V)$ как отображение вида 
+
+$
+c = b + b' space.quad arrow.double.l.r space.quad c(x, y) = b(x, y) + b'(x, y), space.quad forall x, y in V
+$
+
+(г) Может быть определено умножение билинейной формы $b in "Bil"_KK (V)$ на скаляр $lambda in KK$ как отображение вида 
+
+$
+d = lambda b space.quad arrow.double.l.r space.quad d(x, y) = lambda b(x, y), space.quad forall x, y in V
+$
+
+#line(length: 100%)
+
+=== Лемма 
+
+Отображение $c$ и $d$ являются билинейными формами. 
+
+_Доказательство_. Аналогично соответствующим утверждениям для линейных форм. 
+
+#line(length: 100%)
+
+=== Лемма 
+
+Множество $"Bil"_KK (V)$ наделено структурой линейного пространства. 
+
+_Доказательство_. Можно убедиться путем прямой проверки аксиом линейного пространства. 
+
+#line(length: 100%)
+
+=== Понятие симметричной билинейной формы 
+
+Билинейная форма $b in "Bil"_KK (V)$ называется *симметричной*, если выполняется $b(x, y) = b(y, x)$. 
+
+#line(length: 100%)
+
+=== Понятие антисимметричной билинейной формой 
+
+Билинейная форма $b in "Bil"_KK (V)$ называется *антисимметричной*, если выполняется $b(x, y) = -b(y, x)$. 
+
+#line(length: 100%)
+
+=== Лемма 
+
+Сумма симметричной и антисимметричной формы, построенных согласно процедуре выше, дает исходную билинейную форму. 
+
+_Доказательство_. Убеждаемся непосредственной проверкой: 
+
+$
+b^S (x, y) + b^(A S)(x, y) = frac(1, 2) (b(x, y) + b(y, x)) + frac(1, 2)(b(x, y) - b(y, x)) = b(x, y)
+$
+
+#line(length: 100%)
+
+=== Лемма
+
+Пространство билинейных форм представляется в виде прямой суммы подпространств симметричных и антисимметричных билинейных форм. 
+
+$
+"Bil"_KK (V) = "Bil"_KK^S (V) xor "Bil"_KK^(A S)(V)
+$
+
+_Доказательство_. 
+
+Процедура изготовления симметричных (антисимметричных) форм, описанная выше, позволяет заключить, что 
+
+$
+"Bil"_KK (V) = "Bil"_KK^S (V) + "Bil"_KK^(A S) (V)
+$
+
+Покажем, что сумма будет прямой. Пусть билинейная форма $h(x, y)$ такова, что $h in "Bil"_KK^S (V) inter "Bil"_KK^(A S) (V)$. Тогда имеем 
+
+$
+cases(h(x, y) = h(y, x), h(x, y) = -h(y, x)) space.quad arrow.double h(y, x) = -h(y, x) space.quad arrow.double arrow.quad h(x, y) = 0 space.quad forall x, y in V 
+$
+
+В пересечении подпространств лежит только нулевая билинейная форма. Следовательно сумма является прямой.
+
+
+#line(length: 100%)
+
+=== Понятие коэффициентов билинейной формы 
+
+*Коэффициентами* $beta_(i j)$ билинейной формы $b(x, y)$ называются значения этой линейной формы на базисных векторах пространства. 
+
+$
+b(e_i, e_j) = beta_(i j)
+$
+
+#line(length: 100%)
+
+
+=== Теорема 
+
+Задание билинейной формы эквивалентно заданию ее значений на базисных векторах, т. е. заданию ее коэффициентов. 
+
+_Доказательство_. Пусть в выбранном базисе ${e_i}_(i = 1)^n$ линейного пространства $V$ билинейная форма $b(x, y)$ задана набором коэффициентов ${beta_(i j)}_(i, j = 1)^n$. Тогда $forall x = sum_(i = 1)^n xi^i e_i, space y = sum_(j = 1)^n eta^j e_j:$
+
+$
+b(x, y) = b(sum_(i = 1)^n xi^i e_i, space sum_(j = 1)^n eta^j e_j) = sum_(i = 1)^n sum_(j = 1)^n xi^i eta^j b(e_i, e_j) = sum_(i = 1)^n sum_(j = 1)^n xi^i eta^j beta_(i j) 
+$
+
+По аналогии с линейными формами, коэффициенты которых можно представить в виде вектора-строки, существует аналогичное представление для билинейной формы. 
+
+=== Понятие матрицы билинейной формы 
+
+Матрицей билинейной формы $b(x, y)$ называется матрица $B$, составленная из ее коэффициентов.
+
+#line(length: 100%)
+
+=== Лемма 
+
+Пространство билинейных форм $"Bil"_KK (V)$ изоморфно пространству квадратных матриц $M_n(KK)$. 
+
+_Доказательство_. Изоморфизм устанавливается следующим образом: 
+
+$
+b arrow.l.r B space.quad b' arrow.l.r B'
+$
+
+$
+b + b' arrow.l.r B + B' 
+$
+
+$
+lambda b arrow.l.r lambda B
+$
+
+Соответствие между линейными операциями с билинейными формами и матрицами проверяется непосредственной проверкой определений. 
+
+#line(length: 100%)
+
+=== Теорема 
+
+Матрицы $B$ и $B'$ билинейной формы $b(x, y)$, заданные в базисах ${e_i}_(i = 1)^n$ и ${e_j^'}_(j = 1)^n$ связаны соотношением 
+
+$
+B' = C^T B C, 
+$
+
+где $C = (c_j^i)$ - матрица перехода от базиса ${e_i}_(i = 1)^n$ к базису ${e_j^'}_(j = 1)^n$. 
+
+_Доказательство_. Полагая, что известна матрица перехода $C = (c_j^i)$, компоненты нового базиса можно выразить через векторы старого базиса как 
+
+$
+e_j^' = sum_(i = 1)^n c_j^i e_i
+$
+
+Воспользуемся этим, чтобы получить компоненты матрицы билинейной формы в новом базисе 
+
+$
+beta_(i j)^' = b(e_i^', e_j^') = b(sum_(k = 1)^n c_i^k e_k, space sum_(l = 1)^n c_j^l e_l) = sum_(k = 1)^n sum_(l = 1)^n c_i^k c_j^l b(e_k, e_l) = sum_(k = 1)^n sum_(l = 1)^n c_i^k c_j^l beta_(k l), 
+$
+
+где $beta_(k l) = b(e_k, e_l)$ для всех $k, l = 1, dots n$ - коэффициенты матрицы билинейной формы в старом базисе. Данное двойное суммирование означает ничто иное как матричное умножение, которое можно записать в виде 
+
+$
+B' = C^T B C 
+$
+
+Данное утверждение легко проверяется прямым раскрытием матричного умножения в индексном виде. 
+
+#line(length: 100%)
+
+=== Понятие квадратичной формы 
+
+*Квадратичной формой* на линейном пространстве $V$ называется отображение $q(v)$, построенное из билинейной формы $b(x, y)$ следующим образом: 
+
+$
+q : V arrow KK, space.quad q(v) = b(v, v), space.quad forall x in V 
+$
+
+#line(length: 100%)
+
+=== Лемма
+
+Квадратичная форма является однородным полиномом степени 2 от координат вектора. 
+
+_Доказательство_. Справедливы следующие рассуждения: 
+
+$
+q(lambda v) = b(lambda v, lambda v) = lambda^2 b(v, v) = lambda^2 q(v)
+$
+
+Тем самым мы показали, что квадратичная форма является однородной функцией 2-го порядка. Зафиксируем теперь базис ${e_i}_(i = 1)^n$ в пространстве $V$. Произвольный вектор можем разложить по этому базису единственным образом $v = sum_(i = 1)^n v^i e_i$. Тогда квадратичная функция в координатном представлении имеет вид 
+
+$
+q(v) = q(sum_(i = 1)^n v^i e_i) = b(sum_(i = 1)^n v^i e_i, space sum_(j = 1)^n v^j e_j) = 
+$
+
+$
+= sum_(i = 1)^n sum_(j = 1)^n v^i v^j b(e_i, e_j) = sum_(i = 1)^n sum_(j = 1)^n v^i v^j beta_(i j), 
+$
+
+где $beta_(i j)$ - коэффициенты билинейной формы, по которой построена квадратичная форма $q(v)$. 
+
+=== Лемма 
+
+По квадратичной форме $q(v)$ однозначно восстанавливается симметричная компонента билинейной формы $b(x, y)$. 
+
+_Доказательство_. Рассмотрим квадратичную форму от суммы векторов $x, y in V$: 
+
+
+$
+q(x + y) = b(x + y, x + y) = b(x, x) + b(x, y) + b(y, x) + b(y, y) = q(x) + b(x, y) + b(y, x) + q(y) 
+$
+
+Откуда 
+
+$
+b(x, y) + b(y, x) = q(x + y) - q(x) - q(y)
+$
+
+Если билинейную форму полагать симметричной, т.е. $b in "Bil"^S(V)$, то имеем 
+
+$
+b(x, y) = frac(1, 2) (q(x + y) - q(x) - q(y))
+$
+
+#line(length: 100%)
+
+=== Понятие полилинейной формы 
+
+*Полилинейной формой* на линейном пространстве $V(KK)$ назовем отображение вида 
+
+$
+cal(A) : V times dots times V times V^* times dots times V^* arrow KK 
+$
+
+обладающее линейностью по каждому из аргументов 
+
+$
+cal(A)(x_1, dots, alpha x_i^' + beta x_i^(''), dots, x_p; phi^1, dots, phi^q) = 
+$
+
+$
+= alpha cal(A) (x_1, dots, x_i^', dots, x_p; phi^1, dots, phi^q) + beta cal(A) (x_1, dots, x_i^(''), dots, x_p; phi^1, dots, phi^q), 
+$
+
+где $x_i in V$ и $phi^j in V^*$. 
+
+#line(length: 100%)
+
+=== Понятие валентности полилинейной формы 
+
+*Валентностью* полилинейной формы называют пару чисел $(p, q)$, определяющих количество векторов и ковекторов (линейных форм), являющихся аргументами данного отображения. 
+
+#line(length: 100%)
+
+=== Понятие равных полилинейных форм 
+
+Полилинейные формы $cal(A), cal(B) in Omega^p_q$ одинаковой валентности будем называть *равными*, если 
+
+$
+cal(A)(x_1, x_2, dots, x_p; phi^1, phi^2, dots, phi^q) = cal(B)(x_1, x_2, dots, x_p; phi^1, phi^2, dots, phi^q)
+$
+
+для любых наборов $x_1, x_2, dots, x_p in V$ и $phi^1, phi^2, dots, phi^q in V^*$. 
+
+#line(length: 100%)
+
+=== Понятие нуль-формы 
+
+*Нуль-формой* $Theta in Omega_q^p$ называется такая полилинейная форма, что 
+
+$
+Theta (x_1, x_2, dots, x_p; phi^1, phi^2, dots, phi^q) = 0 space.quad forall x_i in V, space forall phi^j in V^*
+$
+
+Пусть $cal(A)$ и $cal(B)$ - полилинейные формы валентности $(p, q)$. Введем операции с ними. 
+
+#line(length: 100%)
+
+=== Понятие суммы полилинейных форм 
+
+Отображение $cal(C) = cal(A) + cal(B)$ будем называть суммой полилинейных форм $cal(A)$ и $cal(B)$, если 
+
+$
+cal(C)(x_1, x_2, dots, x_p; phi^1, phi^2, dots, phi^q) =  
+$
+
+$
+= cal(A)(x_1, x_2, dots, x_p; phi^1, phi^2, dots, phi^q) + cal(B)(x_1, x_2, dots, x_p; phi^1, phi^2, dots, phi^q)
+$
+
+для любых наборов $x_1, x_2, dots, x_p in V$ и $phi^1, phi^2, dots, phi^q in V^*$. 
+
+#line(length: 100%)
+
+=== Лемма 
+
+Отображение $cal(C)$, определенное как сумма полилинейных форм $cal(A), cal(B) in Omega_q^p$ является полилинейной формой из $Omega_q^p$ 
+
+_Доказательство_. Доказательство строится также как аналогичное доказательство для линейных и билинейных форм.
+
+#line(length: 100%)
+
+=== Понятие произведения полилинейной формы на скаляр 
+
+Отображение $lambda cal(A)$ будем называть произведением полилинейной формы $cal(A)$ на скаляр $lambda$, если 
+
+$
+(lambda cal(A))(x_1, x_2, dots, x_p; phi^1, phi^2, dots, phi^q) = lambda dot cal(A)(x_1, x_2, dots, x_p; phi^1, phi^2, dots, phi^q)
+$
+
+для любых наборов $x_1, x_2, dots, x_p in V$ и $phi^1, phi^2, dots, phi^q in V^*$. 
+
+#line(length: 100%)
+
+=== Лемма 
+
+Отображение $lambda cal(A)$, определенное как произведение полилинейной формы $cal(A) in Omega_q^p$ на скаляр $lambda in KK$ является полилинейной формой из $Omega_q^p$ 
+
+_Доказательство_. Доказательство строится также как аналогичное доказательство для линейных и билинейных форм. 
+
+#line(length: 100%)
+
+=== Теорема 
+
+Множество $Omega_q^p$ полилинейных форм валентности $(p, q)$ образует линейное пространство. 
+
+_Доказательство_. Доказательство сводится к проверке аксиом линейного пространства. 
+
+#line(length: 100%)
+
+=== Понятие произведения полилинейных форм 
+
+Произведением полилинейных форм $cal(A) in Omega_(q_1)^(p_1)$ и $cal(B) in Omega_(q_2)^(p_2)$ называют отображение $cal(C) = cal(A) dot cal(B)$  определяемое как 
+
+$
+cal(A)(x_1, dots, x_(p_1) ; phi^1, dots, phi^(q_1)) dot cal(B)(x_(p_1 + 1), dots, x_(p_1 + p_2); phi^(q_1 + 1), dots, phi^(q_1 + q_2)) = 
+$
+
+$
+= cal(C)(x_1, dots, x_(p_1), x_(p_1 + 1), dots, x_(p_1 + p_2) ; phi^1, dots, phi^(q_1), phi^(q_1 + 1), dots, phi^(q_1 + q_2))
+$
+
+#line(length: 100%)
+
+=== Лемма
+
+Отображение $cal(C)$, введенное как произведение полилинейных форм, является полилинейной формой. 
+
+$
+cal(C) in Omega_(q_1 + q_2)^(p_1 + p_2)
+$
+
+_Доказательство_. Не теряя общности, мы можем показать линейность по первому векторному аргументу. Для остальных доказательство может быть построено аналогичным образом, но его запись при этом усложнится значительно. Пусть произведение полилинейных форм задается следующим образом: 
+
+$
+cal(C)(x, dots ; dots) = cal(A)(x, dots ; dots) dot cal(B)(dots, dots ; dots), 
+$
+
+где через многоточия обозначены остальные аргументы всех полилинейных форм согласно определению выше. 
+
+При этом, если аргумент $x$ представлен линейной комбинацией $x = alpha_1 x_1 + alpha_2 x_2$, имеем 
+
+$
+cal(C)(alpha_1 x_1 + alpha_2 x_2, dots ; dots) = cal(A)(alpha_1 x_1 + alpha_2 x_2, dots ; dots) dot cal(B)(dots ; dots) = 
+$
+
+$
+(alpha_1 cal(A)(x_1, dots ; dots) + alpha_2 cal(A)(x_2, dots ; dots)) dot cal(B)(dots ; dots) = 
+$
+
+$
+alpha_1 cal(A)(x_1, dots ; dots) dot cal(B)(dots ; dots) + alpha_2 cal(A)(x_2, dots ; dots) dot cal(B)(dots ; dots) = 
+$
+
+$
+alpha_1 cal(C)(x_1, dots ; dots) + alpha_2 cal(C)(x_2, dots ; dots),
+$
+
+где мы воспользовались свойством полилинейности отображения $cal(A)$. В силу того, что это отображение линейно по каждому из аргументов, данные рассуждения справедливы по набору его аргументов. А также в силу того, что отображение $cal(B)$ тоже является полилинейным, свойство линейности отображения $cal(C)$ по каждому из аргументов набора из $cal(B)$.  
+
+#line(length: 100%)
+
+=== Свойства произведения полилинейных форм 
+
+(а) Некоммутативность 
+
+$
+cal(A) dot cal(B) eq.not cal(B) dot cal(A)
+$
+
+Данное свойство очевидно вытекает из определения произведения в силу того, что порядок произведения $cal(A)$ и $cal(B)$ определяет порядок аргументов в $cal(C)$. Однако продемонстрируем это свойство на более простом примере. Рассмотрим следующие полилинейные формы, определенные как произведения обычных линейных форм $f^1, f^2 in V^*$
+
+$
+cal(C)_1 = f^1 dot f^2 space.quad arrow.double space.quad cal(C)_1 (x, y) = f^1(x) dot f^2(y)
+$
+
+$
+cal(C)_2 = f^2 dot f^1 space.quad arrow.double space.quad cal(C)_2 (x, y) = f^2(x) dot f^1(y)
+$
+
+(б) Ассоциативность 
+
+$
+cal(A) dot (cal(B) dot cal(C)) = (cal(A) dot cal(B)) dot cal(C)
+$
+
+(в) Нуль-форма 
+
+$
+cal(A) dot Theta_((p_2, q_2)) = Theta_((p_1, q_1)) dot cal(B) = Theta_((p_1 + p_2, q_1 + q_2))
+$
+
+(г) Законы согласования операций (дистрибутивность) 
+
+$
+cal(A) dot (cal(B) + cal(C)) = cal(A) dot cal(B) + cal(A) dot cal(C)
+$
+
+$
+(cal(A) + cal(B)) dot cal(C) = cal(A) dot cal(C) + cal(B) dot cal(C)
+$
+
+$
+(alpha cal(A)) dot cal(B) = alpha (cal(A) dot cal(B)) = cal(A) dot (alpha cal(B))
+$
+
+=== Понятие тензора полилинейной формы
+
+Зафиксируем в $V(KK)$ базис ${e_i}_(i = 1)^n$ и построим к нему сопряженный базис ${f^j}_(j = 1)^n$ в пространстве $V^*$. Вспомним, что эти базисы связаны соотношением 
+
+$
+f^j(e_i) = delta_i^j = cases(1", "i = j, 0", "i eq.not j)
+$
+
+*Тензором* полилинейной формы $cal(C)$ валентности $(p, q)$ называется набор из $n^(p + q)$ скаляров, определяемых как действие полилинейной формы на всевозможных наборах базисных векторов. 
+
+$
+c_(i_1 i_2 dots i_p)^(j_1 j_2 dots j_q) = cal(C)(e_(i_1), e_(i_2), dots, e_(i_p); f^(j_1), f^(j_2), dots, f^(j_q)), 
+$
+
+где индексы $i_1, i_2, dots, i_p$ и $j_1, j_2, dots, j_q$ принимаются значения $1, dots, n$, где $n = dim V$ - это размерность пространства $V$. 
+
+=== Замечание о немом суммировании 
+
+Прежде чем перейдем к дальнейшим рассуждениям, отметим следующий факт. Наличие большого количества индексов в случае анализа линейных объектов нередко приводит к большому количеству суммирований как в теоретических выкладках, так и в практических приложениях тензоров. По этой причине вводится так называемое *правило суммирования Эйнштейна*, или соглашение о немом суммировании. В контексте данной темы договоримся о следующем: 
+
+(а) Если в одночлене присутствует одинаковый верхний и нижний индекс, то подразумевается суммирование по нему: 
+
+$
+a^i b_i = sum_i a^i b_i 
+$
+
+(б) Индекс, по которому происходит суммирование, называют немым в силу того, что его обозначение не принципиально, т. е. 
+
+$
+a^i b_i = a^j b_j = a^k b_k 
+$
+
+(в) Необходимо соблюдение баланса индексов. Если индекс не является немым, то в левой и правой частях равенства должны присутствовать одни и те же индексы, а также должен быть неизменным их порядок, т.е. 
+
+$
+e_(i k)b^(k l) = c_i^l
+$
+
+#line(length: 100%)
+
+=== Теорема 
+
+Задание тензора эквивалентно заданию его компонент в паре базисов пространств $V$ и $V^*$. 
+
+_Доказательство_. Рассмотрим набор векторов $x_1, dots, x_p$ и форм $phi^1, dots, phi^q$, заданных своими разложениями по базисам 
+
+$
+x_k = sum_(i = 1)^n xi_k^i e_i = xi^i_k e_i space.quad phi^l = sum_(j = 1)^n eta_j^l f^j = eta_j^l f^j 
+$
+
+Применим к ним тензор $cal(C)(x_1, dots, x_p; pphi^1, dots, phi^q)$ и воспользуемся его линейными свойствами 
+
+$
+cal(C)(x_1, dots, x_p; phi^1, dots, phi^q) = cal(C)(xi_1^(i_1)e_(i_1), dots, xi_p^(i_p)e_(i_p); eta^1_(j_1) f^(j_1), dots, eta_(j_q)^q f^(j_q)) = 
+$
+
+$
+= xi_1^(i_1) xi_2^(i_2) dots xi_p^(i_p) eta^1_(j_1) eta^2_(j_2) dots eta^q_(j_q) cal(C)(e_(i_1), e_(i_2), dots, e_(i_p) ; f^(j_1), f^(j_2), dots, f^(j_q)) = 
+$
+
+$
+= xi_1^(i_1) xi_2^(i_2) dots xi_p^(i_p) eta^1_(j_1) eta^2_(j_2) dots eta^q_(j_q) c_(i_1 i_2 dots i_p)^(j_1 j_2 dots j_q), 
+$
+
+где в данной записи мы как раз воспользовались соглашением о немом суммировании. 
+
+#line(length: 100%)

algorithms/labs/lab6/code/1.py

@@ -0,0 +1,29 @@
+def thief_knapsack(weights, values, M, K):
+    cap = M * K
+    n = len(weights)
+    dp = [0] * (cap + 1)
+    take = [[False] * (cap + 1) for _ in range(n)]
+    for i in range(n):
+        w = weights[i]
+        v = values[i]
+        for c in range(cap, w - 1, -1):
+            if dp[c - w] + v > dp[c]:
+                dp[c] = dp[c - w] + v
+                take[i][c] = True
+    c = cap
+    items = []
+    for i in range(n - 1, -1, -1):
+        if take[i][c]:
+            items.append(i)
+            c -= weights[i]
+    items.reverse()
+    return dp[cap], items
+
+
+if __name__ == "__main__":
+    weights = [2, 3, 4, 5, 9, 7, 3]
+    values = [3, 4, 5, 8, 10, 7, 6]
+    M = 2
+    K = 10
+    best, items = thief_knapsack(weights, values, M, K)
+    print(best, items)

algorithms/labs/lab6/code/2.py

@@ -0,0 +1,35 @@
+def matrix_chain_order(p):
+    n = len(p) - 1
+    m = [[0] * n for _ in range(n)]
+    s = [[0] * n for _ in range(n)]
+    for L in range(2, n + 1):
+        for i in range(n - L + 1):
+            j = i + L - 1
+            m[i][j] = 10**18
+            for k in range(i, j):
+                q = m[i][k] + m[k + 1][j] + p[i] * p[k + 1] * p[j + 1]
+                if q < m[i][j]:
+                    m[i][j] = q
+                    s[i][j] = k
+    return m, s
+
+
+def build_parenthesization(s, i, j, names):
+    if i == j:
+        return names[i]
+    k = s[i][j]
+    return (
+        "("
+        + build_parenthesization(s, i, k, names)
+        + build_parenthesization(s, k + 1, j, names)
+        + ")"
+    )
+
+
+if __name__ == "__main__":
+    p = [30, 35, 15, 5, 10, 20, 25]
+    names = ["A", "B", "C", "D", "E", "F"][: len(p) - 1]
+    m, s = matrix_chain_order(p)
+    expr = build_parenthesization(s, 0, len(p) - 2, names)
+    print(m[0][len(p) - 2])
+    print(expr)

algorithms/labs/lab6/code/3.py

@@ -0,0 +1,29 @@
+def longest_increasing_run(a):
+    if not a:
+        return 0, -1, -1
+    best_len = 1
+    best_l = 0
+    best_r = 0
+    cur_len = 1
+    cur_l = 0
+    for i in range(1, len(a)):
+        if a[i] > a[i - 1]:
+            cur_len += 1
+        else:
+            if cur_len > best_len:
+                best_len = cur_len
+                best_l = cur_l
+                best_r = i - 1
+            cur_len = 1
+            cur_l = i
+    if cur_len > best_len:
+        best_len = cur_len
+        best_l = cur_l
+        best_r = len(a) - 1
+    return best_len, best_l, best_r
+
+
+if __name__ == "__main__":
+    a = [1, 2, 3, -1, 0, 1, 1, 2, 3, 4, -5]
+    length, l, r = longest_increasing_run(a)
+    print(length, l, r)

algorithms/labs/lab6/leetcode/1/link.txt

@@ -0,0 +1 @@
+https://leetcode.com/problems/regular-expression-matching/submissions/1769086671/?envType=problem-list-v2&envId=dynamic-programming

algorithms/labs/lab6/leetcode/1/solution.py

@@ -0,0 +1,14 @@
+class Solution:
+    def isMatch(self, s: str, p: str) -> bool:
+        from functools import lru_cache
+
+        @lru_cache(None)
+        def dp(i: int, j: int) -> bool:
+            if j == len(p):
+                return i == len(s)
+            first = i < len(s) and (p[j] == s[i] or p[j] == ".")
+            if j + 1 < len(p) and p[j + 1] == "*":
+                return dp(i, j + 2) or (first and dp(i + 1, j))
+            return first and dp(i + 1, j + 1)
+
+        return dp(0, 0)

algorithms/labs/lab6/leetcode/2/link.txt

@@ -0,0 +1 @@
+https://leetcode.com/problems/longest-valid-parentheses/submissions/1769090768/?envType=problem-list-v2&envId=dynamic-programming

algorithms/labs/lab6/leetcode/2/solution.py

@@ -0,0 +1,15 @@
+class Solution:
+    def longestValidParentheses(self, s: str) -> int:
+        n = len(s)
+        dp = [0] * n
+        best = 0
+        for i in range(1, n):
+            if s[i] == ")":
+                if s[i - 1] == "(":
+                    dp[i] = (dp[i - 2] if i >= 2 else 0) + 2
+                elif i - dp[i - 1] - 1 >= 0 and s[i - dp[i - 1] - 1] == "(":
+                    dp[i] = dp[i - 1] + 2
+                    if i - dp[i - 1] - 2 >= 0:
+                        dp[i] += dp[i - dp[i - 1] - 2]
+                best = max(best, dp[i])
+        return best

algorithms/labs/lab6/leetcode/3/link.txt

@@ -0,0 +1 @@
+https://leetcode.com/problems/trapping-rain-water/?envType=problem-list-v2&envId=dynamic-programming

algorithms/labs/lab6/leetcode/3/solution.py

@@ -0,0 +1,20 @@
+from typing import List
+
+
+class Solution:
+    def trap(self, height: List[int]) -> int:
+        n = len(height)
+        if n == 0:
+            return 0
+        left = [0] * n
+        right = [0] * n
+        left[0] = height[0]
+        for i in range(1, n):
+            left[i] = max(left[i - 1], height[i])
+        right[-1] = height[-1]
+        for i in range(n - 2, -1, -1):
+            right[i] = max(right[i + 1], height[i])
+        ans = 0
+        for i in range(n):
+            ans += min(left[i], right[i]) - height[i]
+        return ans

algorithms/labs/lab7/code/1.py

@@ -0,0 +1,14 @@
+def greedy_change(n, coins):
+    result = []
+    for value, count in sorted(coins, key=lambda x: -x[0]):
+        while count > 0 and n >= value:
+            n -= value
+            count -= 1
+            result.append(value)
+    return result if n == 0 else None
+
+
+if __name__ == "__main__":
+    coins = [(10, 3), (5, 2), (2, 5), (1, 10)]
+    N = 28
+    print(greedy_change(N, coins))

algorithms/labs/lab7/code/2.py

@@ -0,0 +1,20 @@
+def greedy_thief(weights, values, M, K):
+    items = list(zip(weights, values))
+    items.sort(key=lambda x: x[1] / x[0], reverse=True)
+    cap = M * K
+    total_value = 0
+    chosen = []
+    for w, v in items:
+        if w <= cap:
+            chosen.append((w, v))
+            cap -= w
+            total_value += v
+    return total_value, chosen
+
+
+if __name__ == "__main__":
+    weights = [2, 3, 4, 5, 9, 7, 3]
+    values = [3, 4, 5, 8, 10, 7, 6]
+    M = 2
+    K = 10
+    print(greedy_thief(weights, values, M, K))

algorithms/labs/lab7/code/3.py

@@ -0,0 +1,26 @@
+import heapq
+
+
+def dijkstra(graph, start):
+    dist = {v: float("inf") for v in graph}
+    dist[start] = 0
+    pq = [(0, start)]
+    while pq:
+        d, v = heapq.heappop(pq)
+        if d > dist[v]:
+            continue
+        for u, w in graph[v]:
+            if dist[v] + w < dist[u]:
+                dist[u] = dist[v] + w
+                heapq.heappush(pq, (dist[u], u))
+    return dist
+
+
+if __name__ == "__main__":
+    graph = {
+        "Невский": [("Лиговский", 5), ("Гороховая", 3)],
+        "Лиговский": [("Московский", 7)],
+        "Гороховая": [("Московский", 4)],
+        "Московский": [],
+    }
+    print(dijkstra(graph, "Невский"))

algorithms/labs/lab7/leetcode/1/link.txt

@@ -0,0 +1 @@
+https://leetcode.com/problems/wildcard-matching/?envType=problem-list-v2&envId=greedy

algorithms/labs/lab7/leetcode/1/solution.py

@@ -0,0 +1,26 @@
+from typing import List
+
+
+class Solution:
+    def isMatch(self, s: str, p: str) -> bool:
+        i = j = 0
+        star = -1
+        match = 0
+        n, m = len(s), len(p)
+        while i < n:
+            if j < m and (p[j] == s[i] or p[j] == "?"):
+                i += 1
+                j += 1
+            elif j < m and p[j] == "*":
+                star = j
+                match = i
+                j += 1
+            elif star != -1:
+                j = star + 1
+                match += 1
+                i = match
+            else:
+                return False
+        while j < m and p[j] == "*":
+            j += 1
+        return j == m

algorithms/labs/lab7/leetcode/2/link.txt

@@ -0,0 +1 @@
+https://leetcode.com/problems/candy/description/?envType=problem-list-v2&envId=greedy

algorithms/labs/lab7/leetcode/2/solution.py

@@ -0,0 +1,14 @@
+from typing import List
+
+
+class Solution:
+    def candy(self, ratings: List[int]) -> int:
+        n = len(ratings)
+        candies = [1] * n
+        for i in range(1, n):
+            if ratings[i] > ratings[i - 1]:
+                candies[i] = candies[i - 1] + 1
+        for i in range(n - 2, -1, -1):
+            if ratings[i] > ratings[i + 1]:
+                candies[i] = max(candies[i], candies[i + 1] + 1)
+        return sum(candies)

algorithms/labs/lab7/leetcode/3/link.txt

@@ -0,0 +1 @@
+https://leetcode.com/problems/create-maximum-number/?envType=problem-list-v2&envId=greedy

algorithms/labs/lab7/leetcode/3/solution.py

@@ -0,0 +1,46 @@
+from typing import List
+
+
+class Solution:
+    def maxNumber(self, nums1: List[int], nums2: List[int], k: int) -> List[int]:
+        def pick(arr: List[int], t: int) -> List[int]:
+            drop = len(arr) - t
+            st = []
+            for x in arr:
+                while drop and st and st[-1] < x:
+                    st.pop()
+                    drop -= 1
+                st.append(x)
+            return st[:t]
+
+        def greater(a: List[int], i: int, b: List[int], j: int) -> bool:
+            while i < len(a) and j < len(b) and a[i] == b[j]:
+                i += 1
+                j += 1
+            if j == len(b):
+                return True
+            if i < len(a) and a[i] > b[j]:
+                return True
+            return False
+
+        def merge(a: List[int], b: List[int]) -> List[int]:
+            i = j = 0
+            res = []
+            while i < len(a) or j < len(b):
+                if greater(a, i, b, j):
+                    res.append(a[i])
+                    i += 1
+                else:
+                    res.append(b[j])
+                    j += 1
+            return res
+
+        m, n = len(nums1), len(nums2)
+        ans = []
+        for i in range(max(0, k - n), min(k, m) + 1):
+            a = pick(nums1, i)
+            b = pick(nums2, k - i)
+            cand = merge(a, b)
+            if not ans or cand > ans:
+                ans = cand
+        return ans