Олимпиадное программирование в УлГТУ - Вклад [ru]

Система непересекающихся множеств

2026-04-25T19:46:01Z

Ctrlalt:

== Общие сведения ==
Система неперескающихся множеств (англ. disjointed set union, иногда union-find) — специфическая структура данных, содержащая информацию о наборе множеств, которая позволяет объединять множества и отвечать на вопрос, принадлежат ли указанные элементы к одному множеству.

Назначение системы непересекающихся множеств позволяют понять такие метафоры, как задача о постройке дорог между городами, где периодически требуется отвечать на запросы о достижимости одного города из другого, и задача о добавлении друзей в социальной сети, где требуется узнавать, связаны ли два человека цепочкой общих друзей.

Изначально рассматриваются N различных элементов, каждый из которых представляет собой самостоятельное множество. Далее любые два множества допустимо объединять, при этом все элементы обоих множеств становятся элементами результирующего множества. Очевидно, что из начального состояния (N одноэлементных множеств) через (N-1) слияние будет получено состояние, при котором все элементы объединены в одно множество. Как можно будет убедиться в дальнейшем, реализации системы непересекающихся множеств достаточно просто дополнить операцией добавления нового одноэлементного множества (то есть добавления (N+1)-го элемента, формирующего самостоятельное множество).

Любое множество может быть уникальным образом идентифицировано с помощью одного из своих элементов: два множества не могут содержать один и тот же элемент по определению (этот факт отражён словом «непересекающихся» в названии структуры данных). Такой элемент называется ''представителем'' множества (англ. representative element).

== Интерфейс ==
Здесь и далее будем предполагать, что элементами множеств являются целые числа. Система непересекающихся множеств должна обеспечивать следующие операции:

{| class="methodlist"
| || int || find(int x) || — определение представителя множества, которому принадлежит элемент <tt>x</tt>. Очевидно, что если элементы <tt>x</tt> и <tt>y</tt> принадлежат одному множеству, то должно выполняться условие <tt>find(x) == find(y)</tt>. В противном случае должно иметь место <tt>find(x) != find(y)</tt>;
|-
| || void || merge(int x, int y) || — слияние множеств, содержащих элементы <tt>x</tt> и <tt>y</tt>;
|-
| || bool || connected(int x, int y) || — определение принадлежности элементов <tt>x</tt> и <tt>y</tt> к одному множеству. Из определения метода <tt>find()</tt> следует, что данный метод в любых реализациях может иметь единый код: <tt>return find(x) == find(y);</tt>.
|}

== Демонстрация работы ==
* [http://www.cs.usfca.edu/~galles/visualization/DisjointSets.html Data Structure Visualizations — Disjoint Sets]
: В демонстрации элементы-представители содержат ссылки не на самих себя, а на несуществующую ячейку (-1).
* [http://visualgo.net/ufds.html VisuAlgo — Union-Find Disjoint Sets]

== Простейшая реализация: быстрое определение представителя ==
[[Файл:dsu_quickfind_representation.png|thumb|right|360px|Система непересекающихся множеств в простейшей реализации]]
Определим массив <tt>id[]</tt>, <tt>i</tt>-ая ячейка которого будет содержать представителя множества, которому принадлежит элемент <tt>i</tt>.

Изначально каждый элемент системы непересекающихся множеств сам по себе рассматривается как одноэлементное множество, поэтому каждый элемент является собственным представителем. Показанный ниже конструктор использует динамический массив (вектор) для создания системы из <tt>n</tt> непересекающихся множеств.

DSU(int n) {
for (int i = 0; i < n; i++)
id.push_back(i); //id[i] == i;
}

=== Определение представителя ===
[[Файл:dsu_quickfind_find.png|thumb|right|360px|Быстрое определение представителя]]
Как показано выше, массив <tt>id[]</tt> содержит в своих ячейках значения представителей для всех элементов. Поэтому для вывода представителя в данной реализации достаточно вернуть значение соответствующей ячейки массива <tt>id[]</tt>.

int find(int x) {
return id[x];
}

Можно видеть, что сложность операции определения представителя в этой реализации — O(1).

=== Объединение множеств ===
[[Файл:dsu_quickfind_union.png|thumb|right|360px|Объединение множеств в простейшей реализации]]
После слияния множеств должна сохраняться работоспособность операции <tt>find()</tt>, то есть все элементы объединённого множества должны иметь одного и того же представителя. Так как до объединения часть элементов имеет представителя <tt>a</tt>, а другая часть — представителя <tt>b</tt>, проще всего изменить все упоминания <tt>a</tt> на <tt>b</tt>:

void merge(int x, int y) {
int rx = find(x), ry = find(y);
if (rx == ry)
return;
for (int i = 0; i < id.size(); i++)
if (id[i] == rx)
id[i] = ry;
}

Таким образом, объединение требует прохода по всему массиву, что увеличивает его сложность до O(N). Данное значение для многих задач является неудовлетворительным, поэтому разработаны реализации, позволяющие осуществлять объединение множеств с меньшей асимптотикой.

== Вторая реализация: быстрое объединение ==
[[Файл:dsu_quickunion_representation.png|thumb|right|360px|Система непересекающихся множеств: реализация для быстрого объединения]]
Идея данной реализации в том, что при объединении множеств изменяется лишь один элемент массива <tt>id[]</tt>. Чтобы это стало возможным, прежде всего необходимо определить несколько условий:

*Теперь элементы множества будут представлены в некоторой многоуровневой древовидной структуре;
*<tt>i</tt>-ая ячейка массива <tt>id[]</tt> будет содержать значение элемента, к которому в этой структуре присоединён элемент <tt>i</tt>;
*Если некоторый элемент <tt>i</tt> не присоединён к другому элементу, то выполняется <tt>id[i] == i</tt>. Очевидно, что в каждой древовидной структуре найдётся элемент, обладающий таким свойством — это корень древовидной структуры. Важно, что от любого элемента структуры можно дойти до корневого элемента через некоторое конечное число «подъёмов» по массиву <tt>id[]</tt>. Эта особенность позволяет использовать корень древовидной структуры в качестве представителя множества.

Конструктор системы непересекающихся множеств остаётся прежним, так как в одноэлементном множестве единственный элемент будет являться корнем и в массиве <tt>id[]</tt> будет указывать на себя.

DSU(int n) {
for (int i = 0; i < n; i++)
id.push_back(i); //id[i] == i;
}

=== Определение представителя ===
[[Файл:dsu_quickunion_find.png|thumb|right|360px|Определение представителя как корневого элемента]]
Так как представитель множества — это корень его древовидной структуры, требуется определить именно его. Для этого нужно воспользоваться свойством корня — тем фактом, что он указывает на себя.

int find(int x) {
if (id[x] == x)
return x;
return find(id[x]);
}

Определение представителя в худшем случае следует по массиву <tt>id[]</tt> от элемента-листа до корня древовидной струтуры, поэтому её сложность прямо пропорциональна высоте древовидной структуры. Ниже показано, что эта сложность составляет O(N).

=== Объединение множеств ===
[[Файл:dsu_quickunion_union.png|thumb|right|360px|Быстрое объединение множеств]]
В рассмотренных ограничениях объединение множеств представляет собой объединение их древовидных структур. Для выполнения последнего достаточно присоединить корень одной структуры к элементу другой структуры; в целях минимального увеличения высоты результирующей структуры наиболее выгодно присоединять корень одной из структур к корню другой. Как упоминалось ранее, это потребует корректировки всего одного элемента массива <tt>id[]</tt>:

void merge(int x, int y) {
int rx = find(x), ry = find(y);
if (rx != ry)
id[rx] = ry;
}

Несмотря на то, что операция объединения содержит лишь одно обращение к массиву <tt>id[]</tt>, она использует вызовы операции <tt>find()</tt>, поэтому её сложность также зависит от высоты древовидной структуры. В том случае, когда происходит постоянное подвешивание корня структуры к единственному элементу другой структуры, результат вырождается в односвязный список, а его высота становится равной N. Поэтому операция объединения, равно как операция определения представителя, в данной реализации имеет сложность O(N).

С помощью двух сравнительно простых дополнений скорость работы данной реализации улучшается разительным образом.

== Оптимальная реализация ==
Реализация системы непересекающихся множеств с наилучшим возможным временем работы осуществляется на базе версии «быстрого объединения» с использованием двух дополнительных эвристик (оптимизаций, не имеющих строгого математического обоснования).

=== Эвристика объединения по рангу ===
[[Файл:dsu_weighted_union.png|thumb|right|Принцип объединения по рангу]]
Как было показано ранее, время работы реализации «быстрое объединение» ухудшается с ростом высоты древовидной структуры. Сама же высота может стремительно деградировать до N при неудачно подобранных входных данных (когда структура большего размера присоединяется к корню структуры меньшго размера). Данная оптимизация служит для исключения подобных ситуаций и вводит новое правило: структура большего размера не может быть присоедина к структуре меньшего размера.

Для отслеживания размера структур определяется массив <tt>size[]</tt>, элементы которого в конструкторе инициализируются единицами (так как исходные множества являются одноэлементными):

DSU(int n) {
for (int i = 0; i < n; i++) {
id.push_back(i); //id[i] == i
size.push_back(1); //size[i] == 1
}
}

Код операции <tt>merge()</tt> изменяется соответствующим образом: решение о том, какая из структур будет присоединена к другой, осуществяется на основании сравнения их размеров. Размер результирующей структуры соответствующим образом увеличивается на количество присоединённых элементов:

void merge(int x, int y) {
int rx = find(x), ry = find(y);
if (rx == ry)
return;
if (size[rx] < size[ry]) {
id[rx] = ry;
size[ry] += size[rx];
} else {
id[ry] = rx;
size[rx] += size[ry];
}
}

После данной оптимизации высота дерева увеличивается на 1 только в результате слияния двух множеств равного размера. Так как таких слияний для N элементов может произойти не более log2N, высота дерева в худшем случае оптимизируется до logN.

В качестве критерия присоединения можно использовать не только размер, но и высоту древовидных структур. Более того, часто можно достичь удовлетворительной производительности только за счёт случайного выбора присоединяемой структуры (применение классической идеи рандомизированного алгоритма).

=== Эвристика сжатия путей ===
[[Файл:dsu_path_compressing.png|thumb|right|360px|Сжатие путей при выполнении операции find]]
Дополнительно уменьшить высоту дерева можно, если в операции <tt>find()</tt> перенаправлять все посещённые вершины непосредственно на найденный корень:

int find(int x) {
if (id[x] == x)
return x;
return id[x] = find(id[x]);
}

Данная оптимизация вкупе с предыдущей делает дерево практически плоским, что обеспечивает асимптотику операций, почти равную O(1).

----

Ниже приведён полный код оптимальной реализации системы непересекающихся множеств.

class DSU {

vector<int> id;
vector<int> size;

public:

DSU(int n) {
for (int i = 0; i < n; i++) {
id.push_back(i);
size.push_back(1);
}
}

int find(int x) {
if (id[x] == x)
return x;
return id[x] = find(id[x]);
}

void merge(int x, int y) {
int rx = find(x), ry = find(y);
if (rx == ry)
return;
if (size[rx] < size[ry]) {
id[rx] = ry;
size[ry] += size[rx];
} else {
id[ry] = rx;
size[ry] += size[rx];
}
}

bool connected(int x, int y) {
return find(x) == find(y);
}

};

Некоторые вопросы для размышления:

*''Каким образом реализуется операция <tt>makeSet()</tt>, добавляющая в систему новое одноэлементное множество?''
*''Как реализовать эвристику объединения по рангу, использующую в качестве критерия высоту древовидных структур?''
*''Обратите внимание: после выполнения метода <tt>find()</tt>, использующего эвристику сжатия путей, некоторые элементы массива <tt>size[]</tt> могут содержать неверную (неактуальную) информацию. Влияет ли это на правильность объединения по рангу? Нужно ли исправлять это несоответствие?''

== Задачи, рашаемые с помощью системы непересекающихся множеств ==
Большинство задач, связанных с системой непересекающихся множеств, относятся к так называемым ''оффлайн-задачам'', когда все запросы и их порядок известны заранее. В этом случае допустимо считать и проанализировать все запросы, а также получать ответы на них в порядке, отличном от порядка поступления запросов.

*Расчёт различных функций (сумма элементов, максимум и т. п.) на множествах. Достаточно определить отдельные массивы для значений данных функций аналогично массиву <tt>size[]</tt>, должным образом инициализировать их элементы и обновлять их при слиянии множеств;
*Задача о разрезании графа (запросы об удалении рёбер и принадлежности вершин одной компоненте связности) в оффлайн. Можно считать запросы и выполнять их в обратном порядке (что будет аналогично добавлению рёбер). Полученная задача аналогична тем, которые приведены во введении к данной статье.
*Определение минимального остовного дерева в оффлайн алгоритмом Крускала;
*Определение ближайшего общего предка в оффлайн алгоритмом Тарьяна.

== Код ==

struct DSU {
vector<int> parent;

DSU(int vertexCount) {
for (int v = 0; v < vertexCount; v++)
parent.push_back(v);
}

int findRoot(int v) {
return parent[v] == v ? v : parent[v] = findRoot(parent[v]);
}

bool areConnected(int a, int b) {
return findRoot(a) == findRoot(b);
}

void connect(int a, int b) {
int rootA = findRoot(a);
int rootB = findRoot(b);
if (rootA == rootB)
return;
if (rand() % 2)
parent[rootA] = rootB;
else
parent[rootB] = rootA;
}
};

== Ссылки ==
Теория:
* [https://codeforces.com/edu/course/2/lesson/7 Codeforces EDU — Система непересекающихся множеств]
* [http://e-maxx.ru/algo/dsu e-maxx.ru — Система непересекающихся множеств]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%94%D0%B8%D1%81%D0%BA%D1%80%D0%B5%D1%82%D0%BD%D0%B0%D1%8F_%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0,_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D1%8B_%D0%B8_%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D1%8B_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85#.D0.A1.D0.B8.D1.81.D1.82.D0.B5.D0.BC.D0.B0_.D0.BD.D0.B5.D0.BF.D0.B5.D1.80.D0.B5.D1.81.D0.B5.D0.BA.D0.B0.D1.8E.D1.89.D0.B8.D1.85.D1.81.D1.8F_.D0.BC.D0.BD.D0.BE.D0.B6.D0.B5.D1.81.D1.82.D0.B2 neerc.ifmo.ru/wiki — Система непересекающихся множеств]
* [https://brestprog.by/topics/dsu/ Brestprog — Система непересекающихся множеств (DSU)]
* [http://habrahabr.ru/post/104772/ habrahabr.ru — Система непересекающихся множеств и её применения]
* [http://cppalgo.blogspot.ru/2011/10/disjoint-set-union.html cppalgo.blogspot.ru — Система непересекающихся множеств]
* [https://www.youtube.com/watch?v=gfSpPbJWzVs algs4.cs.princeton.edu/lectures — 1.5 Union Find] ([https://algs4.cs.princeton.edu/lectures/keynote/15UnionFind.pdf slides])
Код:
* [https://github.com/indy256/codelibrary/blob/master/cpp/structures/disjoint_sets_ranked.cpp CodeLibrary — Disjoint-set data structure]
* algs4.cs.princeton.edu/code — [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/QuickFindUF.java.html quick find], [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/QuickUnionUF.java.html quick union], [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/WeightedQuickUnionUF.java.html weighted quick union], [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/UF.java.html union-by-rank with path halving]
Задачи:
* [http://informatics.mccme.ru/course/view.php?id=18 informatics.mccme.ru — Курс «Структуры данных» — часть 7]
* [[:Категория:Задачи: Система непересекающихся множеств|Задачи: Система непересекающихся множеств]]

[[Category:Базовые структуры и абстрактные типы данных]]

Суффиксный массив

2026-04-11T15:37:04Z

Ctrlalt:

== Построение ==

Построение за Nlog2N:
vector<int> makeSuffixArray(string s) {
s += '\0';
int n = s.size();

vector<int> p(n);
for (int i = 0; i < n; i++)
p[i] = i;
sort(p.begin(), p.end(), [&](int i, int j) { return s[i] < s[j]; });

vector<int> rank(n);
rank[p[0]] = 0;
for (int i = 1; i < n; i++)
rank[p[i]] = rank[p[i - 1]] + (s[p[i]] != s[p[i - 1]]);

vector<pair<int, int>> rankPair(n);
for (int len = 1; len < n; len *= 2) {
for (int i = 0; i < n; i++)
rankPair[i] = { rank[i], rank[(i + len) % n] };

sort(p.begin(), p.end(), [&](int i, int j) { return rankPair[i] < rankPair[j]; });

rank[p[0]] = 0;
for (int i = 1; i < n; i++)
rank[p[i]] = rank[p[i - 1]] + (rankPair[p[i]] != rankPair[p[i - 1]]);
}

return p;
}

Построение за NlogN:

Меняем вызов <tt>sort()</tt> внутри цикла на следующий фрагмент:
for (int i = 0; i < n; i++)
p[i] = (p[i] - len + n) % n;
countSort(p, rank);

Здесь <tt>countSort()</tt> — сортировка подсчётом:
void countSort(vector<int> &p, const vector<int> &rank) {
int n = p.size();

vector<int> rankCount(n);
for (int i = 0; i < n; i++)
rankCount[rank[i]]++;

vector<int> rankFrom(n);
for (int i = 1; i < n; i++)
rankFrom[i] = rankFrom[i - 1] + rankCount[i - 1];

vector<int> sortedP(n);
for (int elem : p)
sortedP[rankFrom[rank[elem]]++] = elem;
p.swap(sortedP);
}

== Поиск подстрок ==

int lowerBound(const string &s, const vector<int> &p, const string &t) {
int l = 0, r = p.size();
while (l + 1 < r) {
int m = l + (r - l) / 2;
if (s.compare(p[m], t.size(), t) >= 0)
r = m;
else
l = m;
}
return r;
}

int upperBound(const string &s, const vector<int> &p, const string &t) {
int l = 0, r = p.size();
while (l + 1 < r) {
int m = l + (r - l) / 2;
if (s.compare(p[m], t.size(), t) > 0)
r = m;
else
l = m;
}
return r;
}

int count(const string &s, const vector<int> &p, const string &t) {
return upperBound(s, p, t) - lowerBound(s, p, t);
}

== Построение массива LCP ==

vector<int> makeLCP(const string &s, const vector<int> &p) {
int n = p.size();
vector<int> positionInP(n);
for (int i = 0; i < n; i++)
positionInP[p[i]] = i;

vector<int> lcp(n);
for (int i = 0, len = 0; i < n - 1; i++, len = max(len - 1, 0)) {
int j = p[positionInP[i] - 1];
while (s[i + len] == s[j + len])
len++;
lcp[positionInP[i]] = len;
}
return lcp;
}

== Количество различных подстрок ==

long long distinctSubstringsCount(const vector<int> &p, const vector<int> &lcp) {
long long res = 0;
for (int i = 1; i < p.size(); i++)
res += (p.size() - 1 - p[i]) - lcp[i];
return res;
}

== Наибольшая общая подстрока ==
string longestCommonSubstring(const string &a, const string &b) {
string s = a + "#" + b;
auto p = makeSuffixArray(s);
auto lcp = makeLCP(s, p);

int len = 0, from = 0;
for (int i = 1; i < p.size(); i++) {
if ((p[i] < a.size() && p[i - 1] > a.size() ||
p[i] > a.size() && p[i - 1] < a.size()) && lcp[i] > len) {
len = lcp[i];
from = min(p[i], p[i - 1]);
}
}
return a.substr(from, len);
}

== Класс SuffixArray ==

class SuffixArray {
string s;
vector<int> order;

void radixSort(vector<vector<int>> &rankPair) {
for (int j : { 1, 0 }) {
vector<int> count(rankPair.size());
for (int i = 0; i < rankPair.size(); i++) {
int rank = rankPair[i][j];
count[rank]++;
}

vector<int> from(rankPair.size());
for (int rank = 1; rank < rankPair.size(); rank++)
from[rank] = from[rank - 1] + count[rank - 1];

vector<int> sortedOrder(order.size());
for (int i : order) {
int rank = rankPair[i][j];
sortedOrder[from[rank]] = i;
from[rank]++;
}
order.swap(sortedOrder);
}
}

int lowerBound(const string &word) {
int l = 0, r = order.size();
while (l + 1 < r) {
int m = l + (r - l) / 2;
if (s.compare(order[m], word.size(), word) >= 0)
r = m;
else
l = m;
}
return r;
}

int upperBound(const string &word) {
int l = 0, r = order.size();
while (l + 1 < r) {
int m = l + (r - l) / 2;
if (s.compare(order[m], word.size(), word) > 0)
r = m;
else
l = m;
}
return r;
}

public:
SuffixArray(const string &text) : s(text + '\0') {
order.resize(s.size());
for (int i = 0; i < order.size(); i++)
order[i] = i;
sort(order.begin(), order.end(), [&](int l, int r) {
return s[l] < s[r];
});

vector<int> rank(s.size());
rank[order[0]] = 0;
for (int i = 1; i < s.size(); i++)
rank[order[i]] = rank[order[i - 1]] + (s[order[i - 1]] != s[order[i]]);

for (int halfLen = 1; halfLen < s.size(); halfLen *= 2) {
vector<vector<int>> rankPair(s.size());
for (int i = 0; i < s.size(); i++)
rankPair[i] = { rank[i], rank[(i + halfLen) % s.size()] };

radixSort(rankPair);

rank[order[0]] = 0;
for (int i = 1; i < s.size(); i++)
rank[order[i]] = rank[order[i - 1]] + (rankPair[order[i - 1]] != rankPair[order[i]]);
}
}

int count(const string &word) {
return upperBound(word) - lowerBound(word);
}
};

== Ссылки ==
* [http://codeforces.com/edu/course/2/lesson/2 Codeforces EDU — Суффиксный массив]
* [http://e-maxx.ru/algo/suffix_array e-maxx — Суффиксный массив]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D1%83%D1%84%D1%84%D0%B8%D0%BA%D1%81%D0%BD%D1%8B%D0%B9_%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2 neerc.info.ru/wiki — Суффиксный массив]
* [http://algorithmica.org/ru/suffix-array Algorithmica.org — Суффиксный массив]
* [http://um-nik.github.io/suffix-array Данилюк А. Суффиксный массив]
* [http://opentrains.mipt.ru/zksh/files/zksh2015/lectures/Suffix_Array_lecture_A.pdf Тихомиров М., Останин А. Лекция по суффиксному массиву]
* [http://habr.com/ru/post/115346/ Habr — Суффиксный массив — удобная замена суффиксного дерева]
* [http://visualgo.net/en/suffixarray VisuAlgo — Suffix Array]

Heavy-light-декомпозиция

2026-02-15T00:43:22Z

Ctrlalt:

{|width=100%
|
Отдельное дерево отрезков для каждого пути
|
Изменение порядка рёбер в списках смежности, одно общее дерево отрезков для всех путей
|-
|
struct SegmentTree {
int size;
vector<int> t;

void build(int v, int vl, int vr, vector<int> &path, vector<int> &values) {
if (vl == vr) {
t[v] = values[path[vl]];
return;
}
int vm = vl + (vr - vl) / 2;
build(2 * v + 1, vl, vm, path, values);
build(2 * v + 2, vm + 1, vr, path, values);
t[v] = max(t[2 * v + 1], t[2 * v + 2]);
}

int query(int v, int vl, int vr, int l, int r) {
if (l <= vl && vr <= r)
return t[v];
int vm = vl + (vr - vl) / 2;
if (r <= vm)
return query(2 * v + 1, vl, vm, l, r);
if (vm + 1 <= l)
return query(2 * v + 2, vm + 1, vr, l, r);
int ql = query(2 * v + 1, vl, vm, l, r);
int qr = query(2 * v + 2, vm + 1, vr, l, r);
return max(ql, qr);
}

void modify(int v, int vl, int vr, int index, int value) {
if (vl == vr) {
t[v] = value;
return;
}
int vm = vl + (vr - vl) / 2;
if (index <= vm)
modify(2 * v + 1, vl, vm, index, value);
else
modify(2 * v + 2, vm + 1, vr, index, value);
t[v] = max(t[2 * v + 1], t[2 * v + 2]);
}

SegmentTree() {}

SegmentTree(vector<int> &path, vector<int> &values) : size(path.size()), t(4 * size) {
build(0, 0, size - 1, path, values);
}

int getMax(int l, int r) {
return query(0, 0, size - 1, l, r);
}

void setValue(int index, int value) {
modify(0, 0, size - 1, index, value);
}
};

struct HeavyLightDecomposition {
vector<vector<int>> graph, paths;
vector<int> parent, depth, subtreeSize, pathOf, posOf;
vector<SegmentTree> segmentTrees;

HeavyLightDecomposition(int vertexCount) :
graph(vertexCount), parent(vertexCount), depth(vertexCount),
subtreeSize(vertexCount), pathOf(vertexCount), posOf(vertexCount) {}

void addEdge(int a, int b) {
graph[a].push_back(b);
graph[b].push_back(a);
}

int dfs1(int v, int p) {
parent[v] = p;
depth[v] = parent[v] != -1 ? depth[parent[v]] + 1 : 0;
subtreeSize[v] = 1;
for (int to : graph[v])
if (to != parent[v])
subtreeSize[v] += dfs1(to, v);
return subtreeSize[v];
}

void dfs2(int v, int pathIndex) {
if (paths.size() == pathIndex)
paths.emplace_back();
paths[pathIndex].push_back(v);

pathOf[v] = pathIndex;
posOf[v] = paths[pathIndex].size() - 1;

int maxTo = -1;
for (int to : graph[v])
if (to != parent[v] && (maxTo == -1 || subtreeSize[maxTo] < subtreeSize[to]))
maxTo = to;

for (int to : graph[v])
if (to != parent[v])
dfs2(to, to == maxTo ? pathIndex : paths.size());
}

void prepare(int root, vector<int> &values) {
dfs1(root, -1);
dfs2(root, 0);
for (vector<int> &path : paths)
segmentTrees.push_back(SegmentTree(path, values));
}

int getMax(int a, int b) {
int res = -1e9;

while (pathOf[a] != pathOf[b]) {
if (depth[paths[pathOf[a]][0]] > depth[paths[pathOf[b]][0]])
swap(a, b);
res = max(res, segmentTrees[pathOf[b]].getMax(0, posOf[b]));
b = parent[paths[pathOf[b]][0]];
}

if (depth[a] > depth[b])
swap(a, b);
res = max(res, segmentTrees[pathOf[a]].getMax(posOf[a], posOf[b]));

return res;
}

void setValue(int v, int value) {
segmentTrees[pathOf[v]].setValue(posOf[v], value);
}
};
|
struct SegmentTree {
int size;
vector<int> t;

void build(int v, int vl, int vr, vector<int> &posInv, vector<int> &values) {
if (vl == vr) {
t[v] = values[posInv[vl]];
return;
}
int vm = vl + (vr - vl) / 2;
build(2 * v + 1, vl, vm, posInv, values);
build(2 * v + 2, vm + 1, vr, posInv, values);
t[v] = max(t[2 * v + 1], t[2 * v + 2]);
}

int query(int v, int vl, int vr, int l, int r) {
if (l <= vl && vr <= r)
return t[v];
int vm = vl + (vr - vl) / 2;
if (r <= vm)
return query(2 * v + 1, vl, vm, l, r);
if (vm + 1 <= l)
return query(2 * v + 2, vm + 1, vr, l, r);
int ql = query(2 * v + 1, vl, vm, l, r);
int qr = query(2 * v + 2, vm + 1, vr, l, r);
return max(ql, qr);
}

void modify(int v, int vl, int vr, int index, int value) {
if (vl == vr) {
t[v] = value;
return;
}
int vm = vl + (vr - vl) / 2;
if (index <= vm)
modify(2 * v + 1, vl, vm, index, value);
else
modify(2 * v + 2, vm + 1, vr, index, value);
t[v] = max(t[2 * v + 1], t[2 * v + 2]);
}

SegmentTree() {}

SegmentTree(vector<int> &posInv, vector<int> &values) : size(posInv.size()), t(4 * size) {
build(0, 0, size - 1, posInv, values);
}

int getMax(int l, int r) {
return query(0, 0, size - 1, l, r);
}

void setValue(int index, int value) {
modify(0, 0, size - 1, index, value);
}
};

struct HeavyLightDecomposition {
vector<vector<int>> graph;
vector<int> parent, depth, subtreeSize, pos, posInv, pathStart;
int timer = 0;
SegmentTree segmentTree;

HeavyLightDecomposition(int vertexCount) :
graph(vertexCount), parent(vertexCount), depth(vertexCount),
subtreeSize(vertexCount), pos(vertexCount), posInv(vertexCount), pathStart(vertexCount) {}

void addEdge(int a, int b) {
graph[a].push_back(b);
graph[b].push_back(a);
}

int dfs1(int v, int p) {
parent[v] = p;
if (parent[v] != -1) {
depth[v] = depth[parent[v]] + 1;
graph[v].erase(find(graph[v].begin(), graph[v].end(), parent[v]));
}
subtreeSize[v] = 1;
for (int &to : graph[v]) {
subtreeSize[v] += dfs1(to, v);
if (subtreeSize[graph[v][0]] < subtreeSize[to])
swap(graph[v][0], to);
}
return subtreeSize[v];
}

void dfs2(int v, int start) {
pos[v] = timer;
posInv[timer++] = v;
pathStart[v] = start;
for (int to : graph[v])
dfs2(to, to == graph[v][0] ? pathStart[v] : to);
}

void prepare(int root, vector<int> &values) {
dfs1(root, -1);
dfs2(root, root);
segmentTree = SegmentTree(posInv, values);
}

int getMax(int a, int b) {
int res = -1e9;

while (pathStart[a] != pathStart[b]) {
if (depth[pathStart[a]] > depth[pathStart[b]])
swap(a, b);
res = max(res, segmentTree.getMax(pos[pathStart[b]], pos[b]));
b = parent[pathStart[b]];
}

if (depth[a] > depth[b])
swap(a, b);
res = max(res, segmentTree.getMax(pos[a], pos[b]));

return res;
}

void setValue(int v, int value) {
segmentTree.setValue(pos[v], value);
}
};
|}

== Ссылки на задачи ==
* [http://acm.timus.ru/problem.aspx?num=1553 Timus #1553 — Caves and Tunnels]

== Ссылки ==
Теория:
* [https://e-maxx.ru/algo/heavy_light e-maxx.ru — Heavy-light декомпозиция]
* [https://cp-algorithms.com/graph/hld.html cp-algorithms.com — Heavy-light decomposition]
* [https://algorithmica.org/ru/hld algorithmica.org — Heavy-light декомпозиция]
* [https://codeforces.com/blog/entry/12239 codeforces.com — Heavy-light decompositon — это может быть просто!]
* [https://codeforces.com/blog/entry/81317 codeforces.com — Hybrid Tutorial #-1: Heavy-Light Decomposition]
* [https://web.archive.org/web/20221128105153/https://blog.anudeep2011.com/heavy-light-decomposition/ blog.anudeep2011.com — Heavy Light Decomposition]
* [https://usaco.guide/plat/hld usaco.guide — Heavy-Light Decomposition]
Код:
* [https://github.com/indy256/codelibrary/blob/main/cpp/structures/heavy_light_decomposition.cpp codelibrary/cpp/structures/heavy_light_decomposition.cpp]
* [https://github.com/ADJA/algos/blob/master/Graphs/HLD.cpp algos/Graphs/HLD.cpp]
* [https://github.com/ADJA/algos/blob/master/Graphs/LCAHLD.cpp algos/Graphs/LCAHLD.cpp]

[[Категория:Учебный курс «Алгоритмы и структуры данных»]]

Heavy-light-декомпозиция

2026-02-14T22:35:34Z

Ctrlalt:

struct SegmentTree {
int size;
vector<int> t;

int query(int v, int vl, int vr, int l, int r) {
if (vr < l || r < vl)
return -1e9;
if (l <= vl && vr <= r)
return t[v];
int vm = vl + (vr - vl) / 2;
int ql = query(2 * v + 1, vl, vm, l, r);
int qr = query(2 * v + 2, vm + 1, vr, l, r);
return max(ql, qr);
}

void modify(int v, int vl, int vr, int index, int value) {
if (vr < index || index < vl)
return;
if (vl == vr) {
t[v] += value;
return;
}
int vm = vl + (vr - vl) / 2;
modify(2 * v + 1, vl, vm, index, value);
modify(2 * v + 2, vm + 1, vr, index, value);
t[v] = max(t[2 * v + 1], t[2 * v + 2]);
}

SegmentTree(int size) : size(size), t(4 * size) {}

int getMax(int l, int r) {
return query(0, 0, size - 1, l, r);
}

void addValue(int index, int value) {
modify(0, 0, size - 1, index, value);
}
};

struct HeavyLightDecomposition {
vector<vector<int>> graph;
vector<int> l, r, parent, subtreeSize;
int timer = 0;
vector<vector<int>> paths;
vector<int> pathOf, posOf;
vector<SegmentTree> segmentTrees;

HeavyLightDecomposition(int vertexCount) :
graph(vertexCount), l(vertexCount), r(vertexCount),
parent(vertexCount), subtreeSize(vertexCount),
pathOf(vertexCount), posOf(vertexCount) {}

void addEdge(int a, int b) {
graph[a].push_back(b);
graph[b].push_back(a);
}

int dfs(int v, int p) {
l[v] = timer++;
parent[v] = p;
subtreeSize[v] = 1;

for (int to : graph[v])
if (to != parent[v])
subtreeSize[v] += dfs(to, v);

r[v] = timer++;
return subtreeSize[v];
}

bool isAncestor(int a, int b) {
return l[a] <= l[b] && r[b] <= r[a];
}

void buildPath(int v, int pathIndex) {
if (paths.size() == pathIndex)
paths.emplace_back();
paths[pathIndex].push_back(v);

pathOf[v] = pathIndex;
posOf[v] = paths[pathIndex].size() - 1;

int maxTo = -1;
for (int to : graph[v])
if (to != parent[v] && (maxTo == -1 || subtreeSize[maxTo] < subtreeSize[to]))
maxTo = to;

for (int to : graph[v])
if (to != parent[v])
buildPath(to, to == maxTo ? pathIndex : paths.size());
}

void prepare(int root) {
dfs(root, -1);
buildPath(root, 0);
for (vector<int> &path : paths)
segmentTrees.push_back(SegmentTree(path.size()));
}

int getMax(int a, int b) {
int res = 0;

for (; !isAncestor(paths[pathOf[a]][0], b); a = parent[paths[pathOf[a]][0]])
res = max(res, segmentTrees[pathOf[a]].getMax(0, posOf[a]));
for (; !isAncestor(paths[pathOf[b]][0], a); b = parent[paths[pathOf[b]][0]])
res = max(res, segmentTrees[pathOf[b]].getMax(0, posOf[b]));

if (posOf[a] > posOf[b])
swap(a, b);
return max(res, segmentTrees[pathOf[a]].getMax(posOf[a], posOf[b]));
}

void addValue(int v, int value) {
segmentTrees[pathOf[v]].addValue(posOf[v], value);
}
};

== Ссылки на задачи ==
* [http://acm.timus.ru/problem.aspx?num=1553 Timus #1553 — Caves and Tunnels]

== Ссылки ==
Теория:
* [https://e-maxx.ru/algo/heavy_light e-maxx.ru — Heavy-light декомпозиция]
* [https://cp-algorithms.com/graph/hld.html cp-algorithms.com — Heavy-light decomposition]
* [https://algorithmica.org/ru/hld algorithmica.org — Heavy-light декомпозиция]
* [https://codeforces.com/blog/entry/12239 codeforces.com — Heavy-light decompositon — это может быть просто!]
* [https://codeforces.com/blog/entry/81317 codeforces.com — Hybrid Tutorial #-1: Heavy-Light Decomposition]
* [https://web.archive.org/web/20221128105153/https://blog.anudeep2011.com/heavy-light-decomposition/ blog.anudeep2011.com — Heavy Light Decomposition]
* [https://usaco.guide/plat/hld usaco.guide — Heavy-Light Decomposition]
Код:
* [https://github.com/indy256/codelibrary/blob/main/cpp/structures/heavy_light_decomposition.cpp codelibrary/cpp/structures/heavy_light_decomposition.cpp]
* [https://github.com/ADJA/algos/blob/master/Graphs/HLD.cpp algos/Graphs/HLD.cpp]
* [https://github.com/ADJA/algos/blob/master/Graphs/LCAHLD.cpp algos/Graphs/LCAHLD.cpp]

[[Категория:Учебный курс «Алгоритмы и структуры данных»]]

Heavy-light-декомпозиция

2026-02-14T22:29:20Z

Ctrlalt: /* Ссылки */

struct SegmentTree {
int size;
vector<int> t;

int query(int v, int vl, int vr, int l, int r) {
if (vr < l || r < vl)
return -1e9;
if (l <= vl && vr <= r)
return t[v];
int vm = vl + (vr - vl) / 2;
int ql = query(2 * v + 1, vl, vm, l, r);
int qr = query(2 * v + 2, vm + 1, vr, l, r);
return max(ql, qr);
}

void modify(int v, int vl, int vr, int index, int value) {
if (vr < index || index < vl)
return;
if (vl == vr) {
t[v] += value;
return;
}
int vm = vl + (vr - vl) / 2;
modify(2 * v + 1, vl, vm, index, value);
modify(2 * v + 2, vm + 1, vr, index, value);
t[v] = max(t[2 * v + 1], t[2 * v + 2]);
}

SegmentTree(int size) : size(size), t(4 * size) {}

int getMax(int l, int r) {
return query(0, 0, size - 1, l, r);
}

void addValue(int index, int value) {
modify(0, 0, size - 1, index, value);
}
};

struct HeavyLightDecomposition {
vector<vector<int>> graph;
vector<int> l, r, parent, subtreeSize;
int timer = 0;
vector<vector<int>> paths;
vector<int> pathOf, posOf;
vector<SegmentTree> segmentTrees;

HeavyLightDecomposition(int vertexCount) :
graph(vertexCount), l(vertexCount), r(vertexCount),
parent(vertexCount), subtreeSize(vertexCount),
pathOf(vertexCount), posOf(vertexCount) {}

void addEdge(int a, int b) {
graph[a].push_back(b);
graph[b].push_back(a);
}

int dfs(int v, int p) {
l[v] = timer++;
parent[v] = p;
subtreeSize[v] = 1;

for (int to : graph[v])
if (to != p)
subtreeSize[v] += dfs(to, v);

r[v] = timer++;
return subtreeSize[v];
}

bool isAncestor(int a, int b) {
return l[a] <= l[b] && r[b] <= r[a];
}

void buildPath(int v, int pathIndex) {
if (paths.size() == pathIndex)
paths.emplace_back();
paths[pathIndex].push_back(v);

pathOf[v] = pathIndex;
posOf[v] = paths[pathIndex].size() - 1;

int maxTo = -1;
for (int to : graph[v])
if (to != parent[v] && (maxTo == -1 || subtreeSize[maxTo] < subtreeSize[to]))
maxTo = to;

for (int to : graph[v]) {
if (to == parent[v])
continue;
if (to == maxTo)
buildPath(to, pathIndex);
else
buildPath(to, paths.size());
}
}

void prepare(int root) {
dfs(root, -1);
buildPath(root, 0);
for (vector<int> &path : paths)
segmentTrees.push_back(SegmentTree(path.size()));
}

int getMax(int a, int b) {
int res = 0;

for (; !isAncestor(paths[pathOf[a]][0], b); a = parent[paths[pathOf[a]][0]])
res = max(res, segmentTrees[pathOf[a]].getMax(0, posOf[a]));
for (; !isAncestor(paths[pathOf[b]][0], a); b = parent[paths[pathOf[b]][0]])
res = max(res, segmentTrees[pathOf[b]].getMax(0, posOf[b]));

if (posOf[a] > posOf[b])
swap(a, b);
return max(res, segmentTrees[pathOf[a]].getMax(posOf[a], posOf[b]));
}

void addValue(int v, int value) {
segmentTrees[pathOf[v]].addValue(posOf[v], value);
}
};

== Ссылки на задачи ==
* [http://acm.timus.ru/problem.aspx?num=1553 Timus #1553 — Caves and Tunnels]

== Ссылки ==
Теория:
* [https://e-maxx.ru/algo/heavy_light e-maxx.ru — Heavy-light декомпозиция]
* [https://cp-algorithms.com/graph/hld.html cp-algorithms.com — Heavy-light decomposition]
* [https://algorithmica.org/ru/hld algorithmica.org — Heavy-light декомпозиция]
* [https://codeforces.com/blog/entry/12239 codeforces.com — Heavy-light decompositon — это может быть просто!]
* [https://codeforces.com/blog/entry/81317 codeforces.com — Hybrid Tutorial #-1: Heavy-Light Decomposition]
* [https://web.archive.org/web/20221128105153/https://blog.anudeep2011.com/heavy-light-decomposition/ blog.anudeep2011.com — Heavy Light Decomposition]
* [https://usaco.guide/plat/hld usaco.guide — Heavy-Light Decomposition]
Код:
* [https://github.com/indy256/codelibrary/blob/main/cpp/structures/heavy_light_decomposition.cpp codelibrary/cpp/structures/heavy_light_decomposition.cpp]
* [https://github.com/ADJA/algos/blob/master/Graphs/HLD.cpp algos/Graphs/HLD.cpp]
* [https://github.com/ADJA/algos/blob/master/Graphs/LCAHLD.cpp algos/Graphs/LCAHLD.cpp]

[[Категория:Учебный курс «Алгоритмы и структуры данных»]]

Категория:Учебный курс «Алгоритмы и структуры данных»

2026-02-14T22:01:18Z

Ctrlalt:

{|
|
;Сортировка и поиск
:
:* [[Асимптотический анализ алгоритмов]]
:* [[Анализ рекуррентных соотношений. Мастер-теорема]]
: Простейшие алгоритмы сортировки
:* 📄 [[Сортировка выбором]]
:* 📄 [[Сортировка вставками]]
: Улучшенные алгоритмы сортировки
:* 📄 [[Сортировка слиянием]]
:* 📄 [[Быстрая сортировка]]
: Сортировка за линейное время
:* [[Сортировка подсчётом]]
:* [[Поразрядная сортировка]]
: Алгоритмы поиска
:* [[Бинарный поиск]]
:* [[Тернарный поиск]]
: Применение сортировки
:* [[Сканирующая прямая]]
;Структуры данных
:
: Базовые структуры и абстрактные типы данных
:* [[Динамический массив]]
:* [[Связный список]]
:* [[Стек]]
:* [[Очередь]]
:* [[Очередь с приоритетами]]
:* [[Множество. Реализация на битовых векторах]]
:* [[Множество и словарь. Реализация на деревьях поиска]]
:* [[Множество и словарь. Реализация на хеш-таблицах]]
:* [[Система непересекающихся множеств]]
: Балансирующиеся деревья
:* 📄 [[АВЛ-дерево]]
:* 📄 [[Красно-чёрное дерево]]
:* [[Декартово дерево]]
:* 📄 [[Расширения декартова дерева]]
: Обработка запросов на отрезках
:* 📄 [[Префиксные суммы]]
:* [[Дерево Фенвика]]
:* 📄 [[Дерево отрезков]]
:* 📄 [[Sparse table]]
:* Sqrt-декомпозиция
:* [[Алгоритм Мо]]
|width=450px|
;Алгоритмы для работы с графами
:
:* [[Основные определения. Представление графов]]
: Поиск в глубину и его приложения
:* 📄 [[Поиск в глубину]]''O(V+E)''
:* 📄 [[Компоненты связности]]
:* 📄 [[Циклы в графе. Двудольность]]
:* 📄 [[Топологическая сортировка]]
:* 📄 [[Компоненты сильной связности. Алгоритм Косараю-Шарира|Компоненты сильной связности]]
:* 📄 [[Мосты. Компоненты рёберной двусвязности|Мосты]]
:* 📄 [[Точки сочленения. Компоненты вершинной двусвязности|Точки сочленения]]
:* 📄 [[Эйлеров цикл. Эйлеров путь]]
: Кратчайшие пути из одной вершины
:* 📄 [[Поиск в ширину]]''O(V+E)''
:* 📝 [[Алгоритм Дейкстры]]''O(V2+E) или O(ElogV)''
:* 📄 [[Алгоритм A*]]
:* [[Алгоритм Форда-Беллмана]]''O(VE)''
:* [[Кратчайшие пути в ациклических орграфах]]''O(V+E)''
: Кратчайшие пути между всеми парами вершин
:* 📄 [[Алгоритм Флойда]]''O(V3)''
:* [[Алгоритм Джонсона]]''O(VElogV)''
: Минимальное остовное дерево
:* 📝 [[Алгоритм Краскала]]''O(ElogV)''
:* 📄 [[Алгоритм Прима]]''O(V2+E) или O(ElogV)''
: Максимальный поток
:* 📄 [[Алгоритм Форда-Фалкерсона]]''O(Flow×E)''
:* 📄 [[Алгоритм Эдмондса-Карпа]]''O(VE2)''
:* 📄 [[Алгоритм Диница]]''O(V2E)''
:* 📄 [[Максимальный поток минимальной стоимости]]
:* [[Применения максимального потока]]
: Максимальное паросочетание
:* 📄 [[Алгоритм Куна]]''O(VE)''
:* 📄 [[Минимальное вершинное покрытие, максимальное независимое множество]]
: Наименьший общий предок
:* 📄 [[Метод двоичного подъёма]]''O(NlogN), O(logN)''
:* [[Сведение LCA к RMQ и RMQ к LCA]]
:* [[Алгоритм Тарьяна (offline)]]''O(N), O(1)''
: Декомпозиции деревьев
:* 📄 [[Heavy-light-декомпозиция]]
|
;Полный перебор и методы его оптимизации
:
:* [[Полный перебор]]
:* [[Два указателя]]
:* Meet in the middle
:* [[Жадные алгоритмы]]
: Динамическое программирование
:* [[Динамическое программирование]]
:* [[Задача о рюкзаке и связанные задачи]]
:* [[Оптимизации динамического программирования]]
;Математика
:
: Теория чисел
:* 📄 [[НОД. Алгоритм Евклида]]
:* 📄 [[Простые числа. Решето Эратосфена]]
:* 📄 [[Быстрое возведение в степень]]
:* 📄 [[Модульная арифметика]]
:* 📝 [[Длинная арифметика]]
:* 📄 [[Метод Гаусса]]
:* 📄 [[Быстрое преобразование Фурье]]
: Комбинаторика
:* 📄 [[Подсчёт и перечисление комбинаторных объектов]]
:* [[Получение номера по объекту и объекта по номеру]]
:* [[Перестановки]]
: Теория игр
:* [[Игры]]
: Геометрия
:* 📝 [[Геометрические примитивы]]
:* 📄 [[Выпуклая оболочка]]

; Алгоритмы для работы со строками
:
:* 📄 [[Хеширование строк]]
:* 📄 [[Префикс-функция]]
:* 📄 [[Алгоритм Ахо-Корасик]]
:* 📄 [[Z-функция]]
:* 📄 [[Алгоритм Манакера]]
:* 📄 [[Суффиксный массив]]
: Разбор выражений
:* 📝 [[Наивный рекурсивный разбор]]
:* 📄 [[Алгоритм сортировочной станции]]

; Разное
:
:* 📄 [[Часто используемые фрагменты]]
|}

''© В. А. Фолунин, 2012–2026''

Категория:Учебный курс «Алгоритмы и структуры данных»

2026-02-14T21:59:41Z

Ctrlalt:

{|
|
;Сортировка и поиск
:
:* [[Асимптотический анализ алгоритмов]]
:* [[Анализ рекуррентных соотношений. Мастер-теорема]]
: Простейшие алгоритмы сортировки
:* 📄 [[Сортировка выбором]]
:* 📄 [[Сортировка вставками]]
: Улучшенные алгоритмы сортировки
:* 📄 [[Сортировка слиянием]]
:* 📄 [[Быстрая сортировка]]
: Сортировка за линейное время
:* [[Сортировка подсчётом]]
:* [[Поразрядная сортировка]]
: Алгоритмы поиска
:* [[Бинарный поиск]]
:* [[Тернарный поиск]]
: Применение сортировки
:* [[Сканирующая прямая]]
;Структуры данных
:
: Базовые структуры и абстрактные типы данных
:* [[Динамический массив]]
:* [[Связный список]]
:* [[Стек]]
:* [[Очередь]]
:* [[Очередь с приоритетами]]
:* [[Множество. Реализация на битовых векторах]]
:* [[Множество и словарь. Реализация на деревьях поиска]]
:* [[Множество и словарь. Реализация на хеш-таблицах]]
:* [[Система непересекающихся множеств]]
: Балансирующиеся деревья
:* 📄 [[АВЛ-дерево]]
:* 📄 [[Красно-чёрное дерево]]
:* [[Декартово дерево]]
:* 📄 [[Расширения декартова дерева]]
: Обработка запросов на отрезках
:* 📄 [[Префиксные суммы]]
:* [[Дерево Фенвика]]
:* 📄 [[Дерево отрезков]]
:* 📄 [[Sparse table]]
:* Sqrt-декомпозиция
:* [[Алгоритм Мо]]
|width=450px|
;Алгоритмы для работы с графами
:
:* [[Основные определения. Представление графов]]
: Поиск в глубину и его приложения
:* 📄 [[Поиск в глубину]]''O(V+E)''
:* 📄 [[Компоненты связности]]
:* 📄 [[Циклы в графе. Двудольность]]
:* 📄 [[Топологическая сортировка]]
:* 📄 [[Компоненты сильной связности. Алгоритм Косараю-Шарира|Компоненты сильной связности]]
:* 📄 [[Мосты. Компоненты рёберной двусвязности|Мосты]]
:* 📄 [[Точки сочленения. Компоненты вершинной двусвязности|Точки сочленения]]
:* 📄 [[Эйлеров цикл. Эйлеров путь]]
: Кратчайшие пути из одной вершины
:* 📄 [[Поиск в ширину]]''O(V+E)''
:* 📝 [[Алгоритм Дейкстры]]''O(V2+E) или O(ElogV)''
:* 📄 [[Алгоритм A*]]
:* [[Алгоритм Форда-Беллмана]]''O(VE)''
:* [[Кратчайшие пути в ациклических орграфах]]''O(V+E)''
: Кратчайшие пути между всеми парами вершин
:* 📄 [[Алгоритм Флойда]]''O(V3)''
:* [[Алгоритм Джонсона]]''O(VElogV)''
: Минимальное остовное дерево
:* 📝 [[Алгоритм Краскала]]''O(ElogV)''
:* 📄 [[Алгоритм Прима]]''O(V2+E) или O(ElogV)''
: Максимальный поток
:* 📄 [[Алгоритм Форда-Фалкерсона]]''O(Flow×E)''
:* 📄 [[Алгоритм Эдмондса-Карпа]]''O(VE2)''
:* 📄 [[Алгоритм Диница]]''O(V2E)''
:* 📝 [[Максимальный поток минимальной стоимости]]
:* [[Применения максимального потока]]
: Максимальное паросочетание
:* 📄 [[Алгоритм Куна]]''O(VE)''
:* 📄 [[Минимальное вершинное покрытие, максимальное независимое множество]]
: Наименьший общий предок
:* 📄 [[Метод двоичного подъёма]]''O(NlogN), O(logN)''
:* [[Сведение LCA к RMQ и RMQ к LCA]]
:* [[Алгоритм Тарьяна (offline)]]''O(N), O(1)''
: Декомпозиции деревьев
:* 📄 [[Heavy-light-декомпозиция]]
|
;Полный перебор и методы его оптимизации
:
:* [[Полный перебор]]
:* [[Два указателя]]
:* Meet in the middle
:* [[Жадные алгоритмы]]
: Динамическое программирование
:* [[Динамическое программирование]]
:* [[Задача о рюкзаке и связанные задачи]]
:* [[Оптимизации динамического программирования]]
;Математика
:
: Теория чисел
:* 📄 [[НОД. Алгоритм Евклида]]
:* 📄 [[Простые числа. Решето Эратосфена]]
:* 📄 [[Быстрое возведение в степень]]
:* 📄 [[Модульная арифметика]]
:* 📝 [[Длинная арифметика]]
:* 📄 [[Метод Гаусса]]
:* 📄 [[Быстрое преобразование Фурье]]
: Комбинаторика
:* 📄 [[Подсчёт и перечисление комбинаторных объектов]]
:* [[Получение номера по объекту и объекта по номеру]]
:* [[Перестановки]]
: Теория игр
:* [[Игры]]
: Геометрия
:* 📝 [[Геометрические примитивы]]
:* 📄 [[Выпуклая оболочка]]

; Алгоритмы для работы со строками
:
:* 📄 [[Хеширование строк]]
:* 📄 [[Префикс-функция]]
:* 📄 [[Алгоритм Ахо-Корасик]]
:* 📄 [[Z-функция]]
:* 📄 [[Алгоритм Манакера]]
:* 📄 [[Суффиксный массив]]
: Разбор выражений
:* 📝 [[Наивный рекурсивный разбор]]
:* 📄 [[Алгоритм сортировочной станции]]

; Разное
:
:* 📄 [[Часто используемые фрагменты]]
|}

''© В. А. Фолунин, 2012–2026''

Heavy-light-декомпозиция

2026-02-14T21:58:56Z

Ctrlalt:

struct SegmentTree {
int size;
vector<int> t;

int query(int v, int vl, int vr, int l, int r) {
if (vr < l || r < vl)
return -1e9;
if (l <= vl && vr <= r)
return t[v];
int vm = vl + (vr - vl) / 2;
int ql = query(2 * v + 1, vl, vm, l, r);
int qr = query(2 * v + 2, vm + 1, vr, l, r);
return max(ql, qr);
}

void modify(int v, int vl, int vr, int index, int value) {
if (vr < index || index < vl)
return;
if (vl == vr) {
t[v] += value;
return;
}
int vm = vl + (vr - vl) / 2;
modify(2 * v + 1, vl, vm, index, value);
modify(2 * v + 2, vm + 1, vr, index, value);
t[v] = max(t[2 * v + 1], t[2 * v + 2]);
}

SegmentTree(int size) : size(size), t(4 * size) {}

int getMax(int l, int r) {
return query(0, 0, size - 1, l, r);
}

void addValue(int index, int value) {
modify(0, 0, size - 1, index, value);
}
};

struct HeavyLightDecomposition {
vector<vector<int>> graph;
vector<int> l, r, parent, subtreeSize;
int timer = 0;
vector<vector<int>> paths;
vector<int> pathOf, posOf;
vector<SegmentTree> segmentTrees;

HeavyLightDecomposition(int vertexCount) :
graph(vertexCount), l(vertexCount), r(vertexCount),
parent(vertexCount), subtreeSize(vertexCount),
pathOf(vertexCount), posOf(vertexCount) {}

void addEdge(int a, int b) {
graph[a].push_back(b);
graph[b].push_back(a);
}

int dfs(int v, int p) {
l[v] = timer++;
parent[v] = p;
subtreeSize[v] = 1;

for (int to : graph[v])
if (to != p)
subtreeSize[v] += dfs(to, v);

r[v] = timer++;
return subtreeSize[v];
}

bool isAncestor(int a, int b) {
return l[a] <= l[b] && r[b] <= r[a];
}

void buildPath(int v, int pathIndex) {
if (paths.size() == pathIndex)
paths.emplace_back();
paths[pathIndex].push_back(v);

pathOf[v] = pathIndex;
posOf[v] = paths[pathIndex].size() - 1;

int maxTo = -1;
for (int to : graph[v])
if (to != parent[v] && (maxTo == -1 || subtreeSize[maxTo] < subtreeSize[to]))
maxTo = to;

for (int to : graph[v]) {
if (to == parent[v])
continue;
if (to == maxTo)
buildPath(to, pathIndex);
else
buildPath(to, paths.size());
}
}

void prepare(int root) {
dfs(root, -1);
buildPath(root, 0);
for (vector<int> &path : paths)
segmentTrees.push_back(SegmentTree(path.size()));
}

int getMax(int a, int b) {
int res = 0;

for (; !isAncestor(paths[pathOf[a]][0], b); a = parent[paths[pathOf[a]][0]])
res = max(res, segmentTrees[pathOf[a]].getMax(0, posOf[a]));
for (; !isAncestor(paths[pathOf[b]][0], a); b = parent[paths[pathOf[b]][0]])
res = max(res, segmentTrees[pathOf[b]].getMax(0, posOf[b]));

if (posOf[a] > posOf[b])
swap(a, b);
return max(res, segmentTrees[pathOf[a]].getMax(posOf[a], posOf[b]));
}

void addValue(int v, int value) {
segmentTrees[pathOf[v]].addValue(posOf[v], value);
}
};

== Ссылки на задачи ==
* [http://acm.timus.ru/problem.aspx?num=1553 Timus #1553 — Caves and Tunnels]

== Ссылки ==
* [http://e-maxx.ru/algo/heavy_light e-maxx.ru — Heavy-light декомпозиция]
* [http://blog.anudeep2011.com/heavy-light-decomposition/ blog.anudeep2011.com — Heavy Light Decomposition]
* [http://github.com/indy256/codelibrary/blob/master/java/src/HeavyLight.java CodeLibrary — Heavy-light tree decomposition for edges or vertices]
* [http://github.com/ADJA/algos/blob/master/Graphs/HLD.cpp Algos — Heavy-light decomposition with segment trees in paths]
* [http://github.com/ADJA/algos/blob/master/Graphs/LCAHLD.cpp Algos — Finding LCA (Least common ancestor) of two vertices in the tree. Uses heavy-light decomposition]

[[Категория:Учебный курс «Алгоритмы и структуры данных»]]

Категория:Учебный курс «Алгоритмы и структуры данных»

2026-01-12T18:26:18Z

Ctrlalt:

{|
|
;Сортировка и поиск
:
:* [[Асимптотический анализ алгоритмов]]
:* [[Анализ рекуррентных соотношений. Мастер-теорема]]
: Простейшие алгоритмы сортировки
:* 📄 [[Сортировка выбором]]
:* 📄 [[Сортировка вставками]]
: Улучшенные алгоритмы сортировки
:* 📄 [[Сортировка слиянием]]
:* 📄 [[Быстрая сортировка]]
: Сортировка за линейное время
:* [[Сортировка подсчётом]]
:* [[Поразрядная сортировка]]
: Алгоритмы поиска
:* [[Бинарный поиск]]
:* [[Тернарный поиск]]
: Применение сортировки
:* [[Сканирующая прямая]]
;Структуры данных
:
: Базовые структуры и абстрактные типы данных
:* [[Динамический массив]]
:* [[Связный список]]
:* [[Стек]]
:* [[Очередь]]
:* [[Очередь с приоритетами]]
:* [[Множество. Реализация на битовых векторах]]
:* [[Множество и словарь. Реализация на деревьях поиска]]
:* [[Множество и словарь. Реализация на хеш-таблицах]]
:* [[Система непересекающихся множеств]]
: Балансирующиеся деревья
:* 📄 [[АВЛ-дерево]]
:* 📄 [[Красно-чёрное дерево]]
:* [[Декартово дерево]]
:* 📄 [[Расширения декартова дерева]]
: Обработка запросов на отрезках
:* 📄 [[Префиксные суммы]]
:* [[Дерево Фенвика]]
:* 📄 [[Дерево отрезков]]
:* 📄 [[Sparse table]]
:* Sqrt-декомпозиция
:* [[Алгоритм Мо]]
|width=450px|
;Алгоритмы для работы с графами
:
:* [[Основные определения. Представление графов]]
: Поиск в глубину и его приложения
:* 📄 [[Поиск в глубину]]''O(V+E)''
:* 📄 [[Компоненты связности]]
:* 📄 [[Циклы в графе. Двудольность]]
:* 📄 [[Топологическая сортировка]]
:* 📄 [[Компоненты сильной связности. Алгоритм Косараю-Шарира|Компоненты сильной связности]]
:* 📄 [[Мосты. Компоненты рёберной двусвязности|Мосты]]
:* 📄 [[Точки сочленения. Компоненты вершинной двусвязности|Точки сочленения]]
:* 📄 [[Эйлеров цикл. Эйлеров путь]]
: Кратчайшие пути из одной вершины
:* 📄 [[Поиск в ширину]]''O(V+E)''
:* 📝 [[Алгоритм Дейкстры]]''O(V2+E) или O(ElogV)''
:* 📄 [[Алгоритм A*]]
:* [[Алгоритм Форда-Беллмана]]''O(VE)''
:* [[Кратчайшие пути в ациклических орграфах]]''O(V+E)''
: Кратчайшие пути между всеми парами вершин
:* 📄 [[Алгоритм Флойда]]''O(V3)''
:* [[Алгоритм Джонсона]]''O(VElogV)''
: Минимальное остовное дерево
:* 📝 [[Алгоритм Краскала]]''O(ElogV)''
:* 📄 [[Алгоритм Прима]]''O(V2+E) или O(ElogV)''
: Максимальный поток
:* 📄 [[Алгоритм Форда-Фалкерсона]]''O(Flow×E)''
:* 📄 [[Алгоритм Эдмондса-Карпа]]''O(VE2)''
:* 📄 [[Алгоритм Диница]]''O(V2E)''
:* 📝 [[Максимальный поток минимальной стоимости]]
:* [[Применения максимального потока]]
: Максимальное паросочетание
:* 📄 [[Алгоритм Куна]]''O(VE)''
:* 📄 [[Минимальное вершинное покрытие, максимальное независимое множество]]
: Наименьший общий предок
:* 📄 [[Метод двоичного подъёма]]''O(NlogN), O(logN)''
:* [[Сведение LCA к RMQ и RMQ к LCA]]
:* [[Алгоритм Тарьяна (offline)]]''O(N), O(1)''
: Декомпозиции деревьев
:* 📝 [[Heavy-light-декомпозиция]]
|
;Полный перебор и методы его оптимизации
:
:* [[Полный перебор]]
:* [[Два указателя]]
:* Meet in the middle
:* [[Жадные алгоритмы]]
: Динамическое программирование
:* [[Динамическое программирование]]
:* [[Задача о рюкзаке и связанные задачи]]
:* [[Оптимизации динамического программирования]]
;Математика
:
: Теория чисел
:* 📄 [[НОД. Алгоритм Евклида]]
:* 📄 [[Простые числа. Решето Эратосфена]]
:* 📄 [[Быстрое возведение в степень]]
:* 📄 [[Модульная арифметика]]
:* 📝 [[Длинная арифметика]]
:* 📄 [[Метод Гаусса]]
:* 📄 [[Быстрое преобразование Фурье]]
: Комбинаторика
:* 📄 [[Подсчёт и перечисление комбинаторных объектов]]
:* [[Получение номера по объекту и объекта по номеру]]
:* [[Перестановки]]
: Теория игр
:* [[Игры]]
: Геометрия
:* 📝 [[Геометрические примитивы]]
:* 📄 [[Выпуклая оболочка]]

; Алгоритмы для работы со строками
:
:* 📄 [[Хеширование строк]]
:* 📄 [[Префикс-функция]]
:* 📄 [[Алгоритм Ахо-Корасик]]
:* 📄 [[Z-функция]]
:* 📄 [[Алгоритм Манакера]]
:* 📄 [[Суффиксный массив]]
: Разбор выражений
:* 📝 [[Наивный рекурсивный разбор]]
:* 📄 [[Алгоритм сортировочной станции]]

; Разное
:
:* 📄 [[Часто используемые фрагменты]]
|}

''© В. А. Фолунин, 2012–2026''

Алгоритм A*

2026-01-01T14:03:35Z

Ctrlalt:

== Общая схема перехода от Дейкстры к A* ==
* Дейкстра ищет кратчайшие пути от заданной начальной вершины до всех остальных. A* ищет кратчайший путь от заданной начальной вершины до заданной конечной.
* Понадобится эвристическая функция h(v), делающая предположение о том, сколько ещё нужно пройти от вершины v до конечной вершины. Функция h() никогда не должна переоценивать это расстояние (но может недооценивать).
* В Дейкстре мы использовали массив dist[]: dist[v] — кратчайшее расстояние от стартовой вершины до вершины v. Теперь мы дополнительно используем массив distH[]: distH[v] — это оценённая длина пути из стартовой вершины в конечную через вершину v. Очевидно, distH[v] всегда равно dist[v] + h(v).
* Будем сравнивать непосещённые вершины и определять наиболее перспективного соседа не по dist[], а по distH[].
* Заметим, что если h() всегда возвращает 0, то A* превращается в алгоритм Дейкстры.

{|width=100%
|width=50%|
int dijkstra(vector<vector<pair<int, int>>> &graph, int start, int finish) {
vector<int> dist(graph.size(), 1e9);
set<pair<int, int>> q;

dist[start] = 0;
q.insert({ dist[start], start });

while (!q.empty()) {
int v = q.begin()->second;
q.erase(q.begin());

if (v == finish)
return dist[v];

for (auto &[to, w] : graph[v]) {
if (dist[to] > dist[v] + w) {
q.erase({ dist[to], to });
dist[to] = dist[v] + w;
q.insert({ dist[to], to });
}
}

}

return 1e9;
}
|width=50%|
int aStar(vector<vector<pair<int, int>>> &graph, int start, int finish) {
vector<int> dist(graph.size(), 1e9);
{{Changed|1=vector<int> distH(graph.size(), 1e9);}}
set<pair<int, int>> q;

dist[start] = 0;
{{Changed|1=distH[start] = dist[start] + h(start);}}
q.insert({ {{Changed|distH}}[start], start });

while (!q.empty()) {
int v = q.begin()->second;
q.erase(q.begin());

if (v == finish)
return dist[v];

for (auto &[to, w] : graph[v]) {
if (dist[to] > dist[v] + w) {
q.erase({ {{Changed|distH}}[to], to });
dist[to] = dist[v] + w;
{{Changed|1=distH[to] = dist[to] + h(to);}}
q.insert({ {{Changed|distH}}[to], to });
}
}
}

return 1e9;
}
|}

== 15 Puzzle ==

{|width=100%
|colspan=2|
'''Board'''
const int SIDE = 4;
const int SIZE = SIDE * SIDE;

struct Board {
vector<int> a;
int zy, zx, manhattanHeuristic, unsolvable;

void recalculate() {
manhattanHeuristic = 0;
int inv = 0;
for (int y = 0; y < SIDE; y++) {
for (int x = 0; x < SIDE; x++) {
if (a[y * SIDE + x]) {
for (int d = 0; d < y * SIDE + x; d++)
inv += a[d] && a[d] > a[y * SIDE + x];
} else {
zy = y;
zx = x;
}
int tile = (a[y * SIDE + x] + SIZE - 1) % SIZE;
int ty = tile / SIDE, tx = tile % SIDE;
manhattanHeuristic += abs(y - ty) + abs(x - tx);
}
}
unsolvable = (inv + zy) % 2 == 0;
}

bool operator < (const Board &that) const {
if (manhattanHeuristic != that.manhattanHeuristic)
return manhattanHeuristic < that.manhattanHeuristic;
return a < that.a;
}

bool canMove(int dy, int dx) {
int ty = zy + dy, tx = zx + dx;
return 0 <= ty && ty < SIDE && 0 <= tx && tx < SIDE;
}

Board move(int dy, int dx) {
Board res = *this;
int ty = zy + dy, tx = zx + dx;
swap(res.a[zy * SIDE + zx], res.a[ty * SIDE + tx]);
res.recalculate();
return res;
}
};

istream &operator >> (istream &in, Board &board) {
board.a.resize(SIZE);
for (int i = 0; i < SIZE; i++)
in >> board.a[i];
board.recalculate();
return in;
}
|-
|width=50%|
'''A*'''
string aStar(Board &board) {
if (board.unsolvable)
return "NO SOLUTION";

map<Board, int> dist, distH, pred;
set<pair<int, Board>> q;

dist[board] = 0;
distH[board] = dist[board] + board.manhattanHeuristic;
pred[board] = -1;
q.insert({ distH[board], board });

static vector<int> dy = { -1, 0, 1, 0 };
static vector<int> dx = { 0, 1, 0, -1 };
static string dc = "URDL";

while (!q.empty()) {
auto v = *q.begin()->second;
q.erase(q.begin());

if (!v.manhattanHeuristic)
break;

for (int d = 0; d < 4; d++) {
if (!v.canMove(dy[d], dx[d]))
continue;

Board to = v.move(dy[d], dx[d]);

if (auto it = dist.find(to); it == dist.end() || it->second > dist[v] + 1) {
q.erase({ distH[to], to });
dist[to] = dist[v] + 1;
distH[to] = dist[to] + to.manhattanHeuristic;
pred[to] = d;
q.insert({ distH[to], to });
}
}
}

for (int i = 0; i < SIZE; i++)
board.a[i] = (i + 1) % SIZE;
board.recalculate();

string path;
while (1) {
int d = pred[board];
if (d == -1)
break;
path.push_back(dc[d]);
board = board.move(dy[(d + 2) % 4], dx[(d + 2) % 4]);
}
reverse(path.begin(), path.end());
return path;
}

void solve() {
Board board;
cin >> board;
cout << aStar(board) << "\n";
}
|width=50%|
'''IDA*'''
struct Solver {
map<Board, int> visited, pred;

static inline vector<int> dy = { -1, 0, 1, 0 };
static inline vector<int> dx = { 0, 1, 0, -1 };
static inline string dc = "URDL";

bool dfs(Board &v, int depth, int limit, int &nextLimit) {
if (depth + v.manhattanHeuristic > limit) {
nextLimit = min(nextLimit, depth + v.manhattanHeuristic);
return 0;
}

if (!v.manhattanHeuristic)
return 1;

if (auto it = visited.find(v); it != visited.end() && it->second <= depth)
return 0;
visited[v] = depth;

for (int d = 0; d < 4; d++) {
if (!v.canMove(dy[d], dx[d]))
continue;

Board to = v.move(dy[d], dx[d]);

if (dfs(to, depth + 1, limit, nextLimit)) {
pred[to] = d;
return 1;
}
}

return 0;
}

string idaStar(Board &board) {
if (board.unsolvable)
return "NO SOLUTION";

int limit = 0;
while (1) {
int nextLimit = 1e9;
visited.clear();
pred = { { board, -1 } };

if (dfs(board, 0, limit, nextLimit))
break;

limit = nextLimit;
}

for (int i = 0; i < SIZE; i++)
board.a[i] = (i + 1) % SIZE;
board.recalculate();

string path;
while (1) {
int d = pred[board];
if (d == -1)
break;
path.push_back(dc[d]);
board = board.move(dy[(d + 2) % 4], dx[(d + 2) % 4]);
}
reverse(path.begin(), path.end());
return path;
}
} solver;

void solve() {
Board board;
cin >> board;
cout << solver.idaStar(board) << "\n";
}
|}

== Knight Path ==

int aStar(int size, int sy, int sx, int fy, int fx) {
vector<vector<int>> dist(size, vector<int>(size, 1e9));
vector<vector<int>> distH(size, vector<int>(size, 1e9));
set<pair<int, pair<int, int>>> q;

dist[sy][sx] = 0;
distH[sy][sx] = dist[sy][sx] + (abs(sy - fy) + abs(sx - fx)) / 3;
q.insert({ distH[sy][sx], { sy, sx } });

while (!q.empty()) {
auto [y, x] = q.begin()->second;
q.erase(q.begin());

if (y == fy && x == fx)
return dist[y][x];

static int dy[] = { -2, -2, -1, 1, 2, 2, 1, -1 };
static int dx[] = { -1, 1, 2, 2, 1, -1, -2, -2 };

for (int d = 0; d < 8; d++) {
int ty = y + dy[d], tx = x + dx[d];
if (0 <= ty && ty < size && 0 <= tx && tx < size && dist[ty][tx] > dist[y][x] + 1) {
q.erase({ distH[ty][tx], { ty, tx } });
dist[ty][tx] = dist[y][x] + 1;
distH[ty][tx] = dist[ty][tx] + (abs(ty - fy) + abs(tx - fx)) / 3;
q.insert({ distH[ty][tx], { ty, tx } });
}
}
}

return 1e9;
}

== Ссылки ==
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_A* neerc.ifmo.ru/wiki — Алгоритм A*]
* [http://www.redblobgames.com/pathfinding/a-star/introduction.html Red Blob Games — Introduction to the A* Algorithm]
* [http://www.redblobgames.com/pathfinding/a-star/implementation.html Red Blob Games — Implementation of A*]
* [http://theory.stanford.edu/~amitp/GameProgramming/ Red Blob Games — Amit’s A* Pages]
* [http://brilliant.org/wiki/a-star-search Brilliant.org — A* Search]
* [http://www.cs.princeton.edu/courses/archive/fall19/cos226/assignments/8puzzle/specification.php Princeton COS 226 Assignment — 8 Slider Puzzle]

Хеширование строк

2025-12-18T01:48:21Z

Ctrlalt:

hi = s0xn - 1 + s1xn - 2 + ... + sn - 2x + sn - 1.

struct Hasher {
long long mod;
vector<long long> p, h;

Hasher(const string &s, long long factor = 31, long long mod = 1e9 + 7) : mod(mod) {
p.push_back(1);
for (int i = 1; i < s.size(); i++)
p.push_back(p[i - 1] * factor % mod);

h.push_back(s[0] - 'a' + 1);
for (int i = 1; i < s.size(); i++)
h.push_back((h[i - 1] * factor % mod + s[i] - 'a' + 1) % mod);
}

long long getHash(int l, int r) {
long long res = h[r];
if (l)
res = (res - p[r - l + 1] * h[l - 1] % mod + mod) % mod;
return res;
}
};

struct DoubleHasher {
Hasher h1, h2;

DoubleHasher(const string &s) : h1(s), h2(s, 29, 1e9 + 9) {}

pair<long long, long long> getHash(int l, int r) {
return { h1.getHash(l, r), h2.getHash(l, r) };
}
};

struct Hasher2D {
long long mod;
vector<long long> py, px;
vector<vector<long long>> h;

Hasher2D(const vector<string> &a, long long factorY = 29, long long factorX = 31, long long mod = 1e9 + 7) : mod(mod) {
py.push_back(1);
for (int y = 1; y < a.size(); y++)
py.push_back(py[y - 1] * factorY % mod);

px.push_back(1);
for (int x = 1; x < a[0].size(); x++)
px.push_back(px[x - 1] * factorX % mod);

h.assign(a.size(), vector<long long>(a[0].size()));
for (int y = 0; y < a.size(); y++) {
for (int x = 0; x < a[0].size(); x++) {
h[y][x] = (a[y][x] - 'a' + 1) % mod;
if (y)
h[y][x] = (h[y][x] + h[y - 1][x] * factorY) % mod;
if (x)
h[y][x] = (h[y][x] + h[y][x - 1] * factorX) % mod;
if (y && x)
h[y][x] = ((h[y][x] - h[y - 1][x - 1] * factorY * factorX) % mod + mod) % mod;
}
}
}

long long getHash(int yl, int xl, int yr, int xr) {
long long res = h[yr][xr];
if (yl)
res = (res - py[yr - yl + 1] * h[yl - 1][xr] % mod + mod) % mod;
if (xl)
res = (res - px[xr - xl + 1] * h[yr][xl - 1] % mod + mod) % mod;
if (yl && xl)
res = (res + py[yr - yl + 1] * px[xr - xl + 1] % mod * h[yl - 1][xl - 1]) % mod;
return res;
}
};



== Ссылки ==
Теория:
* [http://e-maxx.ru/algo/string_hashes e-maxx.ru — Алгоритмы хэширования в задачах на строки]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D0%BF%D0%BE%D0%B4%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B8_%D0%B2_%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B5_%D1%81_%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC_%D1%85%D0%B5%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F._%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%A0%D0%B0%D0%B1%D0%B8%D0%BD%D0%B0-%D0%9A%D0%B0%D1%80%D0%BF%D0%B0 neerc.ifmo.ru — Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D0%BD%D0%B0%D0%B8%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%B5%D0%B9_%D0%BE%D0%B1%D1%89%D0%B5%D0%B9_%D0%BF%D0%BE%D0%B4%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B8_%D0%B4%D0%B2%D1%83%D1%85_%D1%81%D1%82%D1%80%D0%BE%D0%BA_%D1%81_%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC_%D1%85%D0%B5%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F neerc.ifmo.ru — Поиск наибольшей общей подстроки двух строк с использованием хеширования]
* [https://ru.algorithmica.org/cs/hashing/polynomial/ ru.algorithmica.org — Полиномиальное хеширование]
* [http://habrahabr.ru/post/142589/ habrahabr.ru — Полиномиальные хеши и их применение]
* [http://codeforces.com/blog/entry/4898 codeforces.com — Anti-hash test]
* [http://codeforces.com/blog/entry/60445 codeforces.com — Полиномиальное хеширование + разбор интересных задач]
* [https://blog.algoprog.ru/hash-no-multiply/ Калинин П. — Про хеширование без домножения]
* [https://usaco.guide/gold/string-hashing?lang=cpp usaco.guide — String Hashing]
Код:
* [https://github.com/indy256/codelibrary/blob/master/cpp/strings/hashing.cpp codelibrary/cpp/strings/hashing.cpp]
* [https://github.com/ADJA/algos/blob/master/Strings/Hashing.cpp algos/Strings/Hashing.cpp]
Задачи:
* [[:Категория: Задачи: Хеширование строк|Задачи: Хеширование строк]]

[[Категория:Строки]]

Хеширование строк

2025-12-18T01:28:59Z

Ctrlalt:

hi = s0xn - 1 + s1xn - 2 + ... + sn - 2x + sn - 1.

struct Hasher {
long long mod;
vector<long long> p, h;

Hasher(const string &s, long long factor = 31, long long mod = 1e9 + 7) : mod(mod) {
p.push_back(1);
for (int i = 1; i < s.size(); i++)
p.push_back(p[i - 1] * factor % mod);

h.push_back(s[0] - 'a' + 1);
for (int i = 1; i < s.size(); i++)
h.push_back((h[i - 1] * factor % mod + s[i] - 'a' + 1) % mod);
}

long long getHash(int l, int r) {
long long res = h[r];
if (l)
res = (res - p[r - l + 1] * h[l - 1] % mod + mod) % mod;
return res;
}
};

struct DoubleHasher {
Hasher h1, h2;

DoubleHasher(const string &s) : h1(s), h2(s, 29, 1e9 + 9) {}

pair<long long, long long> getHash(int l, int r) {
return { h1.getHash(l, r), h2.getHash(l, r) };
}
};

struct Hasher2D {
long long mod;
vector<long long> py, px;
vector<vector<long long>> h;

Hasher2D(const vector<string> &a, long long factorY = 29, long long factorX = 31, long long mod = 1e9 + 7) : mod(mod) {
py.push_back(1);
for (int y = 1; y < a.size(); y++)
py.push_back(py[y - 1] * factorY % mod);

px.push_back(1);
for (int x = 1; x < a[0].size(); x++)
px.push_back(px[x - 1] * factorX % mod);

h.assign(a.size(), vector<long long>(a[0].size()));
for (int y = 0; y < a.size(); y++) {
for (int x = 0; x < a[0].size(); x++) {
h[y][x] = (a[y][x] - 'a' + 1) % mod;
if (y)
h[y][x] = (h[y][x] + h[y - 1][x] * factorY) % mod;
if (x)
h[y][x] = (h[y][x] + h[y][x - 1] * factorX) % mod;
if (y && x)
h[y][x] = ((h[y][x] - h[y - 1][x - 1] * factorY * factorX) % mod + mod) % mod;
}
}
}

long long getHash(int yl, int xl, int yr, int xr) {
long long res = h[yr][xr];
if (yl)
res = (res - py[yr - yl + 1] * h[yl - 1][xr] % mod + mod) % mod;
if (xl)
res = (res - px[xr - xl + 1] * h[yr][xl - 1] % mod + mod) % mod;
if (yl && xl)
res = (res + py[yr - yl + 1] * px[xr - xl + 1] % mod * h[yl - 1][xl - 1]) % mod;
return res;
}
};

{| width="100%"
| width=50% |
hi = s0 + s1x + s2x2 + ... + sn - 1xn - 1.

Для выравнивания хеши различных подстрок домножаются на xn - 1 - L.

struct Hasher {
long long x = 31, mod = 1e9 + 7;
vector<long long> p, h;

Hasher(const string &s) {
p.resize(s.size());
h.resize(s.size());

p[0] = 1;
h[0] = s[0] - 'a' + 1;

for (int i = 1; i < s.size(); i++) {
p[i] = p[i - 1] * x % mod;
h[i] = (h[i - 1] + p[i] * (s[i] - 'a' + 1) % mod) % mod;
}
}

long long getHash(int l, int r) {
long long res = h[r];
if (l)
res = (res - h[l - 1] + mod) % mod;
res = res * p[p.size() - 1 - l] % mod;
return res;
}
};

Этот способ непригоден для сравнения участков двух строк разной длины. В данном случае хеш более левого участка следует домножать на x|L1 - L2|.

| width="10px" |  
| width=50% |
hi = s0 + s1x + s2x2 + ... + sn - 1xn - 1.

Для выравнивания хеши различных подстрок домножаются на (x-1)L.

struct Hasher {
long long x = 31, {{Changed|1=xi = 129032259,}} mod = 1e9 + 7;
vector<long long> p, {{Changed|pi,}} h;

Hasher(const string &s) {
p.resize(s.size());
{{Changed|pi.resize(s.size());}}
h.resize(s.size());

p[0] = {{Changed|1=pi[0] = }} 1;
h[0] = s[0] - 'a' + 1;

for (int i = 1; i < s.size(); i++) {
p[i] = p[i - 1] * x % mod;
{{Changed|1=pi[i] = pi[i - 1] * xi % mod;}}
h[i] = (h[i - 1] + p[i] * (s[i] - 'a' + 1) % mod) % mod;
}
}

long long getHash(int l, int r) {
long long res = h[r];
if (l) {
res = (res - h[l - 1] + mod) % mod;
{{Changed|1=res = (res * pi[l]) % mod}};
}
return res;
}
};
|}

== Ссылки ==
Теория:
* [http://e-maxx.ru/algo/string_hashes e-maxx.ru — Алгоритмы хэширования в задачах на строки]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D0%BF%D0%BE%D0%B4%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B8_%D0%B2_%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B5_%D1%81_%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC_%D1%85%D0%B5%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F._%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%A0%D0%B0%D0%B1%D0%B8%D0%BD%D0%B0-%D0%9A%D0%B0%D1%80%D0%BF%D0%B0 neerc.ifmo.ru — Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D0%BD%D0%B0%D0%B8%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%B5%D0%B9_%D0%BE%D0%B1%D1%89%D0%B5%D0%B9_%D0%BF%D0%BE%D0%B4%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B8_%D0%B4%D0%B2%D1%83%D1%85_%D1%81%D1%82%D1%80%D0%BE%D0%BA_%D1%81_%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC_%D1%85%D0%B5%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F neerc.ifmo.ru — Поиск наибольшей общей подстроки двух строк с использованием хеширования]
* [https://ru.algorithmica.org/cs/hashing/polynomial/ ru.algorithmica.org — Полиномиальное хеширование]
* [http://habrahabr.ru/post/142589/ habrahabr.ru — Полиномиальные хеши и их применение]
* [http://codeforces.com/blog/entry/4898 codeforces.com — Anti-hash test]
* [http://codeforces.com/blog/entry/60445 codeforces.com — Полиномиальное хеширование + разбор интересных задач]
* [https://blog.algoprog.ru/hash-no-multiply/ Калинин П. — Про хеширование без домножения]
* [https://usaco.guide/gold/string-hashing?lang=cpp usaco.guide — String Hashing]
Код:
* [https://github.com/indy256/codelibrary/blob/master/cpp/strings/hashing.cpp codelibrary/cpp/strings/hashing.cpp]
* [https://github.com/ADJA/algos/blob/master/Strings/Hashing.cpp algos/Strings/Hashing.cpp]
Задачи:
* [[:Категория: Задачи: Хеширование строк|Задачи: Хеширование строк]]

[[Категория:Строки]]

Задача о рюкзаке и связанные задачи

2025-11-19T00:38:03Z

Ctrlalt: /* Каким минимальным количеством предметом можно набрать сумму targetSum */

__TOC__

== Задача о сумме подмножеств (subset sum problem) ==

=== Можно ли набрать заданный вес ===
Есть несколько предметов, для каждого известен вес. Можем ли мы выбрать несколько предметов так, чтобы общий вес был в точности равен заданному числу?

vector<int> itemWeight; // веса предметов
int targetWeight; // вес, который нужно набрать

Будем заполнять таблицу canMake[][]. Строки таблицы соответствуют количеству рассмотренных предметов: нулевая строка — ноль предметов, первая строка — один предмет, ..., N-я строка — N предметов. Столбцы таблицы соответствуют весам от 0 до заданного веса. В ячейках хранятся true и false: canMake[items][weight] == true, если мы можем набрать вес weight, используя некоторые из items первых предметов.

vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

Как должна выглядеть нулевая строка таблицы? В нулевой строке мы описываем ситуацию, когда не рассмотрено ещё ни одного предмета; какие веса мы при этом можем набрать? Очевидно, только вес 0. Поэтому ячейка canMake[0][0] должна содержать true, а остальные ячейки первой строки — false.

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)

Теперь разберёмся, как должна выглядеть первая строка таблицы (она соответствует первому предмету). Пусть, для определённости, вес первого предмета — 3 (itemWeight[0] == 3). Какие веса мы теперь можем набрать?

Нам всё ещё доступен вес 0 (если мы не будем брать первый предмет), но теперь мы можем получить ещё и вес 3 (если мы возьмём первый предмет).

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)
строка canMake[1] 1 0 0 1 0 0 0 0 0 0 0
(вес предмета — 3)

Далее — вторая строка таблицы (она соответствует первым двум предметам). Пусть вес второго предмета — 5 (itemWeight[1] == 5). Какие веса мы теперь можем набрать?

Нам всё ещё доступны веса 0 и 3 (если мы не будем брать второй предмет), но теперь мы можем получить ещё веса 5 (если мы до этого не брали ничего, а теперь возьмём второй предмет) и 8 (если мы до этого взяли первый предмет и получили вес 3, а сейчас добавим второй предмет).

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)
строка canMake[1] 1 0 0 1 0 0 0 0 0 0 0
(вес предмета — 3)
строка canMake[2] 1 0 0 1 0 1 0 0 1 0 0
(вес предмета — 5)

Далее — третья строка таблицы (она соответствует первым трём предметам). Пусть вес третьего предмета — 2 (itemWeight[2] == 2).

Раньше (без третьего предмета) мы могли набрать веса 0, 3, 5 и 8. Теперь (с третьим предметом) можем дополнительно набрать 2, 5, 7 и 10. Обратите внимание, что вес 5 мы могли набрать как без третьего предмета (просто взяв второй предмет с весом 5), так и с ним (взяв первый и третий предметы с весами 3 и 2); ничего необычного в этой ситуации нет.

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)
строка canMake[1] 1 0 0 1 0 0 0 0 0 0 0
(вес предмета — 3)
строка canMake[2] 1 0 0 1 0 1 0 0 1 0 0
(вес предмета — 5)
строка canMake[3] 1 0 1 1 0 1 0 1 1 0 1
(вес предмета — 2)

Сделаем общие выводы о том, как заполняются строки таблицы. Когда будет true в ячейке canMake[items][weight], то есть когда мы можем набрать вес weight первыми items предметами?

* Во-первых, если мы могли набрать вес weight только предыдущими предметами, не используя новый. То есть, если в предыдущей строке на позиции weight было true (canMake[items - 1][weight] == true).
* Во-вторых, если мы могли набрать вес (weight - currentItemWeight) предыдущими предметами (currentItemWeight — вес текущего предмета). В этом случае, если мы добавим текущий предмет, то мы получим как раз вес weight. То есть, если в предыдущей строке на позиции (weight - currentItemWeight) было true (canMake[items - 1][weight - currentItemWeight] == true).

Теперь мы готовы написать код заполнения таблицы:

bool solve(const vector<int> &itemWeight, int targetWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight])
canMake[items][weight] = true;
}
}

return canMake[items.size()][targetWeight];
}

Ответ на задачу в итоге будет записан в последнюю ячейку последней строки (canMake[itemWeight.size()][targetWeight]).

Временная сложность решения — Θ(NM) (N — количество предметов, M — целевой вес). Для таблицы требуется Θ(NM) памяти.

=== Можно ли набрать заданный вес, каждый предмет можно брать несколько раз ===

Посмотрим, как изменится заполнение таблицы:

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)
строка canMake[1] 1 0 0 1 0 0 1 0 0 1 0
(вес предмета — 3)
строка canMake[2] 1 0 0 1 0 1 1 0 1 1 1
(вес предмета — 5)
строка canMake[3] 1 0 1 1 1 1 1 1 1 1 1
(вес предмета — 2)

canMake[items][weight] == true, если canMake[items - 1][weight] == true или canMake[items][weight - currentItemWeight] == true.

bool solve(const vector<int> &itemWeight, int targetWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[{{Changed|items}}][weight - currentItemWeight])
canMake[items][weight] = true;
}
}

return canMake[items.size()][targetWeight];
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(NM) памяти.

Заметим, что в данном случае мы можем не делать двумерную таблицу. Нам будет достаточно одной строки canMake[].

bool solve(const vector<int> &itemWeight, int targetWeight) {
vector<bool> canMake(targetWeight + 1);

canMake[0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = currentItemWeight; weight <= targetWeight; weight++) {
if (canMake[weight - currentItemWeight])
canMake[weight] = true;
}
}

return canMake[targetWeight];
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(M) памяти.

=== Можно ли набрать заданный вес, Θ(M) памяти ===

Как и в предыдущем случае, мы можем не делать двумерную таблицу. Нам будет достаточно одной строки canMake[].

Здесь, однако, нужно обратить внимание на то, что если мы будем обновлять строку слева направо, то мы будем учитывать один и тот же предмет несколько раз (как в предыдущем случае). То есть, например, если первый предмет имеет вес 3, то мы запишем true в ячейку 3 (так как в ячейке 0 записано true), затем в ячейку 6 (так как в ячейке 3 записано true), затем в ячейку 9 (так как в ячейке 6 записано true)...

Чтобы избежать такой ситуации, следует обновлять строку не слева направо, а справа налево. Тогда в ячейках слева от текущей никогда не будет изменений, связанных с текущим предметом.

bool solve(const vector<int> &itemWeight, int targetWeight) {
vector<bool> canMake(targetWeight + 1);

canMake[0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for ({{Changed|1=int weight = targetWeight; weight >= currentItemWeight; weight--}}) {
if (canMake[weight - currentItemWeight])
canMake[weight] = true;
}
}

return canMake[targetWeight];
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(M) памяти.

=== Можно ли набрать заданный вес, мало предметов, очень большие веса (⋆) ===
Мы уже не сможем решить такую задачу при помощи динамического программирования, так как при очень большом targetWeight потребуется очень большая таблица, которая не уместится в память (не говоря уже о времени её заполнения).

Если у нас < 25 предметов, можно просто перебрать все их подмножества (рекурсивно или масками, временная сложность O(2^N)).

Если у нас < 50 предметов, кроме перебора понадобится техника meet in the middle. Разделим предметы на две половины. Для каждой половины сделаем set из всех весов, которые можно составить из предметов в этой половине. Дальше нам нужно найти в двух setах два элемента, в сумме дающие targetWeight.

unordered_set<long long> getTotalWeights(const vector<long long> &itemWeight) {
unordered_set<long long> totalWeights;

for (int mask = 0; mask < (1 << itemWeight.size()); mask++) {
long long totalWeight = 0;

for (int bit = 0; bit < itemWeight.size(); bit++) {
if (mask & (1 << bit))
totalWeight += itemWeight[bit];
}

totalWeights.push_back(totalWeight);
}

return totalMasses;
}

bool solve(const vector<long long> &itemWeight, long long targetWeight) {
auto mid = itemWeight.begin() + itemWeight.size() / 2;
unordered_set<long long> aWeights = getTotalWeights({itemWeight.begin(), mid});
unordered_set<long long> bWeights = getTotalWeights({mid, itemWeight.end()});

for (long long aWeight : aWeights) {
if (bWeights.count(targetWeight - aWeight))
return true;
}

return false;
}

Временная сложность решения Θ(2^(N/2)). Для множеств требуется O(2^(N/2)) памяти.

=== Номера предметов, дающих заданный вес ===

Иногда в задаче требуется не только определить, можем ли мы набрать заданный вес, но и вывести сертификат — номера (индексы) предметов, которые мы должны взять.

Вдобавок к таблице canMake[][] сделаем таблицу take[][], в которой будем отмечать, брали ли мы последний предмет. take[items][weight] == true, если, когда мы рассматривали items предметов, мы смогли набрать вес weight, взяв последний предмет (его индекс — (items - 1)).

Заполнение таблицы take[][] происходит одновременно с заполнением таблицы canMake[][]. Всякий раз, когда мы смогли набрать вес при помощи нового предмета, мы ставим true не только в canMake[][], но и в take[][].

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight]) {
canMake[items][weight] = true;
take[items][weight] = true;
}

Когда у нас есть заполненная таблица take[][], мы можем по ней восстановить номера использованных предметов. Обозначим за weight вес предметов, которые нам нужно взять (изначально weight == targetWeight).

Как понять, взяли ли мы самый последний предмет? Если take[items][weight] == true, то мы его брали, иначе — не брали. Если мы взяли последний предмет, то weight нужно уменьшить на itemWeight[items - 1].

Как понять, взяли ли мы предпоследний предмет? Если take[items - 1][weight] == true, то мы его брали, иначе — не брали. Если мы взяли предпоследний предмет, то weight нужно уменьшить на itemWeight[items - 2].

И так далее, от конца к началу мы определяем, брали или нет мы каждый из предметов, попутно уменьшая weight.

{{Changed|vector<int>}} solve(const vector<int> &itemWeight, int targetWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));
{{Changed|vector<vector<bool>> take(itemWeight.size() + 1, vector<int>(targetWeight + 1));}}

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight]) {
canMake[items][weight] = true;
{{Changed|1=take[items][weight] = true;}}
}
}
}

{{Changed|1=if (!canMake[itemWeight.size()][targetItem])}}
{{Changed|1=return {};}}

{{Changed|1=vector<int> takenItemIndexes;}}
{{Changed|1=for (int items = itemWeight.size(), weight = targetWeight; items > 0; items--) {}}
{{Changed|1=if (take[items][weight]) {}}
{{Changed|1=takenItemIndexes.push_back(items - 1);}}
{{Changed|1=weight -= itemWeight[items - 1];}}
{{Changed|1=} }}
{{Changed|1=} }}
{{Changed|1=return takenItemIndexes;}}
}

Временная сложность решения Θ(NM). Для таблиц требуется Θ(NM) памяти.

=== Номера предметов, дающих заданный вес, Θ(M) памяти (⋆) ===

* [https://stackoverflow.com/questions/51941993/0-1-knapsack-find-solution-set-in-space-optimised-implementation stackoverflow.com/questions/51941993/0-1-knapsack-find-solution-set-in-space-optimised-implementation]
* [https://www.cs.colostate.edu/~cs575dl/Sp2015/Lectures/Knapsack.pdf www.cs.colostate.edu/~cs575dl/Sp2015/Lectures/Knapsack.pdf]

vector<bool> getCanMake(const vector<int> &itemWeight, int targetWeight, int l, int r) {
vector<bool> canMake(targetWeight + 1);

canMake[0] = true;

for (int itemIndex = l; itemIndex <= r; itemIndex++) {
int currentItemWeight = itemWeight[itemIndex];

for (int weight = currentItemWeight; weight <= targetWeight; weight++) {
if (canMake[weight - currentItemWeight])
canMake[weight] = true;
}
}

return canMake;
}

vector<int> solve(const vector<int> &itemWeight, int targetWeight, int l, int r) {
if (l == r)
return targetWeight == itemWeight[l] ? { l } : {};

int m = l + (r - l) / 2;
vector<bool> aCan = getCanMake(itemWeight, targetWeight, l, m);
vector<bool> bCan = getCanMake(itemWeight, targetWeight, m + 1, r);

int aWeight = 0, bWeight = targetWeight;
while (!aCan[aWeight] || !bCan[bWeight]) {
aWeight++;
bWeight--;
}

vector<int> aItemIndexes = solve(itemWeight, aWeight, l, m);
vector<int> bItemIndexes = solve(itemWeight, bWeight, m + 1, r);
aItemIndexes.insert(aItemIndexes.end(), bIntemIndexes.begin(), bItemIndexes.end());
return aItemIndexes;
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(M) памяти.

== Вариации на тему задачи о сумме подмножеств ==

=== Какой максимальный вес не больше заданного можно набрать ===

Решаем задачу о сумме подмножеств, ищем самое правое true в последней строке таблицы.

{{Changed|int}} solve(const vector<int> &itemWeight, int targetWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight])
canMake[items][weight] = true;
}
}

{{Changed|1=while (!canMake[items.size()][targetWeight])}}
{{Changed|1=targetWeight--;}}
{{Changed|1=return targetWeight;}}
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(NM) или Θ(M) памяти.

=== Можно ли разделить предметы на два набора одинакового веса ===

Решаем задачу о сумме подмножеств для targetWeight == (сумма весов предметов) / 2.

bool solve(const vector<int> &itemWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

{{Changed|1=int targetWeight = 0;}}
{{Changed|1=for (int weight : itemWeight)}}
{{Changed|1=targetWeight += weight;}}
{{Changed|1=targetWeight /= 2;}}

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight])
canMake[items][weight] = true;
}
}

return canMake[items.size()][targetWeight];
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(NM) или Θ(M) памяти.

== Примеры кода ==

=== Можно ли набрать сумму targetSum ===

==== O(items.size() * targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
bool canMakeSum(vector<int> &items, int targetSum) {
vector<vector<bool>> canMake(items.size() + 1, vector<bool>(targetSum + 1));
canMake[0][0] = true;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++)
if (canMake[itemCount - 1][sum] ||
sum >= itemWeight && canMake[itemCount - 1][sum - itemWeight])
canMake[itemCount][sum] = true;
}

return canMake[items.size()][targetSum];
}
|
|
bool canMakeSum(vector<int> &items, int targetSum) {
vector<vector<bool>> canMake(items.size() + 1, vector<bool>(targetSum + 1));
canMake[0][0] = true;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++)
if (canMake[itemCount - 1][sum] ||
sum >= itemWeight && canMake[itemCount][sum - itemWeight])
canMake[itemCount][sum] = true;
}

return canMake[items.size()][targetSum];
}
|}

==== O(items.size() * targetSum) памяти, вернуть сертификат (список предметов) ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
vector<int> canMakeSum(vector<int> &items, int targetSum) {
vector<vector<bool>> canMake(items.size() + 1, vector<bool>(targetSum + 1));
canMake[0][0] = true;
vector<vector<pair<int, int>>> from(items.size() + 1, vector<pair<int, int>>(targetSum + 1));

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (canMake[itemCount - 1][sum]) {
canMake[itemCount][sum] = true;
from[itemCount][sum] = { itemCount - 1, sum };
} else if (sum >= itemWeight && canMake[itemCount - 1][sum - itemWeight]) {
canMake[itemCount][sum] = true;
from[itemCount][sum] = { itemCount - 1, sum - itemWeight };
}
}
}

if (!canMake[items.size()][targetSum])
return {};

vector<int> takenItems;
for (int itemCount = items.size(), sum = targetSum; itemCount > 0; ) {
auto &[prevItemCount, prevSum] = from[itemCount][sum];
if (prevSum != sum)
takenItems.push_back(sum - prevSum);
itemCount = prevItemCount;
sum = prevSum;
}
return takenItems;
}
|
|
vector<int> canMakeSum(vector<int> &items, int targetSum) {
vector<vector<bool>> canMake(items.size() + 1, vector<bool>(targetSum + 1));
canMake[0][0] = true;
vector<vector<pair<int, int>>> from(items.size() + 1, vector<pair<int, int>>(targetSum + 1));

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (canMake[itemCount - 1][sum]) {
canMake[itemCount][sum] = true;
from[itemCount][sum] = { itemCount - 1, sum };
} else if (sum >= itemWeight && canMake[itemCount][sum - itemWeight]) {
canMake[itemCount][sum] = true;
from[itemCount][sum] = { itemCount, sum - itemWeight };
}
}
}

if (!canMake[items.size()][targetSum])
return {};

vector<int> takenItems;
for (int itemCount = items.size(), sum = targetSum; itemCount > 0; ) {
auto &[prevItemCount, prevSum] = from[itemCount][sum];
if (prevSum != sum)
takenItems.push_back(sum - prevSum);
itemCount = prevItemCount;
sum = prevSum;
}
return takenItems;
}
|}

==== O(targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
bool canMakeSum(vector<int> &items, int targetSum) {
vector<bool> canMake(targetSum + 1);
canMake[0] = true;

for (int itemWeight : items)
for (int sum = targetSum; sum >= itemWeight; sum--)
if (canMake[sum - itemWeight])
canMake[sum] = true;

return canMake[targetSum];
}
|
|
bool canMakeSum(vector<int> &items, int targetSum) {
vector<bool> canMake(targetSum + 1);
canMake[0] = true;

for (int itemWeight : items)
for (int sum = itemWeight; sum <= targetSum; sum++)
if (canMake[sum - itemWeight])
canMake[sum] = true;

return canMake[targetSum];
}
|}

==== O(targetSum) памяти, вернуть сертификат (список предметов) ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
vector<int> canMakeSum(vector<int> &items, int targetSum) {
vector<bool> canMake(targetSum + 1);
canMake[0] = true;
vector<int> from(targetSum + 1);

for (int itemWeight : items) {
for (int sum = targetSum; sum >= itemWeight; sum--) {
if (!canMake[sum] && canMake[sum - itemWeight]) {
canMake[sum] = true;
from[sum] = sum - itemWeight;
}
}
}

if (!canMake[targetSum])
return {};

vector<int> takenItems;
for (int sum = targetSum; sum > 0; sum = from[sum])
takenItems.push_back(sum - from[sum]);
return takenItems;
}
|
|
vector<int> canMakeSum(vector<int> &items, int targetSum) {
vector<bool> canMake(targetSum + 1);
canMake[0] = true;
vector<int> from(targetSum + 1);

for (int itemWeight : items) {
for (int sum = itemWeight; sum <= targetSum; sum++) {
if (!canMake[sum] && canMake[sum - itemWeight]) {
canMake[sum] = true;
from[sum] = sum - itemWeight;
}
}
}

if (!canMake[targetSum])
return {};

vector<int> takenItems;
for (int sum = targetSum; sum > 0; sum = from[sum])
takenItems.push_back(sum - from[sum]);
return takenItems;
}
|}

=== Каким минимальным количеством предметов можно набрать сумму targetSum ===

==== O(items.size() * targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
int getMinCount(vector<int> &items, int targetSum) {
vector<vector<int>> minCount(items.size() + 1, vector<int>(targetSum + 1, 1e9));
minCount[0][0] = 0;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (minCount[itemCount][sum] > minCount[itemCount - 1][sum])
minCount[itemCount][sum] = minCount[itemCount - 1][sum];
if (sum >= itemWeight && minCount[itemCount][sum] > minCount[itemCount - 1][sum - itemWeight] + 1)
minCount[itemCount][sum] = minCount[itemCount - 1][sum - itemWeight] + 1;
}
}

return minCount[items.size()][targetSum];
}
|
|
int getMinCount(vector<int> &items, int targetSum) {
vector<vector<int>> minCount(items.size() + 1, vector<int>(targetSum + 1, 1e9));
minCount[0][0] = 0;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (minCount[itemCount][sum] > minCount[itemCount - 1][sum])
minCount[itemCount][sum] = minCount[itemCount - 1][sum];
if (sum >= itemWeight && minCount[itemCount][sum] > minCount[itemCount][sum - itemWeight] + 1)
minCount[itemCount][sum] = minCount[itemCount][sum - itemWeight] + 1;
}
}

return minCount[items.size()][targetSum];
}
|}

==== O(items.size() * targetSum) памяти, вернуть сертификат (список предметов) ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
vector<int> getMinCount(vector<int> &items, int targetSum) {
vector<vector<int>> minCount(items.size() + 1, vector<int>(targetSum + 1, 1e9));
minCount[0][0] = 0;
vector<vector<pair<int, int>>> from(items.size() + 1, vector<pair<int, int>>(targetSum + 1));

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (minCount[itemCount][sum] > minCount[itemCount - 1][sum]) {
minCount[itemCount][sum] = minCount[itemCount - 1][sum];
from[itemCount][sum] = { itemCount - 1, sum };
}
if (sum >= itemWeight && minCount[itemCount][sum] > minCount[itemCount - 1][sum - itemWeight] + 1) {
minCount[itemCount][sum] = minCount[itemCount - 1][sum - itemWeight] + 1;
from[itemCount][sum] = { itemCount - 1, sum - itemWeight };
}
}
}

if (minCount[items.size()][targetSum] == 1e9)
return {};

vector<int> takenItems;
for (int itemCount = items.size(), sum = targetSum; itemCount > 0; ) {
auto &[prevItemCount, prevSum] = from[itemCount][sum];
if (prevSum != sum)
takenItems.push_back(sum - prevSum);
itemCount = prevItemCount;
sum = prevSum;
}
return takenItems;
}
|
|
vector<int> getMinCount(vector<int> &items, int targetSum) {
vector<vector<int>> minCount(items.size() + 1, vector<int>(targetSum + 1, 1e9));
minCount[0][0] = 0;
vector<vector<pair<int, int>>> from(items.size() + 1, vector<pair<int, int>>(targetSum + 1));

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (minCount[itemCount][sum] > minCount[itemCount - 1][sum]) {
minCount[itemCount][sum] = minCount[itemCount - 1][sum];
from[itemCount][sum] = { itemCount - 1, sum };
}
if (sum >= itemWeight && minCount[itemCount][sum] > minCount[itemCount][sum - itemWeight] + 1) {
minCount[itemCount][sum] = minCount[itemCount][sum - itemWeight] + 1;
from[itemCount][sum] = { itemCount, sum - itemWeight };
}
}
}

if (minCount[items.size()][targetSum] == 1e9)
return {};

vector<int> takenItems;
for (int itemCount = items.size(), sum = targetSum; itemCount > 0; ) {
auto &[prevItemCount, prevSum] = from[itemCount][sum];
if (prevSum != sum)
takenItems.push_back(sum - prevSum);
itemCount = prevItemCount;
sum = prevSum;
}
return takenItems;
}
|}

==== O(targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
int getMinCount(vector<int> &items, int targetSum) {
vector<int> minCount(targetSum + 1, 1e9);
minCount[0] = 0;

for (int itemWeight : items)
for (int sum = targetSum; sum >= itemWeight; sum--)
if (minCount[sum] > minCount[sum - itemWeight] + 1)
minCount[sum] = minCount[sum - itemWeight] + 1;

return minCount[targetSum];
}
|
|
int getMinCount(vector<int> &items, int targetSum) {
vector<int> minCount(targetSum + 1, 1e9);
minCount[0] = 0;

for (int itemWeight : items)
for (int sum = itemWeight; sum <= targetSum; sum++)
if (minCount[sum] > minCount[sum - itemWeight] + 1)
minCount[sum] = minCount[sum - itemWeight] + 1;

return minCount[targetSum];
}
|}

==== O(targetSum) памяти, вернуть сертификат (список предметов) ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
(Невозможно. Контртест: items = { 1, 2, 3 }, targetSum = 6. Ожидается ответ { 1, 2, 3 }, будет получен ответ { 3, 3 }.)
|
|
vector<int> getMinCount(vector<int> &items, int targetSum) {
vector<int> minCount(targetSum + 1, 1e9);
minCount[0] = 0;
vector<int> from(targetSum + 1);

for (int itemWeight : items) {
for (int sum = itemWeight; sum <= targetSum; sum++) {
if (minCount[sum] > minCount[sum - itemWeight] + 1) {
minCount[sum] = minCount[sum - itemWeight] + 1;
from[sum] = sum - itemWeight;
}
}
}

if (minCount[targetSum] == 1e9)
return {};

vector<int> takenItems;
for (int sum = targetSum; sum > 0; sum = from[sum])
takenItems.push_back(sum - from[sum]);
return takenItems;
}
|}

=== Сколько есть способов набрать сумму targetSum (без учёта порядка, 1 + 2 == 2 + 1) ===

==== O(items.size() * targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
long long getWays(vector<int> &items, int targetSum) {
vector<vector<long long>> ways(items.size() + 1, vector<long long>(targetSum + 1));
ways[0][0] = 1;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
ways[itemCount][sum] += ways[itemCount - 1][sum];
if (sum >= itemWeight)
ways[itemCount][sum] += ways[itemCount - 1][sum - itemWeight];
}
}

return ways[items.size()][targetSum];
}
|
|
long long getWays(vector<int> &items, int targetSum) {
vector<vector<long long>> ways(items.size() + 1, vector<long long>(targetSum + 1));
ways[0][0] = 1;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
ways[itemCount][sum] += ways[itemCount - 1][sum];
if (sum >= itemWeight)
ways[itemCount][sum] += ways[itemCount][sum - itemWeight];
}
}

return ways[items.size()][targetSum];
}
|}

==== O(targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
long long getWays(vector<int> &items, int targetSum) {
vector<long long> ways(targetSum + 1);
ways[0] = 1;

for (int itemWeight : items)
for (int sum = targetSum; sum >= itemWeight; sum--)
ways[sum] += ways[sum - itemWeight];

return ways[targetSum];
}
|
|
long long getWays(vector<int> &items, int targetSum) {
vector<long long> ways(targetSum + 1);
ways[0] = 1;

for (int itemWeight : items)
for (int sum = itemWeight; sum <= targetSum; sum++)
ways[sum] += ways[sum - itemWeight];

return ways[targetSum];
}
|}

=== Сколько есть способов набрать сумму targetSum (с учётом порядка, 1 + 2 != 2 + 1) ===

{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
(O(targetSum * items.size()) памяти.)
long long getOrderedWays(vector<int> &items, int targetSum) {
vector<vector<long long>> ways(targetSum + 1, vector<long long>(items.size() + 1));
ways[0][0] = 1;

for (int itemWeight : items)
for (int sum = targetSum; sum >= itemWeight; sum--)
for (int takenItemCount = 1; takenItemCount <= items.size(); takenItemCount++)
ways[sum][takenItemCount] += ways[sum - itemWeight][takenItemCount - 1] * takenItemCount;

long long res = 0;
for (int takenItemCount = 0; takenItemCount <= items.size(); takenItemCount++)
res += ways[targetSum][takenItemCount];
return res;
}
|
|
(O(targetSum) памяти. По сути, это другая формулировка задачи о кузнечике.)
long long getOrderedWays(vector<int> &items, int targetSum) {
vector<long long> ways(targetSum + 1);
ways[0] = 1;

for (int sum = 1; sum <= targetSum; sum++)
for (int itemWeight : items)
if (sum >= itemWeight)
ways[sum] += ways[sum - itemWeight];

return ways[targetSum];
}
|}

== Ссылки ==
* [http://algorithmica.org/tg/knapsack-gis-gcs algorithmica.org — Задача о рюкзаке, НВП и НОП]
* [https://brilliant.org/wiki/backpack-problem/ brilliant.org — Backpack Problem]

[[Категория:Динамическое программирование]]

Задача о рюкзаке и связанные задачи

2025-11-19T00:35:18Z

Ctrlalt: /* Примеры кода */

__TOC__

== Задача о сумме подмножеств (subset sum problem) ==

=== Можно ли набрать заданный вес ===
Есть несколько предметов, для каждого известен вес. Можем ли мы выбрать несколько предметов так, чтобы общий вес был в точности равен заданному числу?

vector<int> itemWeight; // веса предметов
int targetWeight; // вес, который нужно набрать

Будем заполнять таблицу canMake[][]. Строки таблицы соответствуют количеству рассмотренных предметов: нулевая строка — ноль предметов, первая строка — один предмет, ..., N-я строка — N предметов. Столбцы таблицы соответствуют весам от 0 до заданного веса. В ячейках хранятся true и false: canMake[items][weight] == true, если мы можем набрать вес weight, используя некоторые из items первых предметов.

vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

Как должна выглядеть нулевая строка таблицы? В нулевой строке мы описываем ситуацию, когда не рассмотрено ещё ни одного предмета; какие веса мы при этом можем набрать? Очевидно, только вес 0. Поэтому ячейка canMake[0][0] должна содержать true, а остальные ячейки первой строки — false.

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)

Теперь разберёмся, как должна выглядеть первая строка таблицы (она соответствует первому предмету). Пусть, для определённости, вес первого предмета — 3 (itemWeight[0] == 3). Какие веса мы теперь можем набрать?

Нам всё ещё доступен вес 0 (если мы не будем брать первый предмет), но теперь мы можем получить ещё и вес 3 (если мы возьмём первый предмет).

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)
строка canMake[1] 1 0 0 1 0 0 0 0 0 0 0
(вес предмета — 3)

Далее — вторая строка таблицы (она соответствует первым двум предметам). Пусть вес второго предмета — 5 (itemWeight[1] == 5). Какие веса мы теперь можем набрать?

Нам всё ещё доступны веса 0 и 3 (если мы не будем брать второй предмет), но теперь мы можем получить ещё веса 5 (если мы до этого не брали ничего, а теперь возьмём второй предмет) и 8 (если мы до этого взяли первый предмет и получили вес 3, а сейчас добавим второй предмет).

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)
строка canMake[1] 1 0 0 1 0 0 0 0 0 0 0
(вес предмета — 3)
строка canMake[2] 1 0 0 1 0 1 0 0 1 0 0
(вес предмета — 5)

Далее — третья строка таблицы (она соответствует первым трём предметам). Пусть вес третьего предмета — 2 (itemWeight[2] == 2).

Раньше (без третьего предмета) мы могли набрать веса 0, 3, 5 и 8. Теперь (с третьим предметом) можем дополнительно набрать 2, 5, 7 и 10. Обратите внимание, что вес 5 мы могли набрать как без третьего предмета (просто взяв второй предмет с весом 5), так и с ним (взяв первый и третий предметы с весами 3 и 2); ничего необычного в этой ситуации нет.

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)
строка canMake[1] 1 0 0 1 0 0 0 0 0 0 0
(вес предмета — 3)
строка canMake[2] 1 0 0 1 0 1 0 0 1 0 0
(вес предмета — 5)
строка canMake[3] 1 0 1 1 0 1 0 1 1 0 1
(вес предмета — 2)

Сделаем общие выводы о том, как заполняются строки таблицы. Когда будет true в ячейке canMake[items][weight], то есть когда мы можем набрать вес weight первыми items предметами?

* Во-первых, если мы могли набрать вес weight только предыдущими предметами, не используя новый. То есть, если в предыдущей строке на позиции weight было true (canMake[items - 1][weight] == true).
* Во-вторых, если мы могли набрать вес (weight - currentItemWeight) предыдущими предметами (currentItemWeight — вес текущего предмета). В этом случае, если мы добавим текущий предмет, то мы получим как раз вес weight. То есть, если в предыдущей строке на позиции (weight - currentItemWeight) было true (canMake[items - 1][weight - currentItemWeight] == true).

Теперь мы готовы написать код заполнения таблицы:

bool solve(const vector<int> &itemWeight, int targetWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight])
canMake[items][weight] = true;
}
}

return canMake[items.size()][targetWeight];
}

Ответ на задачу в итоге будет записан в последнюю ячейку последней строки (canMake[itemWeight.size()][targetWeight]).

Временная сложность решения — Θ(NM) (N — количество предметов, M — целевой вес). Для таблицы требуется Θ(NM) памяти.

=== Можно ли набрать заданный вес, каждый предмет можно брать несколько раз ===

Посмотрим, как изменится заполнение таблицы:

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)
строка canMake[1] 1 0 0 1 0 0 1 0 0 1 0
(вес предмета — 3)
строка canMake[2] 1 0 0 1 0 1 1 0 1 1 1
(вес предмета — 5)
строка canMake[3] 1 0 1 1 1 1 1 1 1 1 1
(вес предмета — 2)

canMake[items][weight] == true, если canMake[items - 1][weight] == true или canMake[items][weight - currentItemWeight] == true.

bool solve(const vector<int> &itemWeight, int targetWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[{{Changed|items}}][weight - currentItemWeight])
canMake[items][weight] = true;
}
}

return canMake[items.size()][targetWeight];
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(NM) памяти.

Заметим, что в данном случае мы можем не делать двумерную таблицу. Нам будет достаточно одной строки canMake[].

bool solve(const vector<int> &itemWeight, int targetWeight) {
vector<bool> canMake(targetWeight + 1);

canMake[0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = currentItemWeight; weight <= targetWeight; weight++) {
if (canMake[weight - currentItemWeight])
canMake[weight] = true;
}
}

return canMake[targetWeight];
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(M) памяти.

=== Можно ли набрать заданный вес, Θ(M) памяти ===

Как и в предыдущем случае, мы можем не делать двумерную таблицу. Нам будет достаточно одной строки canMake[].

Здесь, однако, нужно обратить внимание на то, что если мы будем обновлять строку слева направо, то мы будем учитывать один и тот же предмет несколько раз (как в предыдущем случае). То есть, например, если первый предмет имеет вес 3, то мы запишем true в ячейку 3 (так как в ячейке 0 записано true), затем в ячейку 6 (так как в ячейке 3 записано true), затем в ячейку 9 (так как в ячейке 6 записано true)...

Чтобы избежать такой ситуации, следует обновлять строку не слева направо, а справа налево. Тогда в ячейках слева от текущей никогда не будет изменений, связанных с текущим предметом.

bool solve(const vector<int> &itemWeight, int targetWeight) {
vector<bool> canMake(targetWeight + 1);

canMake[0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for ({{Changed|1=int weight = targetWeight; weight >= currentItemWeight; weight--}}) {
if (canMake[weight - currentItemWeight])
canMake[weight] = true;
}
}

return canMake[targetWeight];
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(M) памяти.

=== Можно ли набрать заданный вес, мало предметов, очень большие веса (⋆) ===
Мы уже не сможем решить такую задачу при помощи динамического программирования, так как при очень большом targetWeight потребуется очень большая таблица, которая не уместится в память (не говоря уже о времени её заполнения).

Если у нас < 25 предметов, можно просто перебрать все их подмножества (рекурсивно или масками, временная сложность O(2^N)).

Если у нас < 50 предметов, кроме перебора понадобится техника meet in the middle. Разделим предметы на две половины. Для каждой половины сделаем set из всех весов, которые можно составить из предметов в этой половине. Дальше нам нужно найти в двух setах два элемента, в сумме дающие targetWeight.

unordered_set<long long> getTotalWeights(const vector<long long> &itemWeight) {
unordered_set<long long> totalWeights;

for (int mask = 0; mask < (1 << itemWeight.size()); mask++) {
long long totalWeight = 0;

for (int bit = 0; bit < itemWeight.size(); bit++) {
if (mask & (1 << bit))
totalWeight += itemWeight[bit];
}

totalWeights.push_back(totalWeight);
}

return totalMasses;
}

bool solve(const vector<long long> &itemWeight, long long targetWeight) {
auto mid = itemWeight.begin() + itemWeight.size() / 2;
unordered_set<long long> aWeights = getTotalWeights({itemWeight.begin(), mid});
unordered_set<long long> bWeights = getTotalWeights({mid, itemWeight.end()});

for (long long aWeight : aWeights) {
if (bWeights.count(targetWeight - aWeight))
return true;
}

return false;
}

Временная сложность решения Θ(2^(N/2)). Для множеств требуется O(2^(N/2)) памяти.

=== Номера предметов, дающих заданный вес ===

Иногда в задаче требуется не только определить, можем ли мы набрать заданный вес, но и вывести сертификат — номера (индексы) предметов, которые мы должны взять.

Вдобавок к таблице canMake[][] сделаем таблицу take[][], в которой будем отмечать, брали ли мы последний предмет. take[items][weight] == true, если, когда мы рассматривали items предметов, мы смогли набрать вес weight, взяв последний предмет (его индекс — (items - 1)).

Заполнение таблицы take[][] происходит одновременно с заполнением таблицы canMake[][]. Всякий раз, когда мы смогли набрать вес при помощи нового предмета, мы ставим true не только в canMake[][], но и в take[][].

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight]) {
canMake[items][weight] = true;
take[items][weight] = true;
}

Когда у нас есть заполненная таблица take[][], мы можем по ней восстановить номера использованных предметов. Обозначим за weight вес предметов, которые нам нужно взять (изначально weight == targetWeight).

Как понять, взяли ли мы самый последний предмет? Если take[items][weight] == true, то мы его брали, иначе — не брали. Если мы взяли последний предмет, то weight нужно уменьшить на itemWeight[items - 1].

Как понять, взяли ли мы предпоследний предмет? Если take[items - 1][weight] == true, то мы его брали, иначе — не брали. Если мы взяли предпоследний предмет, то weight нужно уменьшить на itemWeight[items - 2].

И так далее, от конца к началу мы определяем, брали или нет мы каждый из предметов, попутно уменьшая weight.

{{Changed|vector<int>}} solve(const vector<int> &itemWeight, int targetWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));
{{Changed|vector<vector<bool>> take(itemWeight.size() + 1, vector<int>(targetWeight + 1));}}

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight]) {
canMake[items][weight] = true;
{{Changed|1=take[items][weight] = true;}}
}
}
}

{{Changed|1=if (!canMake[itemWeight.size()][targetItem])}}
{{Changed|1=return {};}}

{{Changed|1=vector<int> takenItemIndexes;}}
{{Changed|1=for (int items = itemWeight.size(), weight = targetWeight; items > 0; items--) {}}
{{Changed|1=if (take[items][weight]) {}}
{{Changed|1=takenItemIndexes.push_back(items - 1);}}
{{Changed|1=weight -= itemWeight[items - 1];}}
{{Changed|1=} }}
{{Changed|1=} }}
{{Changed|1=return takenItemIndexes;}}
}

Временная сложность решения Θ(NM). Для таблиц требуется Θ(NM) памяти.

=== Номера предметов, дающих заданный вес, Θ(M) памяти (⋆) ===

* [https://stackoverflow.com/questions/51941993/0-1-knapsack-find-solution-set-in-space-optimised-implementation stackoverflow.com/questions/51941993/0-1-knapsack-find-solution-set-in-space-optimised-implementation]
* [https://www.cs.colostate.edu/~cs575dl/Sp2015/Lectures/Knapsack.pdf www.cs.colostate.edu/~cs575dl/Sp2015/Lectures/Knapsack.pdf]

vector<bool> getCanMake(const vector<int> &itemWeight, int targetWeight, int l, int r) {
vector<bool> canMake(targetWeight + 1);

canMake[0] = true;

for (int itemIndex = l; itemIndex <= r; itemIndex++) {
int currentItemWeight = itemWeight[itemIndex];

for (int weight = currentItemWeight; weight <= targetWeight; weight++) {
if (canMake[weight - currentItemWeight])
canMake[weight] = true;
}
}

return canMake;
}

vector<int> solve(const vector<int> &itemWeight, int targetWeight, int l, int r) {
if (l == r)
return targetWeight == itemWeight[l] ? { l } : {};

int m = l + (r - l) / 2;
vector<bool> aCan = getCanMake(itemWeight, targetWeight, l, m);
vector<bool> bCan = getCanMake(itemWeight, targetWeight, m + 1, r);

int aWeight = 0, bWeight = targetWeight;
while (!aCan[aWeight] || !bCan[bWeight]) {
aWeight++;
bWeight--;
}

vector<int> aItemIndexes = solve(itemWeight, aWeight, l, m);
vector<int> bItemIndexes = solve(itemWeight, bWeight, m + 1, r);
aItemIndexes.insert(aItemIndexes.end(), bIntemIndexes.begin(), bItemIndexes.end());
return aItemIndexes;
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(M) памяти.

== Вариации на тему задачи о сумме подмножеств ==

=== Какой максимальный вес не больше заданного можно набрать ===

Решаем задачу о сумме подмножеств, ищем самое правое true в последней строке таблицы.

{{Changed|int}} solve(const vector<int> &itemWeight, int targetWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight])
canMake[items][weight] = true;
}
}

{{Changed|1=while (!canMake[items.size()][targetWeight])}}
{{Changed|1=targetWeight--;}}
{{Changed|1=return targetWeight;}}
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(NM) или Θ(M) памяти.

=== Можно ли разделить предметы на два набора одинакового веса ===

Решаем задачу о сумме подмножеств для targetWeight == (сумма весов предметов) / 2.

bool solve(const vector<int> &itemWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

{{Changed|1=int targetWeight = 0;}}
{{Changed|1=for (int weight : itemWeight)}}
{{Changed|1=targetWeight += weight;}}
{{Changed|1=targetWeight /= 2;}}

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight])
canMake[items][weight] = true;
}
}

return canMake[items.size()][targetWeight];
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(NM) или Θ(M) памяти.

== Примеры кода ==

=== Можно ли набрать сумму targetSum ===

==== O(items.size() * targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
bool canMakeSum(vector<int> &items, int targetSum) {
vector<vector<bool>> canMake(items.size() + 1, vector<bool>(targetSum + 1));
canMake[0][0] = true;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++)
if (canMake[itemCount - 1][sum] ||
sum >= itemWeight && canMake[itemCount - 1][sum - itemWeight])
canMake[itemCount][sum] = true;
}

return canMake[items.size()][targetSum];
}
|
|
bool canMakeSum(vector<int> &items, int targetSum) {
vector<vector<bool>> canMake(items.size() + 1, vector<bool>(targetSum + 1));
canMake[0][0] = true;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++)
if (canMake[itemCount - 1][sum] ||
sum >= itemWeight && canMake[itemCount][sum - itemWeight])
canMake[itemCount][sum] = true;
}

return canMake[items.size()][targetSum];
}
|}

==== O(items.size() * targetSum) памяти, вернуть сертификат (список предметов) ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
vector<int> canMakeSum(vector<int> &items, int targetSum) {
vector<vector<bool>> canMake(items.size() + 1, vector<bool>(targetSum + 1));
canMake[0][0] = true;
vector<vector<pair<int, int>>> from(items.size() + 1, vector<pair<int, int>>(targetSum + 1));

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (canMake[itemCount - 1][sum]) {
canMake[itemCount][sum] = true;
from[itemCount][sum] = { itemCount - 1, sum };
} else if (sum >= itemWeight && canMake[itemCount - 1][sum - itemWeight]) {
canMake[itemCount][sum] = true;
from[itemCount][sum] = { itemCount - 1, sum - itemWeight };
}
}
}

if (!canMake[items.size()][targetSum])
return {};

vector<int> takenItems;
for (int itemCount = items.size(), sum = targetSum; itemCount > 0; ) {
auto &[prevItemCount, prevSum] = from[itemCount][sum];
if (prevSum != sum)
takenItems.push_back(sum - prevSum);
itemCount = prevItemCount;
sum = prevSum;
}
return takenItems;
}
|
|
vector<int> canMakeSum(vector<int> &items, int targetSum) {
vector<vector<bool>> canMake(items.size() + 1, vector<bool>(targetSum + 1));
canMake[0][0] = true;
vector<vector<pair<int, int>>> from(items.size() + 1, vector<pair<int, int>>(targetSum + 1));

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (canMake[itemCount - 1][sum]) {
canMake[itemCount][sum] = true;
from[itemCount][sum] = { itemCount - 1, sum };
} else if (sum >= itemWeight && canMake[itemCount][sum - itemWeight]) {
canMake[itemCount][sum] = true;
from[itemCount][sum] = { itemCount, sum - itemWeight };
}
}
}

if (!canMake[items.size()][targetSum])
return {};

vector<int> takenItems;
for (int itemCount = items.size(), sum = targetSum; itemCount > 0; ) {
auto &[prevItemCount, prevSum] = from[itemCount][sum];
if (prevSum != sum)
takenItems.push_back(sum - prevSum);
itemCount = prevItemCount;
sum = prevSum;
}
return takenItems;
}
|}

==== O(targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
bool canMakeSum(vector<int> &items, int targetSum) {
vector<bool> canMake(targetSum + 1);
canMake[0] = true;

for (int itemWeight : items)
for (int sum = targetSum; sum >= itemWeight; sum--)
if (canMake[sum - itemWeight])
canMake[sum] = true;

return canMake[targetSum];
}
|
|
bool canMakeSum(vector<int> &items, int targetSum) {
vector<bool> canMake(targetSum + 1);
canMake[0] = true;

for (int itemWeight : items)
for (int sum = itemWeight; sum <= targetSum; sum++)
if (canMake[sum - itemWeight])
canMake[sum] = true;

return canMake[targetSum];
}
|}

==== O(targetSum) памяти, вернуть сертификат (список предметов) ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
vector<int> canMakeSum(vector<int> &items, int targetSum) {
vector<bool> canMake(targetSum + 1);
canMake[0] = true;
vector<int> from(targetSum + 1);

for (int itemWeight : items) {
for (int sum = targetSum; sum >= itemWeight; sum--) {
if (!canMake[sum] && canMake[sum - itemWeight]) {
canMake[sum] = true;
from[sum] = sum - itemWeight;
}
}
}

if (!canMake[targetSum])
return {};

vector<int> takenItems;
for (int sum = targetSum; sum > 0; sum = from[sum])
takenItems.push_back(sum - from[sum]);
return takenItems;
}
|
|
vector<int> canMakeSum(vector<int> &items, int targetSum) {
vector<bool> canMake(targetSum + 1);
canMake[0] = true;
vector<int> from(targetSum + 1);

for (int itemWeight : items) {
for (int sum = itemWeight; sum <= targetSum; sum++) {
if (!canMake[sum] && canMake[sum - itemWeight]) {
canMake[sum] = true;
from[sum] = sum - itemWeight;
}
}
}

if (!canMake[targetSum])
return {};

vector<int> takenItems;
for (int sum = targetSum; sum > 0; sum = from[sum])
takenItems.push_back(sum - from[sum]);
return takenItems;
}
|}

=== Каким минимальным количеством предметом можно набрать сумму targetSum ===

==== O(items.size() * targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
int getMinCount(vector<int> &items, int targetSum) {
vector<vector<int>> minCount(items.size() + 1, vector<int>(targetSum + 1, 1e9));
minCount[0][0] = 0;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (minCount[itemCount][sum] > minCount[itemCount - 1][sum])
minCount[itemCount][sum] = minCount[itemCount - 1][sum];
if (sum >= itemWeight && minCount[itemCount][sum] > minCount[itemCount - 1][sum - itemWeight] + 1)
minCount[itemCount][sum] = minCount[itemCount - 1][sum - itemWeight] + 1;
}
}

return minCount[items.size()][targetSum];
}
|
|
int getMinCount(vector<int> &items, int targetSum) {
vector<vector<int>> minCount(items.size() + 1, vector<int>(targetSum + 1, 1e9));
minCount[0][0] = 0;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (minCount[itemCount][sum] > minCount[itemCount - 1][sum])
minCount[itemCount][sum] = minCount[itemCount - 1][sum];
if (sum >= itemWeight && minCount[itemCount][sum] > minCount[itemCount][sum - itemWeight] + 1)
minCount[itemCount][sum] = minCount[itemCount][sum - itemWeight] + 1;
}
}

return minCount[items.size()][targetSum];
}
|}

==== O(items.size() * targetSum) памяти, вернуть сертификат (список предметов) ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
vector<int> getMinCount(vector<int> &items, int targetSum) {
vector<vector<int>> minCount(items.size() + 1, vector<int>(targetSum + 1, 1e9));
minCount[0][0] = 0;
vector<vector<pair<int, int>>> from(items.size() + 1, vector<pair<int, int>>(targetSum + 1));

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (minCount[itemCount][sum] > minCount[itemCount - 1][sum]) {
minCount[itemCount][sum] = minCount[itemCount - 1][sum];
from[itemCount][sum] = { itemCount - 1, sum };
}
if (sum >= itemWeight && minCount[itemCount][sum] > minCount[itemCount - 1][sum - itemWeight] + 1) {
minCount[itemCount][sum] = minCount[itemCount - 1][sum - itemWeight] + 1;
from[itemCount][sum] = { itemCount - 1, sum - itemWeight };
}
}
}

if (minCount[items.size()][targetSum] == 1e9)
return {};

vector<int> takenItems;
for (int itemCount = items.size(), sum = targetSum; itemCount > 0; ) {
auto &[prevItemCount, prevSum] = from[itemCount][sum];
if (prevSum != sum)
takenItems.push_back(sum - prevSum);
itemCount = prevItemCount;
sum = prevSum;
}
return takenItems;
}
|
|
vector<int> getMinCount(vector<int> &items, int targetSum) {
vector<vector<int>> minCount(items.size() + 1, vector<int>(targetSum + 1, 1e9));
minCount[0][0] = 0;
vector<vector<pair<int, int>>> from(items.size() + 1, vector<pair<int, int>>(targetSum + 1));

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (minCount[itemCount][sum] > minCount[itemCount - 1][sum]) {
minCount[itemCount][sum] = minCount[itemCount - 1][sum];
from[itemCount][sum] = { itemCount - 1, sum };
}
if (sum >= itemWeight && minCount[itemCount][sum] > minCount[itemCount][sum - itemWeight] + 1) {
minCount[itemCount][sum] = minCount[itemCount][sum - itemWeight] + 1;
from[itemCount][sum] = { itemCount, sum - itemWeight };
}
}
}

if (minCount[items.size()][targetSum] == 1e9)
return {};

vector<int> takenItems;
for (int itemCount = items.size(), sum = targetSum; itemCount > 0; ) {
auto &[prevItemCount, prevSum] = from[itemCount][sum];
if (prevSum != sum)
takenItems.push_back(sum - prevSum);
itemCount = prevItemCount;
sum = prevSum;
}
return takenItems;
}
|}

==== O(targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
int getMinCount(vector<int> &items, int targetSum) {
vector<int> minCount(targetSum + 1, 1e9);
minCount[0] = 0;

for (int itemWeight : items)
for (int sum = targetSum; sum >= itemWeight; sum--)
if (minCount[sum] > minCount[sum - itemWeight] + 1)
minCount[sum] = minCount[sum - itemWeight] + 1;

return minCount[targetSum];
}
|
|
int getMinCount(vector<int> &items, int targetSum) {
vector<int> minCount(targetSum + 1, 1e9);
minCount[0] = 0;

for (int itemWeight : items)
for (int sum = itemWeight; sum <= targetSum; sum++)
if (minCount[sum] > minCount[sum - itemWeight] + 1)
minCount[sum] = minCount[sum - itemWeight] + 1;

return minCount[targetSum];
}
|}

==== O(targetSum) памяти, вернуть сертификат (список предметов) ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
(Невозможно. Контртест: items = { 1, 2, 3 }, targetSum = 6. Ожидается ответ { 1, 2, 3 }, будет получен ответ { 3, 3 }.)
|
|
vector<int> getMinCount(vector<int> &items, int targetSum) {
vector<int> minCount(targetSum + 1, 1e9);
minCount[0] = 0;
vector<int> from(targetSum + 1);

for (int itemWeight : items) {
for (int sum = itemWeight; sum <= targetSum; sum++) {
if (minCount[sum] > minCount[sum - itemWeight] + 1) {
minCount[sum] = minCount[sum - itemWeight] + 1;
from[sum] = sum - itemWeight;
}
}
}

if (minCount[targetSum] == 1e9)
return {};

vector<int> takenItems;
for (int sum = targetSum; sum > 0; sum = from[sum])
takenItems.push_back(sum - from[sum]);
return takenItems;
}
|}

=== Сколько есть способов набрать сумму targetSum (без учёта порядка, 1 + 2 == 2 + 1) ===

==== O(items.size() * targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
long long getWays(vector<int> &items, int targetSum) {
vector<vector<long long>> ways(items.size() + 1, vector<long long>(targetSum + 1));
ways[0][0] = 1;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
ways[itemCount][sum] += ways[itemCount - 1][sum];
if (sum >= itemWeight)
ways[itemCount][sum] += ways[itemCount - 1][sum - itemWeight];
}
}

return ways[items.size()][targetSum];
}
|
|
long long getWays(vector<int> &items, int targetSum) {
vector<vector<long long>> ways(items.size() + 1, vector<long long>(targetSum + 1));
ways[0][0] = 1;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
ways[itemCount][sum] += ways[itemCount - 1][sum];
if (sum >= itemWeight)
ways[itemCount][sum] += ways[itemCount][sum - itemWeight];
}
}

return ways[items.size()][targetSum];
}
|}

==== O(targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
long long getWays(vector<int> &items, int targetSum) {
vector<long long> ways(targetSum + 1);
ways[0] = 1;

for (int itemWeight : items)
for (int sum = targetSum; sum >= itemWeight; sum--)
ways[sum] += ways[sum - itemWeight];

return ways[targetSum];
}
|
|
long long getWays(vector<int> &items, int targetSum) {
vector<long long> ways(targetSum + 1);
ways[0] = 1;

for (int itemWeight : items)
for (int sum = itemWeight; sum <= targetSum; sum++)
ways[sum] += ways[sum - itemWeight];

return ways[targetSum];
}
|}

=== Сколько есть способов набрать сумму targetSum (с учётом порядка, 1 + 2 != 2 + 1) ===

{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
(O(targetSum * items.size()) памяти.)
long long getOrderedWays(vector<int> &items, int targetSum) {
vector<vector<long long>> ways(targetSum + 1, vector<long long>(items.size() + 1));
ways[0][0] = 1;

for (int itemWeight : items)
for (int sum = targetSum; sum >= itemWeight; sum--)
for (int takenItemCount = 1; takenItemCount <= items.size(); takenItemCount++)
ways[sum][takenItemCount] += ways[sum - itemWeight][takenItemCount - 1] * takenItemCount;

long long res = 0;
for (int takenItemCount = 0; takenItemCount <= items.size(); takenItemCount++)
res += ways[targetSum][takenItemCount];
return res;
}
|
|
(O(targetSum) памяти. По сути, это другая формулировка задачи о кузнечике.)
long long getOrderedWays(vector<int> &items, int targetSum) {
vector<long long> ways(targetSum + 1);
ways[0] = 1;

for (int sum = 1; sum <= targetSum; sum++)
for (int itemWeight : items)
if (sum >= itemWeight)
ways[sum] += ways[sum - itemWeight];

return ways[targetSum];
}
|}

== Ссылки ==
* [http://algorithmica.org/tg/knapsack-gis-gcs algorithmica.org — Задача о рюкзаке, НВП и НОП]
* [https://brilliant.org/wiki/backpack-problem/ brilliant.org — Backpack Problem]

[[Категория:Динамическое программирование]]

Задача о рюкзаке и связанные задачи

2025-11-19T00:03:05Z

Ctrlalt: /* Примеры кода */

__TOC__

== Задача о сумме подмножеств (subset sum problem) ==

=== Можно ли набрать заданный вес ===
Есть несколько предметов, для каждого известен вес. Можем ли мы выбрать несколько предметов так, чтобы общий вес был в точности равен заданному числу?

vector<int> itemWeight; // веса предметов
int targetWeight; // вес, который нужно набрать

Будем заполнять таблицу canMake[][]. Строки таблицы соответствуют количеству рассмотренных предметов: нулевая строка — ноль предметов, первая строка — один предмет, ..., N-я строка — N предметов. Столбцы таблицы соответствуют весам от 0 до заданного веса. В ячейках хранятся true и false: canMake[items][weight] == true, если мы можем набрать вес weight, используя некоторые из items первых предметов.

vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

Как должна выглядеть нулевая строка таблицы? В нулевой строке мы описываем ситуацию, когда не рассмотрено ещё ни одного предмета; какие веса мы при этом можем набрать? Очевидно, только вес 0. Поэтому ячейка canMake[0][0] должна содержать true, а остальные ячейки первой строки — false.

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)

Теперь разберёмся, как должна выглядеть первая строка таблицы (она соответствует первому предмету). Пусть, для определённости, вес первого предмета — 3 (itemWeight[0] == 3). Какие веса мы теперь можем набрать?

Нам всё ещё доступен вес 0 (если мы не будем брать первый предмет), но теперь мы можем получить ещё и вес 3 (если мы возьмём первый предмет).

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)
строка canMake[1] 1 0 0 1 0 0 0 0 0 0 0
(вес предмета — 3)

Далее — вторая строка таблицы (она соответствует первым двум предметам). Пусть вес второго предмета — 5 (itemWeight[1] == 5). Какие веса мы теперь можем набрать?

Нам всё ещё доступны веса 0 и 3 (если мы не будем брать второй предмет), но теперь мы можем получить ещё веса 5 (если мы до этого не брали ничего, а теперь возьмём второй предмет) и 8 (если мы до этого взяли первый предмет и получили вес 3, а сейчас добавим второй предмет).

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)
строка canMake[1] 1 0 0 1 0 0 0 0 0 0 0
(вес предмета — 3)
строка canMake[2] 1 0 0 1 0 1 0 0 1 0 0
(вес предмета — 5)

Далее — третья строка таблицы (она соответствует первым трём предметам). Пусть вес третьего предмета — 2 (itemWeight[2] == 2).

Раньше (без третьего предмета) мы могли набрать веса 0, 3, 5 и 8. Теперь (с третьим предметом) можем дополнительно набрать 2, 5, 7 и 10. Обратите внимание, что вес 5 мы могли набрать как без третьего предмета (просто взяв второй предмет с весом 5), так и с ним (взяв первый и третий предметы с весами 3 и 2); ничего необычного в этой ситуации нет.

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)
строка canMake[1] 1 0 0 1 0 0 0 0 0 0 0
(вес предмета — 3)
строка canMake[2] 1 0 0 1 0 1 0 0 1 0 0
(вес предмета — 5)
строка canMake[3] 1 0 1 1 0 1 0 1 1 0 1
(вес предмета — 2)

Сделаем общие выводы о том, как заполняются строки таблицы. Когда будет true в ячейке canMake[items][weight], то есть когда мы можем набрать вес weight первыми items предметами?

* Во-первых, если мы могли набрать вес weight только предыдущими предметами, не используя новый. То есть, если в предыдущей строке на позиции weight было true (canMake[items - 1][weight] == true).
* Во-вторых, если мы могли набрать вес (weight - currentItemWeight) предыдущими предметами (currentItemWeight — вес текущего предмета). В этом случае, если мы добавим текущий предмет, то мы получим как раз вес weight. То есть, если в предыдущей строке на позиции (weight - currentItemWeight) было true (canMake[items - 1][weight - currentItemWeight] == true).

Теперь мы готовы написать код заполнения таблицы:

bool solve(const vector<int> &itemWeight, int targetWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight])
canMake[items][weight] = true;
}
}

return canMake[items.size()][targetWeight];
}

Ответ на задачу в итоге будет записан в последнюю ячейку последней строки (canMake[itemWeight.size()][targetWeight]).

Временная сложность решения — Θ(NM) (N — количество предметов, M — целевой вес). Для таблицы требуется Θ(NM) памяти.

=== Можно ли набрать заданный вес, каждый предмет можно брать несколько раз ===

Посмотрим, как изменится заполнение таблицы:

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)
строка canMake[1] 1 0 0 1 0 0 1 0 0 1 0
(вес предмета — 3)
строка canMake[2] 1 0 0 1 0 1 1 0 1 1 1
(вес предмета — 5)
строка canMake[3] 1 0 1 1 1 1 1 1 1 1 1
(вес предмета — 2)

canMake[items][weight] == true, если canMake[items - 1][weight] == true или canMake[items][weight - currentItemWeight] == true.

bool solve(const vector<int> &itemWeight, int targetWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[{{Changed|items}}][weight - currentItemWeight])
canMake[items][weight] = true;
}
}

return canMake[items.size()][targetWeight];
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(NM) памяти.

Заметим, что в данном случае мы можем не делать двумерную таблицу. Нам будет достаточно одной строки canMake[].

bool solve(const vector<int> &itemWeight, int targetWeight) {
vector<bool> canMake(targetWeight + 1);

canMake[0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = currentItemWeight; weight <= targetWeight; weight++) {
if (canMake[weight - currentItemWeight])
canMake[weight] = true;
}
}

return canMake[targetWeight];
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(M) памяти.

=== Можно ли набрать заданный вес, Θ(M) памяти ===

Как и в предыдущем случае, мы можем не делать двумерную таблицу. Нам будет достаточно одной строки canMake[].

Здесь, однако, нужно обратить внимание на то, что если мы будем обновлять строку слева направо, то мы будем учитывать один и тот же предмет несколько раз (как в предыдущем случае). То есть, например, если первый предмет имеет вес 3, то мы запишем true в ячейку 3 (так как в ячейке 0 записано true), затем в ячейку 6 (так как в ячейке 3 записано true), затем в ячейку 9 (так как в ячейке 6 записано true)...

Чтобы избежать такой ситуации, следует обновлять строку не слева направо, а справа налево. Тогда в ячейках слева от текущей никогда не будет изменений, связанных с текущим предметом.

bool solve(const vector<int> &itemWeight, int targetWeight) {
vector<bool> canMake(targetWeight + 1);

canMake[0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for ({{Changed|1=int weight = targetWeight; weight >= currentItemWeight; weight--}}) {
if (canMake[weight - currentItemWeight])
canMake[weight] = true;
}
}

return canMake[targetWeight];
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(M) памяти.

=== Можно ли набрать заданный вес, мало предметов, очень большие веса (⋆) ===
Мы уже не сможем решить такую задачу при помощи динамического программирования, так как при очень большом targetWeight потребуется очень большая таблица, которая не уместится в память (не говоря уже о времени её заполнения).

Если у нас < 25 предметов, можно просто перебрать все их подмножества (рекурсивно или масками, временная сложность O(2^N)).

Если у нас < 50 предметов, кроме перебора понадобится техника meet in the middle. Разделим предметы на две половины. Для каждой половины сделаем set из всех весов, которые можно составить из предметов в этой половине. Дальше нам нужно найти в двух setах два элемента, в сумме дающие targetWeight.

unordered_set<long long> getTotalWeights(const vector<long long> &itemWeight) {
unordered_set<long long> totalWeights;

for (int mask = 0; mask < (1 << itemWeight.size()); mask++) {
long long totalWeight = 0;

for (int bit = 0; bit < itemWeight.size(); bit++) {
if (mask & (1 << bit))
totalWeight += itemWeight[bit];
}

totalWeights.push_back(totalWeight);
}

return totalMasses;
}

bool solve(const vector<long long> &itemWeight, long long targetWeight) {
auto mid = itemWeight.begin() + itemWeight.size() / 2;
unordered_set<long long> aWeights = getTotalWeights({itemWeight.begin(), mid});
unordered_set<long long> bWeights = getTotalWeights({mid, itemWeight.end()});

for (long long aWeight : aWeights) {
if (bWeights.count(targetWeight - aWeight))
return true;
}

return false;
}

Временная сложность решения Θ(2^(N/2)). Для множеств требуется O(2^(N/2)) памяти.

=== Номера предметов, дающих заданный вес ===

Иногда в задаче требуется не только определить, можем ли мы набрать заданный вес, но и вывести сертификат — номера (индексы) предметов, которые мы должны взять.

Вдобавок к таблице canMake[][] сделаем таблицу take[][], в которой будем отмечать, брали ли мы последний предмет. take[items][weight] == true, если, когда мы рассматривали items предметов, мы смогли набрать вес weight, взяв последний предмет (его индекс — (items - 1)).

Заполнение таблицы take[][] происходит одновременно с заполнением таблицы canMake[][]. Всякий раз, когда мы смогли набрать вес при помощи нового предмета, мы ставим true не только в canMake[][], но и в take[][].

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight]) {
canMake[items][weight] = true;
take[items][weight] = true;
}

Когда у нас есть заполненная таблица take[][], мы можем по ней восстановить номера использованных предметов. Обозначим за weight вес предметов, которые нам нужно взять (изначально weight == targetWeight).

Как понять, взяли ли мы самый последний предмет? Если take[items][weight] == true, то мы его брали, иначе — не брали. Если мы взяли последний предмет, то weight нужно уменьшить на itemWeight[items - 1].

Как понять, взяли ли мы предпоследний предмет? Если take[items - 1][weight] == true, то мы его брали, иначе — не брали. Если мы взяли предпоследний предмет, то weight нужно уменьшить на itemWeight[items - 2].

И так далее, от конца к началу мы определяем, брали или нет мы каждый из предметов, попутно уменьшая weight.

{{Changed|vector<int>}} solve(const vector<int> &itemWeight, int targetWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));
{{Changed|vector<vector<bool>> take(itemWeight.size() + 1, vector<int>(targetWeight + 1));}}

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight]) {
canMake[items][weight] = true;
{{Changed|1=take[items][weight] = true;}}
}
}
}

{{Changed|1=if (!canMake[itemWeight.size()][targetItem])}}
{{Changed|1=return {};}}

{{Changed|1=vector<int> takenItemIndexes;}}
{{Changed|1=for (int items = itemWeight.size(), weight = targetWeight; items > 0; items--) {}}
{{Changed|1=if (take[items][weight]) {}}
{{Changed|1=takenItemIndexes.push_back(items - 1);}}
{{Changed|1=weight -= itemWeight[items - 1];}}
{{Changed|1=} }}
{{Changed|1=} }}
{{Changed|1=return takenItemIndexes;}}
}

Временная сложность решения Θ(NM). Для таблиц требуется Θ(NM) памяти.

=== Номера предметов, дающих заданный вес, Θ(M) памяти (⋆) ===

* [https://stackoverflow.com/questions/51941993/0-1-knapsack-find-solution-set-in-space-optimised-implementation stackoverflow.com/questions/51941993/0-1-knapsack-find-solution-set-in-space-optimised-implementation]
* [https://www.cs.colostate.edu/~cs575dl/Sp2015/Lectures/Knapsack.pdf www.cs.colostate.edu/~cs575dl/Sp2015/Lectures/Knapsack.pdf]

vector<bool> getCanMake(const vector<int> &itemWeight, int targetWeight, int l, int r) {
vector<bool> canMake(targetWeight + 1);

canMake[0] = true;

for (int itemIndex = l; itemIndex <= r; itemIndex++) {
int currentItemWeight = itemWeight[itemIndex];

for (int weight = currentItemWeight; weight <= targetWeight; weight++) {
if (canMake[weight - currentItemWeight])
canMake[weight] = true;
}
}

return canMake;
}

vector<int> solve(const vector<int> &itemWeight, int targetWeight, int l, int r) {
if (l == r)
return targetWeight == itemWeight[l] ? { l } : {};

int m = l + (r - l) / 2;
vector<bool> aCan = getCanMake(itemWeight, targetWeight, l, m);
vector<bool> bCan = getCanMake(itemWeight, targetWeight, m + 1, r);

int aWeight = 0, bWeight = targetWeight;
while (!aCan[aWeight] || !bCan[bWeight]) {
aWeight++;
bWeight--;
}

vector<int> aItemIndexes = solve(itemWeight, aWeight, l, m);
vector<int> bItemIndexes = solve(itemWeight, bWeight, m + 1, r);
aItemIndexes.insert(aItemIndexes.end(), bIntemIndexes.begin(), bItemIndexes.end());
return aItemIndexes;
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(M) памяти.

== Вариации на тему задачи о сумме подмножеств ==

=== Какой максимальный вес не больше заданного можно набрать ===

Решаем задачу о сумме подмножеств, ищем самое правое true в последней строке таблицы.

{{Changed|int}} solve(const vector<int> &itemWeight, int targetWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight])
canMake[items][weight] = true;
}
}

{{Changed|1=while (!canMake[items.size()][targetWeight])}}
{{Changed|1=targetWeight--;}}
{{Changed|1=return targetWeight;}}
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(NM) или Θ(M) памяти.

=== Можно ли разделить предметы на два набора одинакового веса ===

Решаем задачу о сумме подмножеств для targetWeight == (сумма весов предметов) / 2.

bool solve(const vector<int> &itemWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

{{Changed|1=int targetWeight = 0;}}
{{Changed|1=for (int weight : itemWeight)}}
{{Changed|1=targetWeight += weight;}}
{{Changed|1=targetWeight /= 2;}}

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight])
canMake[items][weight] = true;
}
}

return canMake[items.size()][targetWeight];
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(NM) или Θ(M) памяти.

== Примеры кода ==

=== Можно ли набрать сумму targetSum ===

==== Базовый вариант ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
bool canMakeSum(vector<int> &items, int targetSum) {
vector<vector<bool>> canMake(items.size() + 1, vector<bool>(targetSum + 1));
canMake[0][0] = true;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++)
if (canMake[itemCount - 1][sum] ||
sum >= itemWeight && canMake[itemCount - 1][sum - itemWeight])
canMake[itemCount][sum] = true;
}

return canMake[items.size()][targetSum];
}
|
|
bool canMakeSum(vector<int> &items, int targetSum) {
vector<vector<bool>> canMake(items.size() + 1, vector<bool>(targetSum + 1));
canMake[0][0] = true;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++)
if (canMake[itemCount - 1][sum] ||
sum >= itemWeight && canMake[itemCount][sum - itemWeight])
canMake[itemCount][sum] = true;
}

return canMake[items.size()][targetSum];
}
|}

==== Вернуть сертификат (список предметов) ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
vector<int> canMakeSum(vector<int> &items, int targetSum) {
vector<vector<bool>> canMake(items.size() + 1, vector<bool>(targetSum + 1));
canMake[0][0] = true;
vector<vector<pair<int, int>>> from(items.size() + 1, vector<pair<int, int>>(targetSum + 1));

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (canMake[itemCount - 1][sum]) {
canMake[itemCount][sum] = true;
from[itemCount][sum] = { itemCount - 1, sum };
} else if (sum >= itemWeight && canMake[itemCount - 1][sum - itemWeight]) {
canMake[itemCount][sum] = true;
from[itemCount][sum] = { itemCount - 1, sum - itemWeight };
}
}
}

if (!canMake[items.size()][targetSum])
return {};

vector<int> takenItems;
for (int itemCount = items.size(), sum = targetSum; itemCount > 0; ) {
auto &[prevItemCount, prevSum] = from[itemCount][sum];
if (prevSum != sum)
takenItems.push_back(sum - prevSum);
itemCount = prevItemCount;
sum = prevSum;
}
return takenItems;
}
|
|
vector<int> canMakeSum(vector<int> &items, int targetSum) {
vector<vector<bool>> canMake(items.size() + 1, vector<bool>(targetSum + 1));
canMake[0][0] = true;
vector<vector<pair<int, int>>> from(items.size() + 1, vector<pair<int, int>>(targetSum + 1));

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (canMake[itemCount - 1][sum]) {
canMake[itemCount][sum] = true;
from[itemCount][sum] = { itemCount - 1, sum };
} else if (sum >= itemWeight && canMake[itemCount][sum - itemWeight]) {
canMake[itemCount][sum] = true;
from[itemCount][sum] = { itemCount, sum - itemWeight };
}
}
}

if (!canMake[items.size()][targetSum])
return {};

vector<int> takenItems;
for (int itemCount = items.size(), sum = targetSum; itemCount > 0; ) {
auto &[prevItemCount, prevSum] = from[itemCount][sum];
if (prevSum != sum)
takenItems.push_back(sum - prevSum);
itemCount = prevItemCount;
sum = prevSum;
}
return takenItems;
}
|}

==== Базовый вариант, O(targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
bool canMakeSum(vector<int> &items, int targetSum) {
vector<bool> canMake(targetSum + 1);
canMake[0] = true;

for (int itemWeight : items)
for (int sum = targetSum; sum >= itemWeight; sum--)
if (canMake[sum - itemWeight])
canMake[sum] = true;

return canMake[targetSum];
}
|
|
bool canMakeSum(vector<int> &items, int targetSum) {
vector<bool> canMake(targetSum + 1);
canMake[0] = true;

for (int itemWeight : items)
for (int sum = itemWeight; sum <= targetSum; sum++)
if (canMake[sum - itemWeight])
canMake[sum] = true;

return canMake[targetSum];
}
|}

==== Вернуть сертификат (список предметов), O(targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
vector<int> canMakeSum(vector<int> &items, int targetSum) {
vector<bool> canMake(targetSum + 1);
canMake[0] = true;
vector<int> from(targetSum + 1);

for (int itemWeight : items) {
for (int sum = targetSum; sum >= itemWeight; sum--) {
if (!canMake[sum] && canMake[sum - itemWeight]) {
canMake[sum] = true;
from[sum] = sum - itemWeight;
}
}
}

if (!canMake[targetSum])
return {};

vector<int> takenItems;
for (int sum = targetSum; sum > 0; sum = from[sum])
takenItems.push_back(sum - from[sum]);
return takenItems;
}
|
|
vector<int> canMakeSum(vector<int> &items, int targetSum) {
vector<bool> canMake(targetSum + 1);
canMake[0] = true;
vector<int> from(targetSum + 1);

for (int itemWeight : items) {
for (int sum = itemWeight; sum <= targetSum; sum++) {
if (!canMake[sum] && canMake[sum - itemWeight]) {
canMake[sum] = true;
from[sum] = sum - itemWeight;
}
}
}

if (!canMake[targetSum])
return {};

vector<int> takenItems;
for (int sum = targetSum; sum > 0; sum = from[sum])
takenItems.push_back(sum - from[sum]);
return takenItems;
}
|}

=== Каким минимальным количеством предметом можно набрать сумму targetSum ===

==== Базовый вариант ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
int getMinCount(vector<int> &items, int targetSum) {
vector<vector<int>> minCount(items.size() + 1, vector<int>(targetSum + 1, 1e9));
minCount[0][0] = 0;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (minCount[itemCount][sum] > minCount[itemCount - 1][sum])
minCount[itemCount][sum] = minCount[itemCount - 1][sum];
if (sum >= itemWeight && minCount[itemCount][sum] > minCount[itemCount - 1][sum - itemWeight] + 1)
minCount[itemCount][sum] = minCount[itemCount - 1][sum - itemWeight] + 1;
}
}

return minCount[items.size()][targetSum];
}
|
|
int getMinCount(vector<int> &items, int targetSum) {
vector<vector<int>> minCount(items.size() + 1, vector<int>(targetSum + 1, 1e9));
minCount[0][0] = 0;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (minCount[itemCount][sum] > minCount[itemCount - 1][sum])
minCount[itemCount][sum] = minCount[itemCount - 1][sum];
if (sum >= itemWeight && minCount[itemCount][sum] > minCount[itemCount][sum - itemWeight] + 1)
minCount[itemCount][sum] = minCount[itemCount][sum - itemWeight] + 1;
}
}

return minCount[items.size()][targetSum];
}
|}

==== Вернуть сертификат (список предметов) ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
vector<int> getMinCount(vector<int> &items, int targetSum) {
vector<vector<int>> minCount(items.size() + 1, vector<int>(targetSum + 1, 1e9));
minCount[0][0] = 0;
vector<vector<pair<int, int>>> from(items.size() + 1, vector<pair<int, int>>(targetSum + 1));

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (minCount[itemCount][sum] > minCount[itemCount - 1][sum]) {
minCount[itemCount][sum] = minCount[itemCount - 1][sum];
from[itemCount][sum] = { itemCount - 1, sum };
}
if (sum >= itemWeight && minCount[itemCount][sum] > minCount[itemCount - 1][sum - itemWeight] + 1) {
minCount[itemCount][sum] = minCount[itemCount - 1][sum - itemWeight] + 1;
from[itemCount][sum] = { itemCount - 1, sum - itemWeight };
}
}
}

if (minCount[items.size()][targetSum] == 1e9)
return {};

vector<int> takenItems;
for (int itemCount = items.size(), sum = targetSum; itemCount > 0; ) {
auto &[prevItemCount, prevSum] = from[itemCount][sum];
if (prevSum != sum)
takenItems.push_back(sum - prevSum);
itemCount = prevItemCount;
sum = prevSum;
}
return takenItems;
}
|
|
vector<int> getMinCount(vector<int> &items, int targetSum) {
vector<vector<int>> minCount(items.size() + 1, vector<int>(targetSum + 1, 1e9));
minCount[0][0] = 0;
vector<vector<pair<int, int>>> from(items.size() + 1, vector<pair<int, int>>(targetSum + 1));

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (minCount[itemCount][sum] > minCount[itemCount - 1][sum]) {
minCount[itemCount][sum] = minCount[itemCount - 1][sum];
from[itemCount][sum] = { itemCount - 1, sum };
}
if (sum >= itemWeight && minCount[itemCount][sum] > minCount[itemCount][sum - itemWeight] + 1) {
minCount[itemCount][sum] = minCount[itemCount][sum - itemWeight] + 1;
from[itemCount][sum] = { itemCount, sum - itemWeight };
}
}
}

if (minCount[items.size()][targetSum] == 1e9)
return {};

vector<int> takenItems;
for (int itemCount = items.size(), sum = targetSum; itemCount > 0; ) {
auto &[prevItemCount, prevSum] = from[itemCount][sum];
if (prevSum != sum)
takenItems.push_back(sum - prevSum);
itemCount = prevItemCount;
sum = prevSum;
}
return takenItems;
}
|}

==== Базовый вариант, O(targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
int getMinCount(vector<int> &items, int targetSum) {
vector<int> minCount(targetSum + 1, 1e9);
minCount[0] = 0;

for (int itemWeight : items)
for (int sum = targetSum; sum >= itemWeight; sum--)
if (minCount[sum] > minCount[sum - itemWeight] + 1)
minCount[sum] = minCount[sum - itemWeight] + 1;

return minCount[targetSum];
}
|
|
int getMinCount(vector<int> &items, int targetSum) {
vector<int> minCount(targetSum + 1, 1e9);
minCount[0] = 0;

for (int itemWeight : items)
for (int sum = itemWeight; sum <= targetSum; sum++)
if (minCount[sum] > minCount[sum - itemWeight] + 1)
minCount[sum] = minCount[sum - itemWeight] + 1;

return minCount[targetSum];
}
|}

==== Вернуть сертификат (список предметов), O(targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
(Невозможно. Контртест: items = { 1, 2, 3 }, targetSum = 6. Ожидается ответ { 1, 2, 3 }, будет получен ответ { 3, 3 }.)
|
|
vector<int> getMinCount(vector<int> &items, int targetSum) {
vector<int> minCount(targetSum + 1, 1e9);
minCount[0] = 0;
vector<int> from(targetSum + 1);

for (int itemWeight : items) {
for (int sum = itemWeight; sum <= targetSum; sum++) {
if (minCount[sum] > minCount[sum - itemWeight] + 1) {
minCount[sum] = minCount[sum - itemWeight] + 1;
from[sum] = sum - itemWeight;
}
}
}

if (minCount[targetSum] == 1e9)
return {};

vector<int> takenItems;
for (int sum = targetSum; sum > 0; sum = from[sum])
takenItems.push_back(sum - from[sum]);
return takenItems;
}
|}

=== Сколько есть способов набрать сумму targetSum (без учёта порядка, 1 + 2 == 2 + 1) ===

==== Базовый вариант ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
long long getWays(vector<int> &items, int targetSum) {
vector<vector<long long>> ways(items.size() + 1, vector<long long>(targetSum + 1));
ways[0][0] = 1;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
ways[itemCount][sum] += ways[itemCount - 1][sum];
if (sum >= itemWeight)
ways[itemCount][sum] += ways[itemCount - 1][sum - itemWeight];
}
}

return ways[items.size()][targetSum];
}
|
|
long long getWays(vector<int> &items, int targetSum) {
vector<vector<long long>> ways(items.size() + 1, vector<long long>(targetSum + 1));
ways[0][0] = 1;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
ways[itemCount][sum] += ways[itemCount - 1][sum];
if (sum >= itemWeight)
ways[itemCount][sum] += ways[itemCount][sum - itemWeight];
}
}

return ways[items.size()][targetSum];
}
|}

==== Базовый вариант, O(targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
long long getWays(vector<int> &items, int targetSum) {
vector<long long> ways(targetSum + 1);
ways[0] = 1;

for (int itemWeight : items)
for (int sum = targetSum; sum >= itemWeight; sum--)
ways[sum] += ways[sum - itemWeight];

return ways[targetSum];
}
|
|
long long getWays(vector<int> &items, int targetSum) {
vector<long long> ways(targetSum + 1);
ways[0] = 1;

for (int itemWeight : items)
for (int sum = itemWeight; sum <= targetSum; sum++)
ways[sum] += ways[sum - itemWeight];

return ways[targetSum];
}
|}

=== Сколько есть способов набрать сумму targetSum (с учётом порядка, 1 + 2 != 2 + 1) ===

{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
long long getOrderedWays(vector<int> &items, int targetSum) {
vector<vector<long long>> ways(targetSum + 1, vector<long long>(items.size() + 1));
ways[0][0] = 1;

for (int itemWeight : items)
for (int sum = targetSum; sum >= itemWeight; sum--)
for (int takenItemCount = 1; takenItemCount <= items.size(); takenItemCount++)
ways[sum][takenItemCount] += ways[sum - itemWeight][takenItemCount - 1] * takenItemCount;

long long res = 0;
for (int takenItemCount = 0; takenItemCount <= items.size(); takenItemCount++)
res += ways[targetSum][takenItemCount];
return res;
}
|
|
long long getOrderedWays(vector<int> &items, int targetSum) {
vector<long long> ways(targetSum + 1);
ways[0] = 1;

for (int sum = 1; sum <= targetSum; sum++)
for (int itemWeight : items)
if (sum >= itemWeight)
ways[sum] += ways[sum - itemWeight];

return ways[targetSum];
}

(O(targetSum) памяти. По сути, это другая формулировка задачи о кузнечике.)
|}

== Ссылки ==
* [http://algorithmica.org/tg/knapsack-gis-gcs algorithmica.org — Задача о рюкзаке, НВП и НОП]
* [https://brilliant.org/wiki/backpack-problem/ brilliant.org — Backpack Problem]

[[Категория:Динамическое программирование]]

Задача о рюкзаке и связанные задачи

2025-11-18T23:26:34Z

Ctrlalt: /* Also */

__TOC__

== Задача о сумме подмножеств (subset sum problem) ==

=== Можно ли набрать заданный вес ===
Есть несколько предметов, для каждого известен вес. Можем ли мы выбрать несколько предметов так, чтобы общий вес был в точности равен заданному числу?

vector<int> itemWeight; // веса предметов
int targetWeight; // вес, который нужно набрать

Будем заполнять таблицу canMake[][]. Строки таблицы соответствуют количеству рассмотренных предметов: нулевая строка — ноль предметов, первая строка — один предмет, ..., N-я строка — N предметов. Столбцы таблицы соответствуют весам от 0 до заданного веса. В ячейках хранятся true и false: canMake[items][weight] == true, если мы можем набрать вес weight, используя некоторые из items первых предметов.

vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

Как должна выглядеть нулевая строка таблицы? В нулевой строке мы описываем ситуацию, когда не рассмотрено ещё ни одного предмета; какие веса мы при этом можем набрать? Очевидно, только вес 0. Поэтому ячейка canMake[0][0] должна содержать true, а остальные ячейки первой строки — false.

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)

Теперь разберёмся, как должна выглядеть первая строка таблицы (она соответствует первому предмету). Пусть, для определённости, вес первого предмета — 3 (itemWeight[0] == 3). Какие веса мы теперь можем набрать?

Нам всё ещё доступен вес 0 (если мы не будем брать первый предмет), но теперь мы можем получить ещё и вес 3 (если мы возьмём первый предмет).

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)
строка canMake[1] 1 0 0 1 0 0 0 0 0 0 0
(вес предмета — 3)

Далее — вторая строка таблицы (она соответствует первым двум предметам). Пусть вес второго предмета — 5 (itemWeight[1] == 5). Какие веса мы теперь можем набрать?

Нам всё ещё доступны веса 0 и 3 (если мы не будем брать второй предмет), но теперь мы можем получить ещё веса 5 (если мы до этого не брали ничего, а теперь возьмём второй предмет) и 8 (если мы до этого взяли первый предмет и получили вес 3, а сейчас добавим второй предмет).

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)
строка canMake[1] 1 0 0 1 0 0 0 0 0 0 0
(вес предмета — 3)
строка canMake[2] 1 0 0 1 0 1 0 0 1 0 0
(вес предмета — 5)

Далее — третья строка таблицы (она соответствует первым трём предметам). Пусть вес третьего предмета — 2 (itemWeight[2] == 2).

Раньше (без третьего предмета) мы могли набрать веса 0, 3, 5 и 8. Теперь (с третьим предметом) можем дополнительно набрать 2, 5, 7 и 10. Обратите внимание, что вес 5 мы могли набрать как без третьего предмета (просто взяв второй предмет с весом 5), так и с ним (взяв первый и третий предметы с весами 3 и 2); ничего необычного в этой ситуации нет.

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)
строка canMake[1] 1 0 0 1 0 0 0 0 0 0 0
(вес предмета — 3)
строка canMake[2] 1 0 0 1 0 1 0 0 1 0 0
(вес предмета — 5)
строка canMake[3] 1 0 1 1 0 1 0 1 1 0 1
(вес предмета — 2)

Сделаем общие выводы о том, как заполняются строки таблицы. Когда будет true в ячейке canMake[items][weight], то есть когда мы можем набрать вес weight первыми items предметами?

* Во-первых, если мы могли набрать вес weight только предыдущими предметами, не используя новый. То есть, если в предыдущей строке на позиции weight было true (canMake[items - 1][weight] == true).
* Во-вторых, если мы могли набрать вес (weight - currentItemWeight) предыдущими предметами (currentItemWeight — вес текущего предмета). В этом случае, если мы добавим текущий предмет, то мы получим как раз вес weight. То есть, если в предыдущей строке на позиции (weight - currentItemWeight) было true (canMake[items - 1][weight - currentItemWeight] == true).

Теперь мы готовы написать код заполнения таблицы:

bool solve(const vector<int> &itemWeight, int targetWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight])
canMake[items][weight] = true;
}
}

return canMake[items.size()][targetWeight];
}

Ответ на задачу в итоге будет записан в последнюю ячейку последней строки (canMake[itemWeight.size()][targetWeight]).

Временная сложность решения — Θ(NM) (N — количество предметов, M — целевой вес). Для таблицы требуется Θ(NM) памяти.

=== Можно ли набрать заданный вес, каждый предмет можно брать несколько раз ===

Посмотрим, как изменится заполнение таблицы:

суммарные веса 0 1 2 3 4 5 6 7 8 9 10
строка canMake[0] 1 0 0 0 0 0 0 0 0 0 0
(предметов пока нет)
строка canMake[1] 1 0 0 1 0 0 1 0 0 1 0
(вес предмета — 3)
строка canMake[2] 1 0 0 1 0 1 1 0 1 1 1
(вес предмета — 5)
строка canMake[3] 1 0 1 1 1 1 1 1 1 1 1
(вес предмета — 2)

canMake[items][weight] == true, если canMake[items - 1][weight] == true или canMake[items][weight - currentItemWeight] == true.

bool solve(const vector<int> &itemWeight, int targetWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[{{Changed|items}}][weight - currentItemWeight])
canMake[items][weight] = true;
}
}

return canMake[items.size()][targetWeight];
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(NM) памяти.

Заметим, что в данном случае мы можем не делать двумерную таблицу. Нам будет достаточно одной строки canMake[].

bool solve(const vector<int> &itemWeight, int targetWeight) {
vector<bool> canMake(targetWeight + 1);

canMake[0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = currentItemWeight; weight <= targetWeight; weight++) {
if (canMake[weight - currentItemWeight])
canMake[weight] = true;
}
}

return canMake[targetWeight];
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(M) памяти.

=== Можно ли набрать заданный вес, Θ(M) памяти ===

Как и в предыдущем случае, мы можем не делать двумерную таблицу. Нам будет достаточно одной строки canMake[].

Здесь, однако, нужно обратить внимание на то, что если мы будем обновлять строку слева направо, то мы будем учитывать один и тот же предмет несколько раз (как в предыдущем случае). То есть, например, если первый предмет имеет вес 3, то мы запишем true в ячейку 3 (так как в ячейке 0 записано true), затем в ячейку 6 (так как в ячейке 3 записано true), затем в ячейку 9 (так как в ячейке 6 записано true)...

Чтобы избежать такой ситуации, следует обновлять строку не слева направо, а справа налево. Тогда в ячейках слева от текущей никогда не будет изменений, связанных с текущим предметом.

bool solve(const vector<int> &itemWeight, int targetWeight) {
vector<bool> canMake(targetWeight + 1);

canMake[0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for ({{Changed|1=int weight = targetWeight; weight >= currentItemWeight; weight--}}) {
if (canMake[weight - currentItemWeight])
canMake[weight] = true;
}
}

return canMake[targetWeight];
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(M) памяти.

=== Можно ли набрать заданный вес, мало предметов, очень большие веса (⋆) ===
Мы уже не сможем решить такую задачу при помощи динамического программирования, так как при очень большом targetWeight потребуется очень большая таблица, которая не уместится в память (не говоря уже о времени её заполнения).

Если у нас < 25 предметов, можно просто перебрать все их подмножества (рекурсивно или масками, временная сложность O(2^N)).

Если у нас < 50 предметов, кроме перебора понадобится техника meet in the middle. Разделим предметы на две половины. Для каждой половины сделаем set из всех весов, которые можно составить из предметов в этой половине. Дальше нам нужно найти в двух setах два элемента, в сумме дающие targetWeight.

unordered_set<long long> getTotalWeights(const vector<long long> &itemWeight) {
unordered_set<long long> totalWeights;

for (int mask = 0; mask < (1 << itemWeight.size()); mask++) {
long long totalWeight = 0;

for (int bit = 0; bit < itemWeight.size(); bit++) {
if (mask & (1 << bit))
totalWeight += itemWeight[bit];
}

totalWeights.push_back(totalWeight);
}

return totalMasses;
}

bool solve(const vector<long long> &itemWeight, long long targetWeight) {
auto mid = itemWeight.begin() + itemWeight.size() / 2;
unordered_set<long long> aWeights = getTotalWeights({itemWeight.begin(), mid});
unordered_set<long long> bWeights = getTotalWeights({mid, itemWeight.end()});

for (long long aWeight : aWeights) {
if (bWeights.count(targetWeight - aWeight))
return true;
}

return false;
}

Временная сложность решения Θ(2^(N/2)). Для множеств требуется O(2^(N/2)) памяти.

=== Номера предметов, дающих заданный вес ===

Иногда в задаче требуется не только определить, можем ли мы набрать заданный вес, но и вывести сертификат — номера (индексы) предметов, которые мы должны взять.

Вдобавок к таблице canMake[][] сделаем таблицу take[][], в которой будем отмечать, брали ли мы последний предмет. take[items][weight] == true, если, когда мы рассматривали items предметов, мы смогли набрать вес weight, взяв последний предмет (его индекс — (items - 1)).

Заполнение таблицы take[][] происходит одновременно с заполнением таблицы canMake[][]. Всякий раз, когда мы смогли набрать вес при помощи нового предмета, мы ставим true не только в canMake[][], но и в take[][].

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight]) {
canMake[items][weight] = true;
take[items][weight] = true;
}

Когда у нас есть заполненная таблица take[][], мы можем по ней восстановить номера использованных предметов. Обозначим за weight вес предметов, которые нам нужно взять (изначально weight == targetWeight).

Как понять, взяли ли мы самый последний предмет? Если take[items][weight] == true, то мы его брали, иначе — не брали. Если мы взяли последний предмет, то weight нужно уменьшить на itemWeight[items - 1].

Как понять, взяли ли мы предпоследний предмет? Если take[items - 1][weight] == true, то мы его брали, иначе — не брали. Если мы взяли предпоследний предмет, то weight нужно уменьшить на itemWeight[items - 2].

И так далее, от конца к началу мы определяем, брали или нет мы каждый из предметов, попутно уменьшая weight.

{{Changed|vector<int>}} solve(const vector<int> &itemWeight, int targetWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));
{{Changed|vector<vector<bool>> take(itemWeight.size() + 1, vector<int>(targetWeight + 1));}}

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight]) {
canMake[items][weight] = true;
{{Changed|1=take[items][weight] = true;}}
}
}
}

{{Changed|1=if (!canMake[itemWeight.size()][targetItem])}}
{{Changed|1=return {};}}

{{Changed|1=vector<int> takenItemIndexes;}}
{{Changed|1=for (int items = itemWeight.size(), weight = targetWeight; items > 0; items--) {}}
{{Changed|1=if (take[items][weight]) {}}
{{Changed|1=takenItemIndexes.push_back(items - 1);}}
{{Changed|1=weight -= itemWeight[items - 1];}}
{{Changed|1=} }}
{{Changed|1=} }}
{{Changed|1=return takenItemIndexes;}}
}

Временная сложность решения Θ(NM). Для таблиц требуется Θ(NM) памяти.

=== Номера предметов, дающих заданный вес, Θ(M) памяти (⋆) ===

* [https://stackoverflow.com/questions/51941993/0-1-knapsack-find-solution-set-in-space-optimised-implementation stackoverflow.com/questions/51941993/0-1-knapsack-find-solution-set-in-space-optimised-implementation]
* [https://www.cs.colostate.edu/~cs575dl/Sp2015/Lectures/Knapsack.pdf www.cs.colostate.edu/~cs575dl/Sp2015/Lectures/Knapsack.pdf]

vector<bool> getCanMake(const vector<int> &itemWeight, int targetWeight, int l, int r) {
vector<bool> canMake(targetWeight + 1);

canMake[0] = true;

for (int itemIndex = l; itemIndex <= r; itemIndex++) {
int currentItemWeight = itemWeight[itemIndex];

for (int weight = currentItemWeight; weight <= targetWeight; weight++) {
if (canMake[weight - currentItemWeight])
canMake[weight] = true;
}
}

return canMake;
}

vector<int> solve(const vector<int> &itemWeight, int targetWeight, int l, int r) {
if (l == r)
return targetWeight == itemWeight[l] ? { l } : {};

int m = l + (r - l) / 2;
vector<bool> aCan = getCanMake(itemWeight, targetWeight, l, m);
vector<bool> bCan = getCanMake(itemWeight, targetWeight, m + 1, r);

int aWeight = 0, bWeight = targetWeight;
while (!aCan[aWeight] || !bCan[bWeight]) {
aWeight++;
bWeight--;
}

vector<int> aItemIndexes = solve(itemWeight, aWeight, l, m);
vector<int> bItemIndexes = solve(itemWeight, bWeight, m + 1, r);
aItemIndexes.insert(aItemIndexes.end(), bIntemIndexes.begin(), bItemIndexes.end());
return aItemIndexes;
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(M) памяти.

== Вариации на тему задачи о сумме подмножеств ==

=== Какой максимальный вес не больше заданного можно набрать ===

Решаем задачу о сумме подмножеств, ищем самое правое true в последней строке таблицы.

{{Changed|int}} solve(const vector<int> &itemWeight, int targetWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight])
canMake[items][weight] = true;
}
}

{{Changed|1=while (!canMake[items.size()][targetWeight])}}
{{Changed|1=targetWeight--;}}
{{Changed|1=return targetWeight;}}
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(NM) или Θ(M) памяти.

=== Можно ли разделить предметы на два набора одинакового веса ===

Решаем задачу о сумме подмножеств для targetWeight == (сумма весов предметов) / 2.

bool solve(const vector<int> &itemWeight) {
vector<vector<bool>> canMake(itemWeight.size() + 1, vector<int>(targetWeight + 1));

{{Changed|1=int targetWeight = 0;}}
{{Changed|1=for (int weight : itemWeight)}}
{{Changed|1=targetWeight += weight;}}
{{Changed|1=targetWeight /= 2;}}

canMake[0][0] = true;

for (int items = 1; items <= itemWeight.size(); items++) {
int currentItemWeight = itemWeight[items - 1];

for (int weight = 0; weight <= targetWeight; weight++) {
if (canMake[items - 1][weight])
canMake[items][weight] = true;

if (weight >= currentItemWeight && canMake[items - 1][weight - currentItemWeight])
canMake[items][weight] = true;
}
}

return canMake[items.size()][targetWeight];
}

Временная сложность решения Θ(NM). Для таблицы требуется Θ(NM) или Θ(M) памяти.

== Примеры кода ==

=== Можно ли набрать сумму targetSum ===

==== Базовый вариант ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
bool canMakeSum(vector<int> &items, int targetSum) {
vector<vector<bool>> canMake(items.size() + 1, vector<bool>(targetSum + 1));
canMake[0][0] = true;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++)
if (canMake[itemCount - 1][sum] ||
sum >= itemWeight && canMake[itemCount - 1][sum - itemWeight])
canMake[itemCount][sum] = true;
}

return canMake[items.size()][targetSum];
}
|
|
bool canMakeSum(vector<int> &items, int targetSum) {
vector<vector<bool>> canMake(items.size() + 1, vector<bool>(targetSum + 1));
canMake[0][0] = true;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++)
if (canMake[itemCount - 1][sum] ||
sum >= itemWeight && canMake[itemCount][sum - itemWeight])
canMake[itemCount][sum] = true;
}

return canMake[items.size()][targetSum];
}
|}

==== Вернуть сертификат (список предметов) ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
vector<int> canMakeSum(vector<int> &items, int targetSum) {
vector<vector<bool>> canMake(items.size() + 1, vector<bool>(targetSum + 1));
canMake[0][0] = true;
vector<vector<pair<int, int>>> from(items.size() + 1, vector<pair<int, int>>(targetSum + 1));

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (canMake[itemCount - 1][sum]) {
canMake[itemCount][sum] = true;
from[itemCount][sum] = { itemCount - 1, sum };
} else if (sum >= itemWeight && canMake[itemCount - 1][sum - itemWeight]) {
canMake[itemCount][sum] = true;
from[itemCount][sum] = { itemCount - 1, sum - itemWeight };
}
}
}

if (!canMake[items.size()][targetSum])
return {};

vector<int> takenItems;
for (int itemCount = items.size(), sum = targetSum; itemCount > 0; ) {
auto &[prevItemCount, prevSum] = from[itemCount][sum];
if (prevSum != sum)
takenItems.push_back(sum - prevSum);
itemCount = prevItemCount;
sum = prevSum;
}
return takenItems;
}
|
|
vector<int> canMakeSum(vector<int> &items, int targetSum) {
vector<vector<bool>> canMake(items.size() + 1, vector<bool>(targetSum + 1));
canMake[0][0] = true;
vector<vector<pair<int, int>>> from(items.size() + 1, vector<pair<int, int>>(targetSum + 1));

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (canMake[itemCount - 1][sum]) {
canMake[itemCount][sum] = true;
from[itemCount][sum] = { itemCount - 1, sum };
} else if (sum >= itemWeight && canMake[itemCount][sum - itemWeight]) {
canMake[itemCount][sum] = true;
from[itemCount][sum] = { itemCount, sum - itemWeight };
}
}
}

if (!canMake[items.size()][targetSum])
return {};

vector<int> takenItems;
for (int itemCount = items.size(), sum = targetSum; itemCount > 0; ) {
auto &[prevItemCount, prevSum] = from[itemCount][sum];
if (prevSum != sum)
takenItems.push_back(sum - prevSum);
itemCount = prevItemCount;
sum = prevSum;
}
return takenItems;
}
|}

==== Базовый вариант, O(targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
bool canMakeSum(vector<int> &items, int targetSum) {
vector<bool> canMake(targetSum + 1);
canMake[0] = true;

for (int itemWeight : items)
for (int sum = targetSum; sum >= itemWeight; sum--)
if (canMake[sum - itemWeight])
canMake[sum] = true;

return canMake[targetSum];
}
|
|
bool canMakeSum(vector<int> &items, int targetSum) {
vector<bool> canMake(targetSum + 1);
canMake[0] = true;

for (int itemWeight : items)
for (int sum = itemWeight; sum <= targetSum; sum++)
if (canMake[sum - itemWeight])
canMake[sum] = true;

return canMake[targetSum];
}
|}

==== Вернуть сертификат (список предметов), O(targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
vector<int> canMakeSum(vector<int> &items, int targetSum) {
vector<bool> canMake(targetSum + 1);
canMake[0] = true;
vector<int> from(targetSum + 1);

for (int itemWeight : items) {
for (int sum = targetSum; sum >= itemWeight; sum--) {
if (!canMake[sum] && canMake[sum - itemWeight]) {
canMake[sum] = true;
from[sum] = sum - itemWeight;
}
}
}

if (!canMake[targetSum])
return {};

vector<int> takenItems;
for (int sum = targetSum; sum > 0; sum = from[sum])
takenItems.push_back(sum - from[sum]);
return takenItems;
}
|
|
vector<int> canMakeSum(vector<int> &items, int targetSum) {
vector<bool> canMake(targetSum + 1);
canMake[0] = true;
vector<int> from(targetSum + 1);

for (int itemWeight : items) {
for (int sum = itemWeight; sum <= targetSum; sum++) {
if (!canMake[sum] && canMake[sum - itemWeight]) {
canMake[sum] = true;
from[sum] = sum - itemWeight;
}
}
}

if (!canMake[targetSum])
return {};

vector<int> takenItems;
for (int sum = targetSum; sum > 0; sum = from[sum])
takenItems.push_back(sum - from[sum]);
return takenItems;
}
|}

=== Каким минимальным количеством предметом можно набрать сумму targetSum ===

==== Базовый вариант ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
int getMinCount(vector<int> &items, int targetSum) {
vector<vector<int>> minCount(items.size() + 1, vector<int>(targetSum + 1, 1e9));
minCount[0][0] = 0;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (minCount[itemCount][sum] > minCount[itemCount - 1][sum])
minCount[itemCount][sum] = minCount[itemCount - 1][sum];
if (sum >= itemWeight && minCount[itemCount][sum] > minCount[itemCount - 1][sum - itemWeight] + 1)
minCount[itemCount][sum] = minCount[itemCount - 1][sum - itemWeight] + 1;
}
}

return minCount[items.size()][targetSum];
}
|
|
int getMinCount(vector<int> &items, int targetSum) {
vector<vector<int>> minCount(items.size() + 1, vector<int>(targetSum + 1, 1e9));
minCount[0][0] = 0;

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (minCount[itemCount][sum] > minCount[itemCount - 1][sum])
minCount[itemCount][sum] = minCount[itemCount - 1][sum];
if (sum >= itemWeight && minCount[itemCount][sum] > minCount[itemCount][sum - itemWeight] + 1)
minCount[itemCount][sum] = minCount[itemCount][sum - itemWeight] + 1;
}
}

return minCount[items.size()][targetSum];
}
|}

==== Вернуть сертификат (список предметов) ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
vector<int> getMinCount(vector<int> &items, int targetSum) {
vector<vector<int>> minCount(items.size() + 1, vector<int>(targetSum + 1, 1e9));
minCount[0][0] = 0;
vector<vector<pair<int, int>>> from(items.size() + 1, vector<pair<int, int>>(targetSum + 1));

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (minCount[itemCount][sum] > minCount[itemCount - 1][sum]) {
minCount[itemCount][sum] = minCount[itemCount - 1][sum];
from[itemCount][sum] = { itemCount - 1, sum };
}
if (sum >= itemWeight && minCount[itemCount][sum] > minCount[itemCount - 1][sum - itemWeight] + 1) {
minCount[itemCount][sum] = minCount[itemCount - 1][sum - itemWeight] + 1;
from[itemCount][sum] = { itemCount - 1, sum - itemWeight };
}
}
}

if (minCount[items.size()][targetSum] == 1e9)
return {};

vector<int> takenItems;
for (int itemCount = items.size(), sum = targetSum; itemCount > 0; ) {
auto &[prevItemCount, prevSum] = from[itemCount][sum];
if (prevSum != sum)
takenItems.push_back(sum - prevSum);
itemCount = prevItemCount;
sum = prevSum;
}
return takenItems;
}
|
|
vector<int> getMinCount(vector<int> &items, int targetSum) {
vector<vector<int>> minCount(items.size() + 1, vector<int>(targetSum + 1, 1e9));
minCount[0][0] = 0;
vector<vector<pair<int, int>>> from(items.size() + 1, vector<pair<int, int>>(targetSum + 1));

for (int itemCount = 1; itemCount <= items.size(); itemCount++) {
int itemWeight = items[itemCount - 1];
for (int sum = 0; sum <= targetSum; sum++) {
if (minCount[itemCount][sum] > minCount[itemCount - 1][sum]) {
minCount[itemCount][sum] = minCount[itemCount - 1][sum];
from[itemCount][sum] = { itemCount - 1, sum };
}
if (sum >= itemWeight && minCount[itemCount][sum] > minCount[itemCount][sum - itemWeight] + 1) {
minCount[itemCount][sum] = minCount[itemCount][sum - itemWeight] + 1;
from[itemCount][sum] = { itemCount, sum - itemWeight };
}
}
}

if (minCount[items.size()][targetSum] == 1e9)
return {};

vector<int> takenItems;
for (int itemCount = items.size(), sum = targetSum; itemCount > 0; ) {
auto &[prevItemCount, prevSum] = from[itemCount][sum];
if (prevSum != sum)
takenItems.push_back(sum - prevSum);
itemCount = prevItemCount;
sum = prevSum;
}
return takenItems;
}
|}

==== Базовый вариант, O(targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
int getMinCount(vector<int> &items, int targetSum) {
vector<int> minCount(targetSum + 1, 1e9);
minCount[0] = 0;

for (int itemWeight : items)
for (int sum = targetSum; sum >= itemWeight; sum--)
if (minCount[sum] > minCount[sum - itemWeight] + 1)
minCount[sum] = minCount[sum - itemWeight] + 1;

return minCount[targetSum];
}
|
|
int getMinCount(vector<int> &items, int targetSum) {
vector<int> minCount(targetSum + 1, 1e9);
minCount[0] = 0;

for (int itemWeight : items)
for (int sum = itemWeight; sum <= targetSum; sum++)
if (minCount[sum] > minCount[sum - itemWeight] + 1)
minCount[sum] = minCount[sum - itemWeight] + 1;

return minCount[targetSum];
}
|}

==== Вернуть сертификат (список предметов), O(targetSum) памяти ====
{|
|width=50%| Предмет каждого вида ровно один
|  
|width=50%| Предметов каждого вида неограниченно много
|-
|
(Невозможно. Контртест: items = { 1, 2, 3 }, targetSum = 6. Ожидается ответ { 1, 2, 3 }, будет получен ответ { 3, 3 }.)
|
|
vector<int> getMinCount(vector<int> &items, int targetSum) {
vector<int> minCount(targetSum + 1, 1e9);
minCount[0] = 0;
vector<int> from(targetSum + 1);

for (int itemWeight : items) {
for (int sum = itemWeight; sum <= targetSum; sum++) {
if (minCount[sum] > minCount[sum - itemWeight] + 1) {
minCount[sum] = minCount[sum - itemWeight] + 1;
from[sum] = sum - itemWeight;
}
}
}

if (minCount[targetSum] == 1e9)
return {};

vector<int> takenItems;
for (int sum = targetSum; sum > 0; sum = from[sum])
takenItems.push_back(sum - from[sum]);
return takenItems;
}
|}

Сколько есть способов монетами coins набрать сумму targetSum? Способы, отличающиеся только порядком монет, считаются одинаковыми.
{|
|width=50%| Есть лишь одна монета каждого вида
|  
|width=50%| Монет каждого вида неограниченно много
|-
|
long long solve(const vector<int> &coins, int targetSum) {
vector<long long> ways(targetSum + 1);
ways[0] = 1;

for (int coin : coins)
for (int sum = targetSum; sum >= coin; sum--)
ways[sum] += ways[sum - coin];

cout << ways[targetSum];
}
|
|
long long solve(const vector<int> &coins, int targetSum) {
vector<long long> ways(targetSum + 1);
ways[0] = 1;

for (int coin : coins)
for (int sum = coin; sum <= targetSum; sum++)
ways[sum] += ways[sum - coin];

cout << ways[targetSum];
}
|}

Сколько есть способов монетами coins набрать сумму targetSum? Способы, отличающиеся только порядком монет, считаются различными.
{|
|width=50%| Есть лишь одна монета каждого вида
|  
|width=50%| Монет каждого вида неограниченно много
|-
|

|
|
long long solve(const vector<int> &coins, int targetSum) {
vector<long long> ways(targetSum + 1);
ways[0] = 1;

for (int sum = 1; sum <= targetSum; sum++)
for (int coin : coins)
if (coin <= sum)
ways[sum] += [sum - coin];

cout << ways[targetSum];
}
|}

== Ссылки ==
* [http://algorithmica.org/tg/knapsack-gis-gcs algorithmica.org — Задача о рюкзаке, НВП и НОП]
* [https://brilliant.org/wiki/backpack-problem/ brilliant.org — Backpack Problem]

[[Категория:Динамическое программирование]]

Алгоритм Диница

2025-10-22T19:51:47Z

Ctrlalt:

class Graph {
struct Edge {
int a, b, capacity, flow = 0;

Edge(int a, int b, int capacity) :
a(a), b(b), capacity(capacity) {}

int other(int v) const {
return v == b ? a : b;
}

int capacityTo(int v) const {
return v == b ? capacity - flow : flow;
}

void addFlowTo(int v, int deltaFlow) {
flow += (v == b ? deltaFlow : -deltaFlow);
}
};

vector<Edge> edges;
vector<vector<int>> graph;
vector<int> dist, edgeTo, index;

bool hasPath(int start, int finish) {
dist.assign(graph.size(), 1e9);
edgeTo.assign(graph.size(), -1);
index.assign(graph.size(), 0);
queue<int> q;

dist[start] = 0;
q.push(start);

while (!q.empty()) {
int v = q.front();
q.pop();

for (int edgeIndex : graph[v]) {
int to = edges[edgeIndex].other(v);
if (dist[to] > dist[v] + 1 && edges[edgeIndex].capacityTo(to)) {
dist[to] = dist[v] + 1;
q.push(to);
}
}
}

return dist[finish] != 1e9;
}

bool dfs(int v, int finish) {
if (v == finish)
return 1;

for (; index[v] < graph[v].size(); index[v]++) {
int edgeIndex = graph[v][index[v]], to = edges[edgeIndex].other(v);
if (dist[to] == dist[v] + 1 && edges[edgeIndex].capacityTo(to) && dfs(to, finish)) {
edgeTo[to] = edgeIndex;
return 1;
}
}

return 0;
}

int getMinCapacity(int start, int finish) {
int minCapacity = 1e9;
for (int v = finish; v != start; v = edges[edgeTo[v]].other(v))
minCapacity = min(minCapacity, edges[edgeTo[v]].capacityTo(v));
return minCapacity;
}

void addFlow(int start, int finish, int deltaFlow) {
for (int v = finish; v != start; v = edges[edgeTo[v]].other(v))
edges[edgeTo[v]].addFlowTo(v, deltaFlow);
}

public:
Graph(int vertexCount) : graph(vertexCount) {}

void addEdge(int from, int to, int capacity) {
edges.push_back(Edge(from, to, capacity));
graph[from].push_back(edges.size() - 1);
graph[to].push_back(edges.size() - 1);
}

long long maxFlow(int start, int finish) {
long long flow = 0;
while (hasPath(start, finish)) {
while (dfs(start, finish)) {
int deltaFlow = getMinCapacity(start, finish);
addFlow(start, finish, deltaFlow);
flow += deltaFlow;
}
}
return flow;
}
};

== Ссылки ==
Теория:
* [http://e-maxx.ru/algo/dinic e-maxx.ru — Алгоритм Диница нахождения максимального потока]
* [https://cp-algorithms.com/graph/dinic.html cp-algorithms.com — Maximum flow — Dinic's algorithm]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D1%85%D0%B5%D0%BC%D0%B0_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%B0_%D0%94%D0%B8%D0%BD%D0%B8%D1%86%D0%B0 neerc.ifmo.ru/wiki — Схема алгоритма Диница]
* [https://wiki.algocode.ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%94%D0%B8%D0%BD%D0%B8%D1%86%D0%B0 wiki.algocode.ru — Алгоритм Диница]
* [https://codeforces.com/blog/entry/104960 codeforces.com — My way of understanding Dinic's algorithm]
* [https://codeforces.com/blog/entry/145343 codeforces.com — Worst-Case Graphs for Maximum Flow Algorithms]
* [https://usaco.guide/adv/max-flow?lang=cpp#dinics-algorithm usaco.guide — Dinic's Algorithm]
Демонстрация:
* [https://visualgo.net/en/maxflow visualgo.net — Network Flow]
Код:
* [https://github.com/indy256/codelibrary/blob/master/cpp/graphs/flows/max_flow_dinic.h indy256/codelibrary/cpp/graphs/flows/max_flow_dinic.h]
* [https://github.com/ADJA/algos/blob/master/Graphs/Dinic.cpp ADJA/algos/Graphs/Dinic.cpp]
Задачи:
* [http://informatics.mccme.ru/course/view.php?id=6 informatics.mccme.ru — Курс «Алгоритмы на графах» — часть 9]

[[Category: Максимальный поток]]

Алгоритм Эдмондса-Карпа

2025-10-22T19:47:53Z

Ctrlalt:

class Graph {
struct Edge {
int a, b, capacity, flow = 0;

Edge(int a, int b, int capacity) :
a(a), b(b), capacity(capacity) {}

int other(int v) const {
return v == b ? a : b;
}

int capacityTo(int v) const {
return v == b ? capacity - flow : flow;
}

void addFlowTo(int v, int deltaFlow) {
flow += (v == b ? deltaFlow : -deltaFlow);
}
};

vector<Edge> edges;
vector<vector<int>> graph;
vector<int> visited, edgeTo;

bool hasPath(int start, int finish) {
visited.assign(graph.size(), 0);
edgeTo.assign(graph.size(), -1);
queue<int> q;

visited[start] = 1;
q.push(start);

while (!q.empty()) {
int v = q.front();
q.pop();

for (int edgeIndex : graph[v]) {
int to = edges[edgeIndex].other(v);
if (!visited[to] && edges[edgeIndex].capacityTo(to)) {
visited[to] = 1;
edgeTo[to] = edgeIndex;
q.push(to);
}
}
}

return visited[finish];
}

int getMinCapacity(int start, int finish) {
int minCapacity = 1e9;
for (int v = finish; v != start; v = edges[edgeTo[v]].other(v))
minCapacity = min(minCapacity, edges[edgeTo[v]].capacityTo(v));
return minCapacity;
}

void addFlow(int start, int finish, int deltaFlow) {
for (int v = finish; v != start; v = edges[edgeTo[v]].other(v))
edges[edgeTo[v]].addFlowTo(v, deltaFlow);
}

public:
Graph(int vertexCount) : graph(vertexCount) {}

void addEdge(int from, int to, int capacity) {
edges.push_back(Edge(from, to, capacity));
graph[from].push_back(edges.size() - 1);
graph[to].push_back(edges.size() - 1);
}

long long maxFlow(int start, int finish) {
long long flow = 0;
while (hasPath(start, finish)) {
int deltaFlow = getMinCapacity(start, finish);
addFlow(start, finish, deltaFlow);
flow += deltaFlow;
}
return flow;
}
};

== Ссылки ==
Теория:
* [https://algs4.cs.princeton.edu/lectures/keynote/64MaxFlow.pdf algs4.cs.princeton.edu — 6.4 Maximum Flow]
* [http://e-maxx.ru/algo/edmonds_karp e-maxx.ru — Алгоритм Эдмондса-Карпа нахождения максимального потока за O (NM^2)]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%AD%D0%B4%D0%BC%D0%BE%D0%BD%D0%B4%D1%81%D0%B0-%D0%9A%D0%B0%D1%80%D0%BF%D0%B0 neerc.ifmo.ru/wiki — Алгоритм Эдмондса-Карпа]
* [http://brilliant.org/wiki/edmonds-karp-algorithm Brilliant.org — Edmonds-Karp Algorithm]
* [https://codeforces.com/blog/entry/145343 codeforces.com — Worst-Case Graphs for Maximum Flow Algorithms]
Демонстрация:
* [https://visualgo.net/en/maxflow VisuAlgo — Network Flow]
Код:
* [https://github.com/indy256/codelibrary/blob/master/java/graphs/flows/MaxFlowEdmondsKarp.java CodeLibrary — Maximum flow. Edmonds-Karp algorithm in O(min(E^2 * V, E * FLOW))]
* algs4.cs.princeton.edu/code — [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/FlowEdge.java.html capacitated edge with flow], [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/FlowNetwork.java.html capacitated network], [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/FordFulkerson.java.html maxflow–mincut] (несмотря на название, используется алгоритм Эдмондса-Карпа)
Задачи:
* [http://informatics.mccme.ru/course/view.php?id=6 informatics.mccme.ru — Курс «Алгоритмы на графах» — часть 9]
* [[:Категория:Задачи: Максимальный поток|Задачи: Максимальный поток]]

[[Category: Максимальный поток]]

Алгоритм Форда-Фалкерсона

2025-10-22T19:45:30Z

Ctrlalt:

class Graph {
struct Edge {
int a, b, capacity, flow = 0;

Edge(int a, int b, int capacity) :
a(a), b(b), capacity(capacity) {}

int other(int v) const {
return v == b ? a : b;
}

int capacityTo(int v) const {
return v == b ? capacity - flow : flow;
}

void addFlowTo(int v, int deltaFlow) {
flow += (v == b ? deltaFlow : -deltaFlow);
}
};

vector<Edge> edges;
vector<vector<int>> graph;
vector<int> visited, edgeTo;

void dfs(int v) {
visited[v] = 1;
for (int edgeIndex : graph[v]) {
int to = edges[edgeIndex].other(v);
if (!visited[to] && edges[edgeIndex].capacityTo(to)) {
edgeTo[to] = edgeIndex;
dfs(to);
}
}
}

bool hasPath(int start, int finish) {
visited.assign(graph.size(), 0);
edgeTo.assign(graph.size(), -1);
dfs(start);
return visited[finish];
}

int getMinCapacity(int start, int finish) {
int minCapacity = 1e9;
for (int v = finish; v != start; v = edges[edgeTo[v]].other(v))
minCapacity = min(minCapacity, edges[edgeTo[v]].capacityTo(v));
return minCapacity;
}

void addFlow(int start, int finish, int deltaFlow) {
for (int v = finish; v != start; v = edges[edgeTo[v]].other(v))
edges[edgeTo[v]].addFlowTo(v, deltaFlow);
}

public:
Graph(int vertexCount) : graph(vertexCount) {}

void addEdge(int from, int to, int capacity) {
edges.push_back(Edge(from, to, capacity));
graph[from].push_back(edges.size() - 1);
graph[to].push_back(edges.size() - 1);
}

long long maxFlow(int start, int finish) {
long long flow = 0;
while (hasPath(start, finish)) {
int deltaFlow = getMinCapacity(start, finish);
addFlow(start, finish, deltaFlow);
flow += deltaFlow;
}
return flow;
}
};

== Ссылки ==
Теория:
* [https://algs4.cs.princeton.edu/lectures/keynote/64MaxFlow.pdf algs4.cs.princeton.edu — 6.4 Maximum Flow]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%A4%D0%BE%D1%80%D0%B4%D0%B0-%D0%A4%D0%B0%D0%BB%D0%BA%D0%B5%D1%80%D1%81%D0%BE%D0%BD%D0%B0,_%D1%80%D0%B5%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F_%D1%81_%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_%D0%B2_%D0%B3%D0%BB%D1%83%D0%B1%D0%B8%D0%BD%D1%83 neerc.ifmo.ru/wiki — Алгоритм Форда-Фалкерсона]
* [http://brilliant.org/wiki/ford-fulkerson-algorithm Brilliant.org — Ford-Fulkerson Algorithm]
* [https://codeforces.com/blog/entry/145343 codeforces.com — Worst-Case Graphs for Maximum Flow Algorithms]
Демонстрация:
* [https://visualgo.net/en/maxflow VisuAlgo — Network Flow]
Код:
* [https://github.com/indy256/codelibrary/blob/master/java/graphs/flows/MaxFlowFordFulkerson.java CodeLibrary — Maximum flow. Ford-Fulkerson alogithm in O(V^2 * FLOW)]
* [http://github.com/ADJA/algos/blob/master/Graphs/FordFulkerson.cpp Algos — Ford-Fulkerson maxflow]
* algs4.cs.princeton.edu/code — [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/FlowEdge.java.html capacitated edge with flow], [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/FlowNetwork.java.html capacitated network], [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/FordFulkerson.java.html maxflow–mincut] (несмотря на название, используется алгоритм Эдмондса-Карпа)
Задачи:
* [http://informatics.mccme.ru/course/view.php?id=6 informatics.mccme.ru — Курс «Алгоритмы на графах» — часть 9]
* [[:Категория:Задачи: Максимальный поток|Задачи: Максимальный поток]]

[[Category: Максимальный поток]]

Длинная арифметика

2025-10-04T14:22:52Z

Ctrlalt: /* Длинная арифметика на vector */

== Хранение, ввод и вывод ==

class BigInteger {
static const int BASE = 1e9;
static const int BASE_LEN = 9;
static const int MAX_SIZE = 1e4;
int d[MAX_SIZE];
int size;
public:
BigInteger(long long val = 0) {
for (int i = 0; i < MAX_SIZE; i++)
d[i] = 0;
size = 0;
if (val == 0)
d[size++] = 0;
while (val > 0) {
d[size++] = val % BASE;
val /= BASE;
}
}
BigInteger(char val[]) {
for (int i = 0; i < MAX_SIZE; i++)
d[i] = 0;
size = 0;
for (int i = strlen(val) - 1; i >= 0; i -= BASE_LEN) {
int digit = 0;
for (int j = max(0, i - BASE_LEN + 1); j <= i; j++)
digit = digit * 10 + val[j] - '0';
d[size++] = digit;
}
}
void print() const {
static char spec[] = "%00d";
spec[2] = BASE_LEN + '0';
printf("%d", d[size - 1]);
for (int i = size - 2; i >= 0; i--)
printf(spec, d[i]);
}
};

== Сравнение ==

int cmp(const BigInteger &that) const {
if (size != that.size)
return size < that.size ? -1 : 1;
for (int i = size - 1; i >= 0; i--) {
if (d[i] != that.d[i])
return d[i] < that.d[i] ? -1 : 1;
}
return 0;
}
bool operator < (const BigInteger &that) const {
return cmp(that) < 0;
}
bool operator == (const BigInteger &that) const {
return cmp(that) == 0;
}

== Сложение ==

BigInteger operator + (const BigInteger &that) const {
BigInteger res;
int carry = 0;
for (int i = 0; i < max(size, that.size) || carry != 0; i++) {
long long x = 0LL + d[i] + that.d[i] + carry;
res.d[i] = x % BASE;
carry = x / BASE;
}
res.size = max(size, that.size) + 1;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

== Вычитание ==

Предполагается, что уменьшаемое больше вычитаемого.

BigInteger operator - (const BigInteger &that) const {
BigInteger res;
int carry = 0;
for (int i = 0; i < size || carry != 0; i++) {
long long x = 0LL + d[i] - that.d[i] + carry;
res.d[i] = (x + BASE) % BASE;
carry = x < 0 ? -1 : 0;
}
res.size = size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

== Умножение ==

{|
| width="50%" |
BigInteger operator * (const BigInteger &that) const {
BigInteger res;
for (int i = 0; i < size; i++) {
int carry = 0;
for (int j = 0; j < that.size || carry != 0; j++) {
long long x = res.d[i + j] + 1LL * d[i] * that.d[j] + carry;
res.d[i + j] = x % BASE;
carry = x / BASE;
}
}
res.size = size + that.size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}
| width="10px" |
| width="50%" |
BigInteger operator * (int that) const {
BigInteger res;
int carry = 0;
for (int i = 0; i < size || carry != 0; i++) {
long long x = 1LL * d[i] * that + carry;
res.d[i] = x % BASE;
carry = x / BASE;
}
res.size = size + 1;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

|}

== Деление и взятие остатка ==

{|
| width="50%" |
BigInteger operator / (const BigInteger &that) const {
BigInteger res, carry;
for (int i = size - 1; i >= 0; i--) {
carry = carry * BASE;
carry.d[0] = d[i];
int l = 0, r = BASE - 1, m;
while (l + 1 < r) {
m = l + (r - l) / 2;
if ((that * m).cmp(carry) <= 0)
l = m;
else
r = m;
}
res.d[i] = (that * r).cmp(carry) <= 0 ? r : l;
carry = carry - that * res.d[i];
}
res.size = size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}
| width="10px" |
| width="50%" |
BigInteger operator / (int that) const {
BigInteger res;
int carry = 0;
for (int i = size - 1; i >= 0; i--) {
long long x = 1LL * carry * BASE + d[i];
res.d[i] = x / that;
carry = x % that;
}
res.size = size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

|}
{|
| width="50%" |
BigInteger operator % (const BigInteger &that) const {
BigInteger carry;
for (int i = size - 1; i >= 0; i--) {
carry = carry * BASE;
carry.d[0] = d[i];
int l = 0, r = BASE - 1, m;
while (l + 1 < r) {
m = l + (r - l) / 2;
if ((that * m).cmp(carry) <= 0)
l = m;
else
r = m;
}
int digit = (that * r).cmp(carry) <= 0 ? r : l;
carry = carry - that * digit;
}
return carry;
}
| width="10px" |
| width="50%" |
int operator % (int that) const {
int carry = 0;
for (int i = size - 1; i >= 0; i--)
carry = (1LL * carry * BASE + d[i]) % that;
return carry;
}

|}

== Длинная арифметика на vector ==

struct BigInteger {
vector<int> digits;
inline static const int BASE = 1e9;
inline static const int DIGIT_WIDTH = 9;

inline int digit(int index) const {
return index < digits.size() ? digits[index] : 0;
}

inline int &digit(int index) {
if (digits.size() <= index)
digits.resize(index + 1);
return digits[index];
}

inline void removeZeros() {
while (!digits.empty() && !digits.back())
digits.pop_back();
}

BigInteger(long long value = 0) {
for (; value; value /= BASE)
digits.push_back(value % BASE);
}

BigInteger(const string &s) {
for (int r = s.size() - 1; r >= 0; r -= DIGIT_WIDTH) {
int l = max(r - DIGIT_WIDTH + 1, 0);
digits.push_back(stoi(s.substr(l, r - l + 1)));
}
removeZeros();
}

bool operator < (const BigInteger &that) const {
if (digits.size() != that.digits.size())
return digits.size() < that.digits.size();
for (int i = digits.size() - 1; i >= 0; i--)
if (digit(i) != that.digit(i))
return digit(i) < that.digit(i);
return 0;
}

BigInteger operator + (const BigInteger &that) const {
BigInteger res;
for (int i = 0, carry = 0; i < digits.size() || i < that.digits.size() || carry; i++) {
int cur = digit(i) + that.digit(i) + carry;
res.digits.push_back(cur % BASE);
carry = cur / BASE;
}
return res;
}

BigInteger operator - (const BigInteger &that) const {
BigInteger res;
for (int i = 0, carry = 0; i < digits.size() || carry; i++) {
int cur = digit(i) - that.digit(i) + carry;
res.digits.push_back((cur + BASE) % BASE);
carry = cur < 0 ? -1 : 0;
}
res.removeZeros();
return res;
}

BigInteger operator * (const BigInteger &that) const {
BigInteger res;
for (int i = 0, carry = 0; i < digits.size(); i++) {
for (int j = 0; j < that.digits.size() || carry; j++) {
long long cur = res.digit(i + j) + 1LL * digit(i) * that.digit(j) + carry;
res.digit(i + j) = cur % BASE;
carry = cur / BASE;
}
}
res.removeZeros();
return res;
}

BigInteger operator / (int that) const {
BigInteger res;
for (int i = digits.size() - 1, carry = 0; i >= 0; i--) {
long long cur = 1LL * carry * BASE + digit(i);
res.digit(i) = cur / that;
carry = cur % that;
}
res.removeZeros();
return res;
}

int operator % (int that) const {
long long res = 0;
for (int i = digits.size() - 1; i >= 0; i--)
res = (res * BASE + digit(i)) % that;
return res;
}

friend istream &operator >> (istream &in, BigInteger &value) {
string s;
in >> s;
value = BigInteger(s);
return in;
}

friend ostream &operator << (ostream &out, const BigInteger &value) {
if (value.digits.empty()) {
out << 0;
} else {
out << value.digits.back();
for (int i = (int)value.digits.size() - 2; i >= 0; i--) {
out.width(DIGIT_WIDTH);
out.fill('0');
out << value.digits[i];
}
}
return out;
}
};

== Ссылки на задачи ==
* [http://acmp.ru/?main=task&id_task=103 ACMP #103 — Снова A + B]
* [http://acmp.ru/?main=task&id_task=143 ACMP #143 — A - B]
* [http://acmp.ru/?main=task&id_task=144 ACMP #144 — A * B]
* [http://acmp.ru/?main=task&id_task=145 ACMP #145 — A div B]

== Ссылки ==
* [[Сложная длинная арифметика]]
* [http://e-maxx.ru/algo/big_integer e-maxx.ru — Длинная арифметика]
* [http://cppalgo.blogspot.ru/2010/05/blog-post.html cppalgo.blogspot.ru — Длинная арифметика]
* [http://brestprog.neocities.org/lections/longarithmetics.html brestprog.neocities.org — Длинная арифметика]
* [http://informatics.mccme.ru/course/view.php?id=17 informatics.mccme.ru — Курс «Арифметика и числовые алгоритмы» — часть 5]
* [http://github.com/ADJA/algos/blob/master/NumberTheory/BigInt.cpp Algos — Structure implementing long arithmetic in C++]

[[Category:Арифметические алгоритмы]]

Алгоритм Диница

2025-08-07T22:23:27Z

Ctrlalt: /* Ссылки */

class Graph {
struct Edge {
int a, b, capacity, flow = 0;

Edge(int a, int b, int capacity) :
a(a), b(b), capacity(capacity) {}

int other(int v) const {
return v == a ? b : a;
}

int capacityTo(int v) const {
return v == b ? capacity - flow : flow;
}

void addFlowTo(int v, int deltaFlow) {
flow += (v == b ? deltaFlow : -deltaFlow);
}
};

vector<Edge> edges;
vector<vector<int>> graph;
vector<int> dist, edgeTo, index;

bool bfs(int start, int finish) {
dist.assign(graph.size(), 1e9);
queue<int> q;

dist[start] = 0;
q.push(start);

while (!q.empty()) {
int v = q.front();
q.pop();

for (int e : graph[v]) {
int to = edges[e].other(v);
if (edges[e].capacityTo(to) && dist[to] > dist[v] + 1) {
dist[to] = dist[v] + 1;
q.push(to);
}
}
}

return dist[finish] != 1e9;
}

bool dfs(int v, int finish) {
if (v == finish)
return 1;

for ( ; index[v] < graph[v].size(); index[v]++) {
int e = graph[v][index[v]], to = edges[e].other(v);
if (edges[e].capacityTo(to) && dist[to] == dist[v] + 1 && dfs(to, finish)) {
edgeTo[to] = e;
return 1;
}
}

return 0;
}

int bottleneckCapacity(int start, int finish) {
int bCapacity = 1e9;
for (int v = finish; v != start; v = edges[edgeTo[v]].other(v))
bCapacity = min(bCapacity, edges[edgeTo[v]].capacityTo(v));
return bCapacity;
}

void addFlow(int start, int finish, int deltaFlow) {
for (int v = finish; v != start; v = edges[edgeTo[v]].other(v))
edges[edgeTo[v]].addFlowTo(v, deltaFlow);
}

public:
Graph(int vertexCount) :
graph(vertexCount), dist(vertexCount), edgeTo(vertexCount), index(vertexCount) {}

void addEdge(int from, int to, int capacity) {
edges.push_back(Edge(from, to, capacity));
graph[from].push_back(edges.size() - 1);
graph[to].push_back(edges.size() - 1);
}

long long maxFlow(int start, int finish) {
long long flow = 0;
while (bfs(start, finish)) {
index.assign(graph.size(), 0);
while (dfs(start, finish)) {
int deltaFlow = bottleneckCapacity(start, finish);
addFlow(start, finish, deltaFlow);
flow += deltaFlow;
}
}
return flow;
}
};

== Ссылки ==
Теория:
* [http://e-maxx.ru/algo/dinic e-maxx.ru — Алгоритм Диница нахождения максимального потока]
* [https://cp-algorithms.com/graph/dinic.html cp-algorithms.com — Maximum flow — Dinic's algorithm]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D1%85%D0%B5%D0%BC%D0%B0_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%B0_%D0%94%D0%B8%D0%BD%D0%B8%D1%86%D0%B0 neerc.ifmo.ru/wiki — Схема алгоритма Диница]
* [https://wiki.algocode.ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%94%D0%B8%D0%BD%D0%B8%D1%86%D0%B0 wiki.algocode.ru — Алгоритм Диница]
* [https://codeforces.com/blog/entry/104960 codeforces.com — My way of understanding Dinic's algorithm]
* [https://codeforces.com/blog/entry/145343 codeforces.com — Worst-Case Graphs for Maximum Flow Algorithms]
* [https://usaco.guide/adv/max-flow?lang=cpp#dinics-algorithm usaco.guide — Dinic's Algorithm]
Демонстрация:
* [https://visualgo.net/en/maxflow visualgo.net — Network Flow]
Код:
* [https://github.com/indy256/codelibrary/blob/master/cpp/graphs/flows/max_flow_dinic.h indy256/codelibrary/cpp/graphs/flows/max_flow_dinic.h]
* [https://github.com/ADJA/algos/blob/master/Graphs/Dinic.cpp ADJA/algos/Graphs/Dinic.cpp]
Задачи:
* [http://informatics.mccme.ru/course/view.php?id=6 informatics.mccme.ru — Курс «Алгоритмы на графах» — часть 9]

[[Category: Максимальный поток]]

Алгоритм Эдмондса-Карпа

2025-08-07T22:23:13Z

Ctrlalt: /* Ссылки */

class Graph {
struct Edge {
int a, b, capacity, flow = 0;

Edge(int a, int b, int capacity) :
a(a), b(b), capacity(capacity) {}

int other(int v) const {
return v == a ? b : a;
}

int capacityTo(int v) const {
return v == b ? capacity - flow : flow;
}

void addFlowTo(int v, int deltaFlow) {
flow += (v == b ? deltaFlow : -deltaFlow);
}
};

vector<Edge> edges;
vector<vector<int>> graph;
vector<bool> visited;
vector<int> edgeTo;

void bfs(int start) {
queue<int> q;
visited[start] = 1;
q.push(start);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int e : graph[v]) {
int to = edges[e].other(v);
if (!visited[to] && edges[e].capacityTo(to)) {
edgeTo[to] = e;
visited[to] = 1;
q.push(to);
}
}
}
}

bool hasPath(int start, int finish) {
visited.assign(visited.size(), 0);
bfs(start);
return visited[finish];
}

int bottleneckCapacity(int start, int finish) {
int bCapacity = 1e9;
for (int v = finish; v != start; v = edges[edgeTo[v]].other(v))
bCapacity = min(bCapacity, edges[edgeTo[v]].capacityTo(v));
return bCapacity;
}

void addFlow(int start, int finish, int deltaFlow) {
for (int v = finish; v != start; v = edges[edgeTo[v]].other(v))
edges[edgeTo[v]].addFlowTo(v, deltaFlow);
}

public:
Graph(int vertexCount) :
graph(vertexCount), visited(vertexCount), edgeTo(vertexCount) {}

void addEdge(int from, int to, int capacity) {
edges.push_back(Edge(from, to, capacity));
graph[from].push_back(edges.size() - 1);
graph[to].push_back(edges.size() - 1);
}

long long maxFlow(int start, int finish) {
long long flow = 0;
while (hasPath(start, finish)) {
int deltaFlow = bottleneckCapacity(start, finish);
addFlow(start, finish, deltaFlow);
flow += deltaFlow;
}
return flow;
}
};

== Ссылки ==
Теория:
* [https://algs4.cs.princeton.edu/lectures/keynote/64MaxFlow.pdf algs4.cs.princeton.edu — 6.4 Maximum Flow]
* [http://e-maxx.ru/algo/edmonds_karp e-maxx.ru — Алгоритм Эдмондса-Карпа нахождения максимального потока за O (NM^2)]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%AD%D0%B4%D0%BC%D0%BE%D0%BD%D0%B4%D1%81%D0%B0-%D0%9A%D0%B0%D1%80%D0%BF%D0%B0 neerc.ifmo.ru/wiki — Алгоритм Эдмондса-Карпа]
* [http://brilliant.org/wiki/edmonds-karp-algorithm Brilliant.org — Edmonds-Karp Algorithm]
* [https://codeforces.com/blog/entry/145343 codeforces.com — Worst-Case Graphs for Maximum Flow Algorithms]
Демонстрация:
* [https://visualgo.net/en/maxflow VisuAlgo — Network Flow]
Код:
* [https://github.com/indy256/codelibrary/blob/master/java/graphs/flows/MaxFlowEdmondsKarp.java CodeLibrary — Maximum flow. Edmonds-Karp algorithm in O(min(E^2 * V, E * FLOW))]
* algs4.cs.princeton.edu/code — [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/FlowEdge.java.html capacitated edge with flow], [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/FlowNetwork.java.html capacitated network], [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/FordFulkerson.java.html maxflow–mincut] (несмотря на название, используется алгоритм Эдмондса-Карпа)
Задачи:
* [http://informatics.mccme.ru/course/view.php?id=6 informatics.mccme.ru — Курс «Алгоритмы на графах» — часть 9]
* [[:Категория:Задачи: Максимальный поток|Задачи: Максимальный поток]]

[[Category: Максимальный поток]]

Алгоритм Форда-Фалкерсона

2025-08-07T22:22:53Z

Ctrlalt: /* Ссылки */

class Graph {
struct Edge {
int a, b, capacity, flow = 0;

Edge(int a, int b, int capacity) :
a(a), b(b), capacity(capacity) {}

int other(int v) const {
return v == a ? b : a;
}

int capacityTo(int v) const {
return v == b ? capacity - flow : flow;
}

void addFlowTo(int v, int deltaFlow) {
flow += (v == b ? deltaFlow : -deltaFlow);
}
};

vector<Edge> edges;
vector<vector<int>> graph;
vector<bool> visited;
vector<int> edgeTo;

void dfs(int v) {
visited[v] = 1;
for (int e : graph[v]) {
int to = edges[e].other(v);
if (!visited[to] && edges[e].capacityTo(to)) {
edgeTo[to] = e;
dfs(to);
}
}
}

bool hasPath(int start, int finish) {
visited.assign(visited.size(), 0);
dfs(start);
return visited[finish];
}

int bottleneckCapacity(int start, int finish) {
int bCapacity = 1e9;
for (int v = finish; v != start; v = edges[edgeTo[v]].other(v))
bCapacity = min(bCapacity, edges[edgeTo[v]].capacityTo(v));
return bCapacity;
}

void addFlow(int start, int finish, int deltaFlow) {
for (int v = finish; v != start; v = edges[edgeTo[v]].other(v))
edges[edgeTo[v]].addFlowTo(v, deltaFlow);
}

public:
Graph(int vertexCount) :
graph(vertexCount), visited(vertexCount), edgeTo(vertexCount) {}

void addEdge(int from, int to, int capacity) {
edges.push_back(Edge(from, to, capacity));
graph[from].push_back(edges.size() - 1);
graph[to].push_back(edges.size() - 1);
}

long long maxFlow(int start, int finish) {
long long flow = 0;
while (hasPath(start, finish)) {
int deltaFlow = bottleneckCapacity(start, finish);
addFlow(start, finish, deltaFlow);
flow += deltaFlow;
}
return flow;
}
};

== Ссылки ==
Теория:
* [https://algs4.cs.princeton.edu/lectures/keynote/64MaxFlow.pdf algs4.cs.princeton.edu — 6.4 Maximum Flow]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%A4%D0%BE%D1%80%D0%B4%D0%B0-%D0%A4%D0%B0%D0%BB%D0%BA%D0%B5%D1%80%D1%81%D0%BE%D0%BD%D0%B0,_%D1%80%D0%B5%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F_%D1%81_%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_%D0%B2_%D0%B3%D0%BB%D1%83%D0%B1%D0%B8%D0%BD%D1%83 neerc.ifmo.ru/wiki — Алгоритм Форда-Фалкерсона]
* [http://brilliant.org/wiki/ford-fulkerson-algorithm Brilliant.org — Ford-Fulkerson Algorithm]
* [https://codeforces.com/blog/entry/145343 codeforces.com — Worst-Case Graphs for Maximum Flow Algorithms]
Демонстрация:
* [https://visualgo.net/en/maxflow VisuAlgo — Network Flow]
Код:
* [https://github.com/indy256/codelibrary/blob/master/java/graphs/flows/MaxFlowFordFulkerson.java CodeLibrary — Maximum flow. Ford-Fulkerson alogithm in O(V^2 * FLOW)]
* [http://github.com/ADJA/algos/blob/master/Graphs/FordFulkerson.cpp Algos — Ford-Fulkerson maxflow]
* algs4.cs.princeton.edu/code — [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/FlowEdge.java.html capacitated edge with flow], [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/FlowNetwork.java.html capacitated network], [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/FordFulkerson.java.html maxflow–mincut] (несмотря на название, используется алгоритм Эдмондса-Карпа)
Задачи:
* [http://informatics.mccme.ru/course/view.php?id=6 informatics.mccme.ru — Курс «Алгоритмы на графах» — часть 9]
* [[:Категория:Задачи: Максимальный поток|Задачи: Максимальный поток]]

[[Category: Максимальный поток]]

Длинная арифметика

2025-04-13T19:01:11Z

Ctrlalt: /* Длинная арифметика на vector */

== Хранение, ввод и вывод ==

class BigInteger {
static const int BASE = 1e9;
static const int BASE_LEN = 9;
static const int MAX_SIZE = 1e4;
int d[MAX_SIZE];
int size;
public:
BigInteger(long long val = 0) {
for (int i = 0; i < MAX_SIZE; i++)
d[i] = 0;
size = 0;
if (val == 0)
d[size++] = 0;
while (val > 0) {
d[size++] = val % BASE;
val /= BASE;
}
}
BigInteger(char val[]) {
for (int i = 0; i < MAX_SIZE; i++)
d[i] = 0;
size = 0;
for (int i = strlen(val) - 1; i >= 0; i -= BASE_LEN) {
int digit = 0;
for (int j = max(0, i - BASE_LEN + 1); j <= i; j++)
digit = digit * 10 + val[j] - '0';
d[size++] = digit;
}
}
void print() const {
static char spec[] = "%00d";
spec[2] = BASE_LEN + '0';
printf("%d", d[size - 1]);
for (int i = size - 2; i >= 0; i--)
printf(spec, d[i]);
}
};

== Сравнение ==

int cmp(const BigInteger &that) const {
if (size != that.size)
return size < that.size ? -1 : 1;
for (int i = size - 1; i >= 0; i--) {
if (d[i] != that.d[i])
return d[i] < that.d[i] ? -1 : 1;
}
return 0;
}
bool operator < (const BigInteger &that) const {
return cmp(that) < 0;
}
bool operator == (const BigInteger &that) const {
return cmp(that) == 0;
}

== Сложение ==

BigInteger operator + (const BigInteger &that) const {
BigInteger res;
int carry = 0;
for (int i = 0; i < max(size, that.size) || carry != 0; i++) {
long long x = 0LL + d[i] + that.d[i] + carry;
res.d[i] = x % BASE;
carry = x / BASE;
}
res.size = max(size, that.size) + 1;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

== Вычитание ==

Предполагается, что уменьшаемое больше вычитаемого.

BigInteger operator - (const BigInteger &that) const {
BigInteger res;
int carry = 0;
for (int i = 0; i < size || carry != 0; i++) {
long long x = 0LL + d[i] - that.d[i] + carry;
res.d[i] = (x + BASE) % BASE;
carry = x < 0 ? -1 : 0;
}
res.size = size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

== Умножение ==

{|
| width="50%" |
BigInteger operator * (const BigInteger &that) const {
BigInteger res;
for (int i = 0; i < size; i++) {
int carry = 0;
for (int j = 0; j < that.size || carry != 0; j++) {
long long x = res.d[i + j] + 1LL * d[i] * that.d[j] + carry;
res.d[i + j] = x % BASE;
carry = x / BASE;
}
}
res.size = size + that.size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}
| width="10px" |
| width="50%" |
BigInteger operator * (int that) const {
BigInteger res;
int carry = 0;
for (int i = 0; i < size || carry != 0; i++) {
long long x = 1LL * d[i] * that + carry;
res.d[i] = x % BASE;
carry = x / BASE;
}
res.size = size + 1;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

|}

== Деление и взятие остатка ==

{|
| width="50%" |
BigInteger operator / (const BigInteger &that) const {
BigInteger res, carry;
for (int i = size - 1; i >= 0; i--) {
carry = carry * BASE;
carry.d[0] = d[i];
int l = 0, r = BASE - 1, m;
while (l + 1 < r) {
m = l + (r - l) / 2;
if ((that * m).cmp(carry) <= 0)
l = m;
else
r = m;
}
res.d[i] = (that * r).cmp(carry) <= 0 ? r : l;
carry = carry - that * res.d[i];
}
res.size = size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}
| width="10px" |
| width="50%" |
BigInteger operator / (int that) const {
BigInteger res;
int carry = 0;
for (int i = size - 1; i >= 0; i--) {
long long x = 1LL * carry * BASE + d[i];
res.d[i] = x / that;
carry = x % that;
}
res.size = size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

|}
{|
| width="50%" |
BigInteger operator % (const BigInteger &that) const {
BigInteger carry;
for (int i = size - 1; i >= 0; i--) {
carry = carry * BASE;
carry.d[0] = d[i];
int l = 0, r = BASE - 1, m;
while (l + 1 < r) {
m = l + (r - l) / 2;
if ((that * m).cmp(carry) <= 0)
l = m;
else
r = m;
}
int digit = (that * r).cmp(carry) <= 0 ? r : l;
carry = carry - that * digit;
}
return carry;
}
| width="10px" |
| width="50%" |
int operator % (int that) const {
int carry = 0;
for (int i = size - 1; i >= 0; i--)
carry = (1LL * carry * BASE + d[i]) % that;
return carry;
}

|}

== Длинная арифметика на vector ==

struct BigInteger {
vector<int> digits;
inline static const int BASE = 1e9;
inline static const int DIGIT_WIDTH = 9;

inline int digit(int index) const {
return index < digits.size() ? digits[index] : 0;
}

inline int &digit(int index) {
if (digits.size() <= index)
digits.resize(index + 1);
return digits[index];
}

inline void removeZeros() {
while (!digits.empty() && !digits.back())
digits.pop_back();
}

BigInteger(long long value = 0) {
for (; value; value /= BASE)
digits.push_back(value % BASE);
}

BigInteger(const string &s) {
for (int r = s.size() - 1; r >= 0; r -= DIGIT_WIDTH) {
int l = max(r - DIGIT_WIDTH + 1, 0);
digits.push_back(stoi(s.substr(l, r - l + 1)));
}
removeZeros();
}

bool operator < (const BigInteger &that) const {
if (digits.size() != that.digits.size())
return digits.size() < that.digits.size();
for (int i = digits.size() - 1; i >= 0; i--)
if (digit(i) != that.digit(i))
return digit(i) < that.digit(i);
return 0;
}

BigInteger operator + (const BigInteger &that) const {
BigInteger res;
for (int i = 0, carry = 0; i < digits.size() || i < that.digits.size() || carry; i++) {
int cur = digit(i) + that.digit(i) + carry;
res.digits.push_back(cur % BASE);
carry = cur / BASE;
}
return res;
}

BigInteger operator * (const BigInteger &that) const {
BigInteger res;
for (int i = 0, carry = 0; i < digits.size(); i++) {
for (int j = 0; j < that.digits.size() || carry; j++) {
long long cur = res.digit(i + j) + 1LL * digit(i) * that.digit(j) + carry;
res.digit(i + j) = cur % BASE;
carry = cur / BASE;
}
}
res.removeZeros();
return res;
}

BigInteger operator / (int that) const {
BigInteger res;
for (int i = digits.size() - 1, carry = 0; i >= 0; i--) {
long long cur = 1LL * carry * BASE + digit(i);
res.digit(i) = cur / that;
carry = cur % that;
}
res.removeZeros();
return res;
}

int operator % (int that) const {
long long res = 0;
for (int i = digits.size() - 1; i >= 0; i--)
res = (res * BASE + digit(i)) % that;
return res;
}

friend istream &operator >> (istream &in, BigInteger &value) {
string s;
in >> s;
value = BigInteger(s);
return in;
}

friend ostream &operator << (ostream &out, const BigInteger &value) {
if (value.digits.empty()) {
out << 0;
} else {
out << value.digits.back();
for (int i = (int)value.digits.size() - 2; i >= 0; i--) {
out.width(DIGIT_WIDTH);
out.fill('0');
out << value.digits[i];
}
}
return out;
}
};

== Ссылки на задачи ==
* [http://acmp.ru/?main=task&id_task=103 ACMP #103 — Снова A + B]
* [http://acmp.ru/?main=task&id_task=143 ACMP #143 — A - B]
* [http://acmp.ru/?main=task&id_task=144 ACMP #144 — A * B]
* [http://acmp.ru/?main=task&id_task=145 ACMP #145 — A div B]

== Ссылки ==
* [[Сложная длинная арифметика]]
* [http://e-maxx.ru/algo/big_integer e-maxx.ru — Длинная арифметика]
* [http://cppalgo.blogspot.ru/2010/05/blog-post.html cppalgo.blogspot.ru — Длинная арифметика]
* [http://brestprog.neocities.org/lections/longarithmetics.html brestprog.neocities.org — Длинная арифметика]
* [http://informatics.mccme.ru/course/view.php?id=17 informatics.mccme.ru — Курс «Арифметика и числовые алгоритмы» — часть 5]
* [http://github.com/ADJA/algos/blob/master/NumberTheory/BigInt.cpp Algos — Structure implementing long arithmetic in C++]

[[Category:Арифметические алгоритмы]]

Длинная арифметика

2025-04-13T19:00:53Z

Ctrlalt: /* Длинная арифметика на vector */

== Хранение, ввод и вывод ==

class BigInteger {
static const int BASE = 1e9;
static const int BASE_LEN = 9;
static const int MAX_SIZE = 1e4;
int d[MAX_SIZE];
int size;
public:
BigInteger(long long val = 0) {
for (int i = 0; i < MAX_SIZE; i++)
d[i] = 0;
size = 0;
if (val == 0)
d[size++] = 0;
while (val > 0) {
d[size++] = val % BASE;
val /= BASE;
}
}
BigInteger(char val[]) {
for (int i = 0; i < MAX_SIZE; i++)
d[i] = 0;
size = 0;
for (int i = strlen(val) - 1; i >= 0; i -= BASE_LEN) {
int digit = 0;
for (int j = max(0, i - BASE_LEN + 1); j <= i; j++)
digit = digit * 10 + val[j] - '0';
d[size++] = digit;
}
}
void print() const {
static char spec[] = "%00d";
spec[2] = BASE_LEN + '0';
printf("%d", d[size - 1]);
for (int i = size - 2; i >= 0; i--)
printf(spec, d[i]);
}
};

== Сравнение ==

int cmp(const BigInteger &that) const {
if (size != that.size)
return size < that.size ? -1 : 1;
for (int i = size - 1; i >= 0; i--) {
if (d[i] != that.d[i])
return d[i] < that.d[i] ? -1 : 1;
}
return 0;
}
bool operator < (const BigInteger &that) const {
return cmp(that) < 0;
}
bool operator == (const BigInteger &that) const {
return cmp(that) == 0;
}

== Сложение ==

BigInteger operator + (const BigInteger &that) const {
BigInteger res;
int carry = 0;
for (int i = 0; i < max(size, that.size) || carry != 0; i++) {
long long x = 0LL + d[i] + that.d[i] + carry;
res.d[i] = x % BASE;
carry = x / BASE;
}
res.size = max(size, that.size) + 1;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

== Вычитание ==

Предполагается, что уменьшаемое больше вычитаемого.

BigInteger operator - (const BigInteger &that) const {
BigInteger res;
int carry = 0;
for (int i = 0; i < size || carry != 0; i++) {
long long x = 0LL + d[i] - that.d[i] + carry;
res.d[i] = (x + BASE) % BASE;
carry = x < 0 ? -1 : 0;
}
res.size = size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

== Умножение ==

{|
| width="50%" |
BigInteger operator * (const BigInteger &that) const {
BigInteger res;
for (int i = 0; i < size; i++) {
int carry = 0;
for (int j = 0; j < that.size || carry != 0; j++) {
long long x = res.d[i + j] + 1LL * d[i] * that.d[j] + carry;
res.d[i + j] = x % BASE;
carry = x / BASE;
}
}
res.size = size + that.size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}
| width="10px" |
| width="50%" |
BigInteger operator * (int that) const {
BigInteger res;
int carry = 0;
for (int i = 0; i < size || carry != 0; i++) {
long long x = 1LL * d[i] * that + carry;
res.d[i] = x % BASE;
carry = x / BASE;
}
res.size = size + 1;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

|}

== Деление и взятие остатка ==

{|
| width="50%" |
BigInteger operator / (const BigInteger &that) const {
BigInteger res, carry;
for (int i = size - 1; i >= 0; i--) {
carry = carry * BASE;
carry.d[0] = d[i];
int l = 0, r = BASE - 1, m;
while (l + 1 < r) {
m = l + (r - l) / 2;
if ((that * m).cmp(carry) <= 0)
l = m;
else
r = m;
}
res.d[i] = (that * r).cmp(carry) <= 0 ? r : l;
carry = carry - that * res.d[i];
}
res.size = size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}
| width="10px" |
| width="50%" |
BigInteger operator / (int that) const {
BigInteger res;
int carry = 0;
for (int i = size - 1; i >= 0; i--) {
long long x = 1LL * carry * BASE + d[i];
res.d[i] = x / that;
carry = x % that;
}
res.size = size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

|}
{|
| width="50%" |
BigInteger operator % (const BigInteger &that) const {
BigInteger carry;
for (int i = size - 1; i >= 0; i--) {
carry = carry * BASE;
carry.d[0] = d[i];
int l = 0, r = BASE - 1, m;
while (l + 1 < r) {
m = l + (r - l) / 2;
if ((that * m).cmp(carry) <= 0)
l = m;
else
r = m;
}
int digit = (that * r).cmp(carry) <= 0 ? r : l;
carry = carry - that * digit;
}
return carry;
}
| width="10px" |
| width="50%" |
int operator % (int that) const {
int carry = 0;
for (int i = size - 1; i >= 0; i--)
carry = (1LL * carry * BASE + d[i]) % that;
return carry;
}

|}

== Длинная арифметика на vector ==

struct BigInteger {
vector<int> digits;
inline static const int BASE = 1e9;
inline static const int DIGIT_WIDTH = 9;

inline int digit(int index) const {
return index < digits.size() ? digits[index] : 0;
}

inline int &digit(int index) {
if (digits.size() <= index)
digits.resize(index + 1);
return digits[index];
}

inline void removeZeros() {
while (!digits.empty() && !digits.back())
digits.pop_back();
}

BigInteger(long long value = 0) {
for (; value; value /= BASE)
digits.push_back(value % BASE);
}

BigInteger(const string &s) {
for (int r = s.size() - 1; r >= 0; r -= DIGIT_WIDTH) {
int l = max(r - DIGIT_WIDTH + 1, 0);
digits.push_back(stoi(s.substr(l, r - l + 1)));
}
removeZeros();
}

bool operator < (const BigInteger &that) const {
if (digits.size() != that.digits.size())
return digits.size() < that.digits.size();
for (int i = digits.size() - 1; i >= 0; i--)
if (digit(i) != that.digit(i))
return digit(i) < that.digit(i);
return 0;
}

BigInteger operator + (const BigInteger &that) const {
BigInteger res;
for (int i = 0, carry = 0; i < digits.size() || i < that.digits.size() || carry; i++) {
int cur = digit(i) + that.digit(i) + carry;
res.digits.push_back(cur % BASE);
carry = cur / BASE;
}
return res;
}

BigInteger operator * (const BigInteger &that) const {
BigInteger res;
for (int i = 0, carry = 0; i < digits.size(); i++) {
for (int j = 0; j < that.digits.size() || carry; j++) {
long long cur = res.digit(i + j) + 1LL * digit(i) * that.digit(j) + carry;
res.digit(i + j) = cur % BASE;
carry = cur / BASE;
}
}
res.removeZeros();
return res;
}

BigInteger operator / (int that) const {
BigInteger res;
for (int i = digits.size() - 1, carry = 0; i >= 0; i--) {
long long cur = 1LL * carry * BASE + digit(i);
res.digit(i) = cur / that;
carry = cur % that;
}
res.removeZeros();
return res;
}

int operator % (int that) const {
long long res = 0;
for (int i = digits.size() - 1; i >= 0; i--)
res = (res * BASE + digit(i)) % that;
return res;
}

friend istream &operator >> (istream &in, BigInteger &value) {
string s;
in >> s;
value = BigInteger(s);
return in;
}

friend ostream &operator << (ostream &out, const BigInteger &value) {
if (value.digits.empty()) {
out << 0;
} else {
out << value.digits.back();
for (int i = (int)value.digits.size() - 2; i >= 0; i--) {
out.width(DIGIT_WIDTH);
out.fill('0');
out << value.digits[i];
}
}
return out;
}
};

== Ссылки на задачи ==
* [http://acmp.ru/?main=task&id_task=103 ACMP #103 — Снова A + B]
* [http://acmp.ru/?main=task&id_task=143 ACMP #143 — A - B]
* [http://acmp.ru/?main=task&id_task=144 ACMP #144 — A * B]
* [http://acmp.ru/?main=task&id_task=145 ACMP #145 — A div B]

== Ссылки ==
* [[Сложная длинная арифметика]]
* [http://e-maxx.ru/algo/big_integer e-maxx.ru — Длинная арифметика]
* [http://cppalgo.blogspot.ru/2010/05/blog-post.html cppalgo.blogspot.ru — Длинная арифметика]
* [http://brestprog.neocities.org/lections/longarithmetics.html brestprog.neocities.org — Длинная арифметика]
* [http://informatics.mccme.ru/course/view.php?id=17 informatics.mccme.ru — Курс «Арифметика и числовые алгоритмы» — часть 5]
* [http://github.com/ADJA/algos/blob/master/NumberTheory/BigInt.cpp Algos — Structure implementing long arithmetic in C++]

[[Category:Арифметические алгоритмы]]

Книги и сайты

2025-02-21T18:54:22Z

Ctrlalt:

== Тестирующие системы ==
Представленные в [http://github.com/vfolunin/monitor мониторе]:
* [http://acmp.ru acmp.ru]
* [http://informatics.msk.ru informatics.msk.ru]
* [http://acm.timus.ru acm.timus.ru]
* [http://codeforces.com codeforces.com]
* [http://e-olymp.com e-olymp.com]
* [http://spoj.com spoj.com]
* [http://onlinejudge.org onlinejudge.org]
* [http://cses.fi/problemset cses.fi/problemset]
Другие:
* [http://open.kattis.com open.kattis.com]
* [http://beecrowd.com.br beecrowd.com.br]
* [http://leetcode.com leetcode.com]

== Сайты ==
Теория:
* [http://e-maxx.ru/algo/ e-maxx.ru], [http://cp-algorithms.com cp-algorithms.com]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%94%D0%B8%D1%81%D0%BA%D1%80%D0%B5%D1%82%D0%BD%D0%B0%D1%8F_%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0,_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D1%8B_%D0%B8_%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D1%8B_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85 neerc.ifmo.ru/wiki]
* [http://brestprog.by/topics/ brestprog.by]
* [https://ru.algorithmica.org/ ru.algorithmica.org], [http://algorithmica.org/ru/ algorithmica.org/ru], [http://algorithmica.org/tg/ algorithmica.org/tg], [https://wiki.algocode.ru/index.php?title=%D0%A1%D0%BF%D0%B8%D1%81%D0%BE%D0%BA_%D0%B2%D1%81%D0%B5%D1%85_%D0%BA%D0%BE%D0%BD%D1%81%D0%BF%D0%B5%D0%BA%D1%82%D0%BE%D0%B2 wiki.algocode.ru]
* [https://codeforces.com/catalog codeforces.com/catalog]
* [https://usaco.guide usaco.guide]
* [http://www.topcoder.com/community/data-science/data-science-tutorials/ topcoder.com]
Демонстрации:
* [http://visualgo.net/ VisuAlgo]
* [http://www.cs.usfca.edu/~galles/visualization/Algorithms.html Data Structure Visualizations]
Код:
* [http://github.com/indy256/codelibrary indy256's CodeLibrary (GitHub)]
* [http://github.com/ADJA/algos ADJA's Algos (GitHub)]
* [http://algs4.cs.princeton.edu/code/ R. Sedgewick and K. Wayne's Java Algorithms and Clients] ([http://github.com/kevin-wayne/algs4/ GitHub])

== Книги ==
=== Алгоритмы (классические учебники) ===
* Introduction to Algorithms / Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein. — 4th ed. — Cambridge, MA: MIT Press, 2022. — 1312 p. ([http://mitpress.mit.edu/9780262046305/introduction-to-algorithms/ сайт книги])
: Алгоритмы: построение и анализ / Томас Х. Кормен, Чарльз И. Лейзерсон, Рональд Л. Ривест, Клиффорд Штайн. — 3-е изд. — М.: Вильямс, 2013. — 1328 с.
* Sedgewick R., Wayne K. Algorithms / Robert Sedgewick, Kevin Wayne. — 4th ed. — Boston, MA: Addison-Wesley, 2011. — 976 p. ([http://algs4.cs.princeton.edu сайт книги])
: Седжвик Р., Уэйн К. Алгоритмы на Java / Роберт Седжвик, Кевин Уэйн. — 4-е изд. — М.: Вильямс, 2013. — 848 с.
* Skiena S. The Algorithm Design Manual / Steven S. Skiena. — 3rd ed. — Cham: Springer, 2020. — 810 p. ([http://www.algorist.com сайт книги])
: Скиена С. Алгоритмы. Руководство по разработке / Стивен С. Скиена. — 2-е изд. — СПб.: БХВ-Петербург, 2011. — 720 с.

=== Олимпиадное программирование ===
* [https://www.comp.nus.edu.sg/~stevenha/database/Art_of_Programming_Contest_SE_for_uva.pdf Art of Programming Contest / Ed. by A. S. Arefin. — 2nd ed. — Dhaka: Gyankosh Prokashoni, 2006. — 247 p.]
* {{GoodBadge}} [https://github.com/prasadgujar/CompetitiveProgramming/blob/master/book/Competitive%20Programming%203.pdf Halim S., Halim F. Competitive Programming 3 / Steven Halim, Felix Halim. — Raleigh, NC: Lulu, 2013. — 448 p.]
* Halim S., Halim F., Effendy S. Competitive Programming 4. Book 1 / Steven Halim, Felix Halim, Suhendry Effendy. — Lulu, 2020. — 329 p.
* Halim S., Halim F., Effendy S. Competitive Programming 4. Book 2 / Steven Halim, Felix Halim, Suhendry Effendy. — Lulu, 2020. — 352 p.
* {{GoodBadge}} [https://github.com/pllk/cphb/blob/master/book.pdf Laaksonen A. Competitive Programmer’s Handbook / Antti Laaksonen. — 2019. — 300 p.]
* [http://darrenyao.com/usacobook/cpp.pdf Yao D. An Introduction to the USA Computing Olympiad / Darren Yao. — 2020. — 87 p.]
* Долинский М. С. Решение сложных и олимпиадных задач по программированию / М. С. Долинский. — СПб.: Питер, 2006. — 366 с.
* {{GoodBadge}} Лааксонен А. Олимпиадное программирование. / Антти Лааксонен. — 2-е изд. — М.: ДМК Пресс, 2020. — 328 с. {{Comment|Бумажный вариант online-книги того же автора. Порядок глав изменён; добавлены разделы про центроид-декомпозицию, heavy-light-декомпозицию, деревья поиска в глубину, суффиксные массивы, декартовы деревья, оптимизации ДП, параллельный бинпоиск, динамическую связность, FFT, MCMF.}}
* Окулов С. М. Основы программирования / С. М. Окулов. — 4-е изд. — М.: БИНОМ, 2008. — 440 с.
* Окулов С. М. Программирование в алгоритмах / С. М. Окулов. — 3-е изд. — М.: БИНОМ, 2007. — 383 с.
* {{GoodBadge}} Порублев И. Н., Ставровский А. Б. Алгоритмы и программы. Решение олимпиадных задач. — М.: Вильямс, 2007. — 480 с.
* Скиена С. С., Ревилла М. А. Олимпиадные задачи по программированию. Руководство по подготовке к соревнованиям / С. С. Скиена, М. А. Ревилла. — М.: КУДИЦ-ОБРАЗ, 2005. — 416 с.

=== Олимпиадное программирование (более сложные темы) ===
* [https://kostka.dev/sp/spbook.pdf Kostka B. Sports Programming in Practice / Bartosz Kostka — University of Wroclaw, 2021. — 234 p.]
* [https://peltorator.ru/cp_book.pdf Горбачёв Е. А. Спортивное программирование. Алгоритмы и структуры данных / Е. А. Горбачёв — 2021. — 136 с.]

=== Сборники задач ===
* Durr C., Vie J. Competitive Programming in Python / Christoph Durr, Jill-Jenn Vie. — Cambridge University Press, 2021. — 264 p.
* Wu Y., Wang J. Algorithm Design Practice for Collegiate Programming Contests and Education / Yonghui Wu, Jiande Wang. — CRC Press, 2018. — 706 p.
* Wu Y., Wang J. Data Structure Practice for Collegiate Programming Contests and Education / Yonghui Wu, Jiande Wang. — CRC Press, 2016. — 512 p.
* [http://acmp.ru/download/book.pdf Алексеев А. В., Беляев С. Н. Подготовка школьников к олимпиадам по информатике с использованием веб-сайта / А. В. Алексеев, С. Н. Беляев. — Ханты-Мансийск: РИО ИРО, 2008. — 284 с.]
* Брудно А. Л., Каплан Л. И. Московские олимпиады по программированию / Под ред. Б. Н. Наумова. — 2-е изд. — М.: Наука, 1990. — 208 с.
* Кирюхин В. М., Окулов С. М. Методика решения задач по информатике. Международные олимпиады / В. М. Кирюхин, С. М. Окулов. — М.: БИНОМ, 2007. — 600 с.
* [https://www.olympiads.ru/books/mskolymp/mosinformatolymp.pdf Московские олимпиады по информатике / Под ред. Е. В. Андреевой, В. М. Гуровица и В. А. Матюхина. — М.: МЦНМО, 2006. — 256 с.]
* [https://www.olympiads.ru/moscow/sbory/sbory2.pdf Московские учебно тренировочные сборы по информатике. Весна–2006 / Под ред. В. М. Гуровица. — М.: МЦНМО, 2007. — 194 с.]
* Меньшиков Ф. В. Олимпиадные задачи по программированию / Ф. В. Меньшиков. — СПб: Питер, 2006. — 315 с.
* [http://onzi.narod.ru Особенности национальных задач по информатике / В. И. Беров, А. В. Лапунов, В. А. Матюхин, А. Е. Пономарёв. — Киров: Триада-С, 2000. — 160 с.]
* [http://www.mccme.ru/free-books/shen/shen-progbook.pdf Шень А. Программирование: теоремы и задачи / А. Шень. — 6-е изд. — М.: МЦНМО, 2017. — 320 с.]

=== Литература по темам ===
==== Алгоритмы ====
* [http://jeffe.cs.illinois.edu/teaching/algorithms Erickson J. Algorithms / Jeff Erickson. — Urbana, IL: University of Illinois at Urbana-Champaign, 2019. — 472 p.]
* [http://www.algorithmsilluminated.org Roughgarden T. Algorithms Illuminated]:
:* Roughgarden T. Algorithms Illuminated. Part 1: The Basics / Tim Roughgarden. — San-Francisco, CA: Soundlikeyourself Publishing, 2017. — 216 p.
:* Roughgarden T. Algorithms Illuminated. Part 2: Graph Algorithms and Data Structures / Tim Roughgarden. — San-Francisco, CA: Soundlikeyourself Publishing, 2018. — 221 p.
:* Roughgarden T. Algorithms Illuminated. Part 3: Greedy Algorithms and Dynamic Programming / Tim Roughgarden. — New York, NY: Soundlikeyourself Publishing, 2019. — 229 p.
:* Roughgarden T. Algorithms Illuminated. Part 4: Algorithms for NP-Hard Problems / Tim Roughgarden. — New York, NY: Soundlikeyourself Publishing, 2020. — 271 p.
* Sedgewick R., Flajolet P. An Introduction to the Analysis of Algorithms / Robert Sedgewick, Philippe Flajolet. — 2th ed. — Boston, MA: Addison-Wesley, 2013. — 592 p.
* Ахо А., Хопкрофт Д., Ульман Д. Построение и анализ вычислительных алгоритмов / А. Ахо, Дж. Хопкрофт, Дж. Ульман. — М.: Мир, 1979. — 536 с.
* Ахо А., Хопкрофт Д., Ульман Д. Структуры данных и алгоритмы / Альфред В. Ахо, Джон Хопкрофт, Джеффри Д. Ульман. — М.: Вильямс, 2000. — 384 с.
* Бабенко М. А., Левин М. В. Введение в теорию алгоритмов и структур данных / М. А. Бабенко, М. В. Левин. — М.: МЦНМО, 2016. — 144 с. {{Comment|Темы: динамические массивы, амортизационный анализ; сортировка выбором, Ω-оценка для сортировок сравнением, mergesort, quicksort, порядковая статистика (за O(N) в среднем и худшем случае); линейный поиск, бинарный поиск, деревья поиска, splay-деревья; кучи, heapsort, k-ичные кучи, сливаемые кучи (leftist и skew), персистентность, декартовы деревья; хеширование, разрешение коллизий (цепочки, открытая адресация, двойное хеширование), универсальное хеширование, совершенное хеширование, фильтр Блюма; DSU, DSU с отменами; RMQ, деревья отрезков, разреженные таблицы, LCA, сведение LCA к RMQ и наоборот, RMQ и LCA за (O(N), O(1)); динамическое программирование, НВП, перемножение цепочки матриц, принципы ДП.}}
* Вирт Н. Алгоритмы и структуры данных / Н. Вирт. — М.: Мир, 1989. — 360 с.
* [http://alexanderskulikov.github.io/files/algorithms_href.pdf Дасгупта С., Пападимитриу Х., Вазирани У. Алгоритмы / С. Дасгупта, Х. Пападимитриу, У. Вазирани. — М.: МЦНМО, 2014. — 320 с.]
* Клейнберг Дж., Тардос Е. Алгоритмы: разработка и применение / Джон Клейнберг, Ева Тардос. — СПб.: Питер, 2016. — 800 с. ([http://www.cs.princeton.edu/~wayne/kleinberg-tardos слайды лекций])
* Левитин А. В. Алгоритмы: введение в разработку и анализ / Ананий В. Левитин. — М.: Вильямс, 2006. — 576 с.
* Макконнелл Дж. Анализ алгоритмов. Вводный курс / Дж. Макконнелл. — М.: Техносфера, 2002. — 304 с.
* Стивенс Р. Алгоритмы. Теория и практическое применение / Род Стивенс. — М.: Э, 2016. — 544 с.

==== Структуры данных ====
* Brass P. Advanced Data Structures / Peter Brass. — Cambridge: Cambridge University Press, 2008. — 472 pp.
* [https://opendatastructures.org Morin P. Open Data Structures / Par Morin. — Edmonton, AB: Athabasca University Press, 2013. — 344 pp.]

==== Дискретная математика ====
* Асанов М. О. Баранский В. А., Расин В. В. Дискретная математика: графы, матроиды, алгоритмы / М. О. Асанов, В. А. Баранский, В. В. Расин. — 3-е изд. — СПб.: Лань, 2020. — 364 с.
* Грэхем Р., Кнут Д., Паташник О. Конкретная математика. Основание информатики / Р. Грэхем, Д. Кнут, О. Паташник. — М.: Мир, 1998. — 703 с.
* Кук Д., Бейз Г. Компьютерная математика / Д. Кук, Г. Бейз. — М.: Наука, 1990. — 384 с.
* Новиков Ф. А. Дискретная математика для программистов / Ф. А. Новиков. — 2-е изд. — СПб.: Питер. 2007. — 364 с.
* Окулов С. М. Дискретная математика. Теория и практика решения задач по информатике / С. М. Окулов. — 2-е изд. — М.: БИНОМ, 2012. — 422 с.
* Хаггарти Р. Дискретная математика для программистов / Р. Хаггарти — М.: Техносфера, 2004. — 320 с.

==== Динамическое программирование ====
* Kellerer H., Pferschy U., Pisinger D. Knapsack Problems / Hans Kellerer, Ulrich Pferschy, David Pisinger. — Berlin: Springer-Verlag, 2004. — 568 p.
* [http://www.or.deis.unibo.it/kp/KnapsackProblems.pdf Martello S., Toth P. Knapsack problems / Silvano Martello, Paolo Toth. — New York, NY: Wiley, 1990. — 308 p.]
* Окулов С. М., Пестов О. А. Динамическое программирование / С. М. Окулов, О. А. Пестов. — М.: Бином, 2012. — 296 с.

==== Вычислительная геометрия ====
* [http://vlecomte.github.io/cp-geo.pdf Lecomte V. Handbook of geometry for competitive programmers / Victor Lecomte. — 2018. — 122 p.]
* {{GoodBadge}} [http://e-maxx.ru/bookz/files/andreeva.pdf Андреева Е. В., Егоров Ю. Е. Вычислительная геометрия на плоскости / Е. В. Андреева, Ю. Е. Егоров. // Информатика. — 2002. — №39, 40, 43, 44]
* Берг М. Вычислительная геометрия. Алгоритмы и приложения / М. Берг, О. Чеонг, М. Кревельд, М. Овермарс. — М.: ДМК-Пресс, 2016. — 438 с.
* Препарата Ф., Шеймос М. Вычислительная геометрия / Ф. Препарата, М. Шеймос. — М.: Мир, 1989. — 478 с.
* [https://server.179.ru/tasks/python/2014b1/minimum.pdf Теоретический минимум по по вычислительной геометрии для групп параллели B’. — Летняя компьютерная школа, 2010 г. — 6 с.]

==== Теория графов ====
* Кристофидес Н. Теория графов. Алгоритмический подход / Н. Кристофидес. — М.: Мир, 1978. — 432 с.
* Оре О. Графы и их применение / О. Оре. — М. Мир, 1965. — 175 с.
* Оре О. Теория графов / О. Оре. — 2-е изд. — М. Наука, 1980. — 336 с.
* Харари Ф. Теория графов / Под ред. Г. П. Гаврилова. — М.: Едиториал УРСС, 2003. — 296 с.

==== Алгоритмы на строках ====
* Гасфилд Д. Строки, деревья и последовательности в алгоритмах / Дэн Гасфилд. — СПб: Невский диалект; БХВ-Петербург, 2003. — 654 с.
* Смит Б. Методы и алгоритмы вычислений на строках / Билл Смит. — М.: Вильямс, 2006. — 496 с.

== Периодические издания и сборники ==
* Журнал [http://ioinformatics.org/page/ioi-journal-contents/3 Olympiads in Informatics]
: [http://ioinformatics.org/page/ioi-journal-index/44#volume1 2007], [http://ioinformatics.org/page/ioi-journal-index/44#volume2 2008], [http://ioinformatics.org/page/ioi-journal-index/44#volume3 2009], [http://ioinformatics.org/page/ioi-journal-index/44#volume4 2010], [http://ioinformatics.org/page/ioi-journal-index/44#volume5 2011], [http://ioinformatics.org/page/ioi-journal-index/44#volume6 2012], [http://ioinformatics.org/page/ioi-journal-index/44#volume7 2013], [http://ioinformatics.org/page/ioi-journal-index/44#volume8 2014], [http://ioinformatics.org/page/ioi-journal-index/44#volume9 2015], [http://ioinformatics.org/page/ioi-journal-index/44#volume10 2016], [http://ioinformatics.org/page/ioi-journal-index/44#volume10si 2016+], [http://ioinformatics.org/page/ioi-journal-index/44#volume11 2017], [http://ioinformatics.org/page/ioi-journal-index/44#volume11si 2017+], [http://ioinformatics.org/page/ioi-journal-index/44#volume12 2018], [http://ioinformatics.org/page/ioi-journal-index/44#volume13 2019], [http://ioinformatics.org/page/ioi-journal-index/44#volume14 2020], [http://ioinformatics.org/page/ioi-journal-index/44#volume15 2021], [http://ioinformatics.org/page/ioi-journal-index/44#volume16 2022], [http://ioinformatics.org/page/ioi-journal-index/44#volume17 2023], [http://ioinformatics.org/page/ioi-journal-index/44#volume18 2024]
* Сборники Зимней школы по программированию ХНУРЭ
: [http://ws.kh.ua/media/sbornik/Sbornik2008.pdf 2008], [http://ws.kh.ua/media/sbornik/Sbornik2009.pdf 2009], [http://ws.kh.ua/media/sbornik/Sbornik2010.pdf 2010], [http://ws.kh.ua/media/sbornik/Sbornik2011.pdf 2011], [http://ws.kh.ua/media/sbornik/Sbornik2012.pdf 2012], [http://ws.kh.ua/media/sbornik/Sbornik2013.pdf 2013], [http://ws.kh.ua/media/sbornik/Sbornik2014.pdf 2014]

Быстрое возведение в степень

2025-02-16T13:25:18Z

Ctrlalt:

== Базовая реализация ==

long long binPow(long long x, long long p, long long mod) {
if (!p)
return 1 % mod;
if (p % 2)
return binPow(x, p - 1, mod) * x % mod;
long long r = binPow(x, p / 2, mod);
return r * r % mod;
}

== Вычисление степеней, превышающих размер long long ==

Если x и mod взаимно просты, то binPow(x, p, mod) == binPow(x, p % phi(mod), mod), где phi — функция Эйлера.

Если x и mod не взаимно просты, но p ≥ log2(mod), то binPow(x, p, mod) == binPow(x, p % phi(mod) + phi(mod), mod).

long long phi(long long n) {
long long res = n;
for (long long d = 2; d * d <= n; d++) {
if (n % d == 0) {
while (n % d == 0)
n /= d;
res -= res / d;
}
}
if (n > 1)
res -= res / n;
return res;
}

== Возведение в степень матриц ==

const long long MOD = 1e9 + 7;

using Matrix = vector<vector<long long>>;

Matrix identityMatrix(int size) {
Matrix res(size, vector<long long>(size));
for (int i = 0; i < res.size(); i++)
res[i][i] = 1;
return res;
}

Matrix operator * (const Matrix &a, const Matrix &b) {
Matrix res(a.size(), vector<long long>(b[0].size()));
for (int y = 0; y < res.size(); y++)
for (int x = 0; x < res[0].size(); x++)
for (int i = 0; i < a[0].size(); i++)
res[y][x] = (res[y][x] + a[y][i] * b[i][x] % MOD) % MOD;
return res;
}

Matrix pow(const Matrix &m, long long p) {
if (!p)
return identityMatrix(m.size());
if (p % 2)
return pow(m, p - 1) * m;
Matrix r = pow(m, p / 2);
return r * r;
}

== Ссылки ==
* [http://e-maxx.ru/algo/binary_pow E-maxx — Бинарное возведение в степень]
* [https://cp-algorithms.com/algebra/binary-exp.html cp-algorithms.com — Binary Exponentiation]
* [https://cp-algorithms.com/algebra/phi-function.html#application cp-algorithms.com — Euler's totient function application in Euler's theorem]
* [http://algorithmica.org/tg/number-theory algorithmica.org — Теория чисел]
* [http://codeforces.com/blog/entry/43225 Codeforces — Cool tricks using Matrix Exponential]
* [http://habr.com/ru/post/148901 Habr — Используем быстрое возведение матриц в степень для написания очень быстрого интерпретатора простого языка программирования]
* [http://habr.com/ru/post/236689 Habr — Автоматическая оптимизация алгоритмов с помощью быстрого возведения матриц в степень]

[[Category:Арифметические алгоритмы]]

Категория:Учебный курс «Алгоритмы и структуры данных»

2025-01-05T21:02:41Z

Ctrlalt:

{|
|
;Сортировка и поиск
:
:* [[Асимптотический анализ алгоритмов]]
:* [[Анализ рекуррентных соотношений. Мастер-теорема]]
: Простейшие алгоритмы сортировки
:* 📄 [[Сортировка выбором]]
:* 📄 [[Сортировка вставками]]
: Улучшенные алгоритмы сортировки
:* 📄 [[Сортировка слиянием]]
:* 📄 [[Быстрая сортировка]]
: Сортировка за линейное время
:* [[Сортировка подсчётом]]
:* [[Поразрядная сортировка]]
: Алгоритмы поиска
:* [[Бинарный поиск]]
:* [[Тернарный поиск]]
: Применение сортировки
:* [[Сканирующая прямая]]
;Структуры данных
:
: Базовые структуры и абстрактные типы данных
:* [[Динамический массив]]
:* [[Связный список]]
:* [[Стек]]
:* [[Очередь]]
:* [[Очередь с приоритетами]]
:* [[Множество. Реализация на битовых векторах]]
:* [[Множество и словарь. Реализация на деревьях поиска]]
:* [[Множество и словарь. Реализация на хеш-таблицах]]
:* [[Система непересекающихся множеств]]
: Балансирующиеся деревья
:* 📄 [[АВЛ-дерево]]
:* 📄 [[Красно-чёрное дерево]]
:* [[Декартово дерево]]
:* 📄 [[Расширения декартова дерева]]
: Обработка запросов на отрезках
:* 📄 [[Префиксные суммы]]
:* [[Дерево Фенвика]]
:* 📄 [[Дерево отрезков]]
:* 📄 [[Sparse table]]
:* Sqrt-декомпозиция
:* [[Алгоритм Мо]]
|width=450px|
;Алгоритмы для работы с графами
:
:* [[Основные определения. Представление графов]]
: Поиск в глубину и его приложения
:* 📄 [[Поиск в глубину]]''O(V+E)''
:* 📄 [[Компоненты связности]]
:* 📄 [[Циклы в графе. Двудольность]]
:* 📄 [[Топологическая сортировка]]
:* 📄 [[Компоненты сильной связности. Алгоритм Косараю-Шарира|Компоненты сильной связности]]
:* 📄 [[Мосты. Компоненты рёберной двусвязности|Мосты]]
:* 📄 [[Точки сочленения. Компоненты вершинной двусвязности|Точки сочленения]]
:* 📄 [[Эйлеров цикл. Эйлеров путь]]
: Кратчайшие пути из одной вершины
:* 📄 [[Поиск в ширину]]''O(V+E)''
:* 📝 [[Алгоритм Дейкстры]]''O(V2+E) или O(ElogV)''
:* 📄 [[Алгоритм A*]]
:* [[Алгоритм Форда-Беллмана]]''O(VE)''
:* [[Кратчайшие пути в ациклических орграфах]]''O(V+E)''
: Кратчайшие пути между всеми парами вершин
:* 📄 [[Алгоритм Флойда]]''O(V3)''
:* [[Алгоритм Джонсона]]''O(VElogV)''
: Минимальное остовное дерево
:* 📝 [[Алгоритм Краскала]]''O(ElogV)''
:* 📄 [[Алгоритм Прима]]''O(V2+E) или O(ElogV)''
: Максимальный поток
:* 📄 [[Алгоритм Форда-Фалкерсона]]''O(Flow×E)''
:* 📄 [[Алгоритм Эдмондса-Карпа]]''O(VE2)''
:* 📄 [[Алгоритм Диница]]''O(V2E)''
:* 📝 [[Максимальный поток минимальной стоимости]]
:* [[Применения максимального потока]]
: Максимальное паросочетание
:* 📄 [[Алгоритм Куна]]''O(VE)''
:* 📄 [[Минимальное вершинное покрытие, максимальное независимое множество]]
: Наименьший общий предок
:* 📄 [[Метод двоичного подъёма]]''O(NlogN), O(logN)''
:* [[Сведение LCA к RMQ и RMQ к LCA]]
:* [[Алгоритм Тарьяна (offline)]]''O(N), O(1)''
: Декомпозиции деревьев
:* 📝 [[Heavy-light-декомпозиция]]
|
;Полный перебор и методы его оптимизации
:
:* [[Полный перебор]]
:* [[Два указателя]]
:* Meet in the middle
:* [[Жадные алгоритмы]]
: Динамическое программирование
:* [[Динамическое программирование]]
:* [[Задача о рюкзаке и связанные задачи]]
:* [[Оптимизации динамического программирования]]
;Математика
:
: Теория чисел
:* 📄 [[НОД. Алгоритм Евклида]]
:* 📄 [[Простые числа. Решето Эратосфена]]
:* 📄 [[Быстрое возведение в степень]]
:* 📄 [[Модульная арифметика]]
:* 📝 [[Длинная арифметика]]
:* 📄 [[Метод Гаусса]]
:* 📄 [[Быстрое преобразование Фурье]]
: Комбинаторика
:* 📄 [[Подсчёт и перечисление комбинаторных объектов]]
:* [[Получение номера по объекту и объекта по номеру]]
:* [[Перестановки]]
: Теория игр
:* [[Игры]]
: Геометрия
:* 📝 [[Геометрические примитивы]]
:* 📄 [[Выпуклая оболочка]]

; Алгоритмы для работы со строками
:
:* 📄 [[Хеширование строк]]
:* 📄 [[Префикс-функция]]
:* 📄 [[Алгоритм Ахо-Корасик]]
:* 📄 [[Z-функция]]
:* 📄 [[Алгоритм Манакера]]
:* 📄 [[Суффиксный массив]]
: Разбор выражений
:* 📝 [[Наивный рекурсивный разбор]]
:* 📄 [[Алгоритм сортировочной станции]]

; Разное
:
:* 📄 [[Часто используемые фрагменты]]
|}

''© В. А. Фолунин, 2012–2025''

Хеширование строк

2024-12-16T15:33:33Z

Ctrlalt:

hi = s0xn - 1 + s1xn - 2 + ... + sn - 2x + sn - 1.

struct Hasher {
long long x, mod;
vector<long long> p, h;

Hasher(const string &s, long long x = 31, long long mod = 1e9 + 7) : x(x), mod(mod) {
p.resize(s.size());
h.resize(s.size());

p[0] = 1;
h[0] = s[0] - 'a' + 1;

for (int i = 1; i < s.size(); i++) {
p[i] = p[i - 1] * x % mod;
h[i] = (h[i - 1] * x % mod + s[i] - 'a' + 1) % mod;
}
}

long long getHash(int l, int r) {
long long res = h[r];
if (l)
res = (res - p[r - l + 1] * h[l - 1] % mod + mod) % mod;
return res;
}
};

struct DoubleHasher {
Hasher h1, h2;

DoubleHasher(const string &s) : h1(s), h2(s, 29, 1e9 + 9) {}

pair<long long, long long> getHash(int l, int r) {
return { h1.getHash(l, r), h2.getHash(l, r) };
}
};

{| width="100%"
| width=50% |
hi = s0 + s1x + s2x2 + ... + sn - 1xn - 1.

Для выравнивания хеши различных подстрок домножаются на xn - 1 - L.

struct Hasher {
long long x = 31, mod = 1e9 + 7;
vector<long long> p, h;

Hasher(const string &s) {
p.resize(s.size());
h.resize(s.size());

p[0] = 1;
h[0] = s[0] - 'a' + 1;

for (int i = 1; i < s.size(); i++) {
p[i] = p[i - 1] * x % mod;
h[i] = (h[i - 1] + p[i] * (s[i] - 'a' + 1) % mod) % mod;
}
}

long long getHash(int l, int r) {
long long res = h[r];
if (l)
res = (res - h[l - 1] + mod) % mod;
res = res * p[p.size() - 1 - l] % mod;
return res;
}
};

Этот способ непригоден для сравнения участков двух строк разной длины. В данном случае хеш более левого участка следует домножать на x|L1 - L2|.

| width="10px" |  
| width=50% |
hi = s0 + s1x + s2x2 + ... + sn - 1xn - 1.

Для выравнивания хеши различных подстрок домножаются на (x-1)L.

struct Hasher {
long long x = 31, {{Changed|1=xi = 129032259,}} mod = 1e9 + 7;
vector<long long> p, {{Changed|pi,}} h;

Hasher(const string &s) {
p.resize(s.size());
{{Changed|pi.resize(s.size());}}
h.resize(s.size());

p[0] = {{Changed|1=pi[0] = }} 1;
h[0] = s[0] - 'a' + 1;

for (int i = 1; i < s.size(); i++) {
p[i] = p[i - 1] * x % mod;
{{Changed|1=pi[i] = pi[i - 1] * xi % mod;}}
h[i] = (h[i - 1] + p[i] * (s[i] - 'a' + 1) % mod) % mod;
}
}

long long getHash(int l, int r) {
long long res = h[r];
if (l) {
res = (res - h[l - 1] + mod) % mod;
{{Changed|1=res = (res * pi[l]) % mod}};
}
return res;
}
};
|}

== Ссылки ==
Теория:
* [http://e-maxx.ru/algo/string_hashes e-maxx.ru — Алгоритмы хэширования в задачах на строки]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D0%BF%D0%BE%D0%B4%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B8_%D0%B2_%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B5_%D1%81_%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC_%D1%85%D0%B5%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F._%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%A0%D0%B0%D0%B1%D0%B8%D0%BD%D0%B0-%D0%9A%D0%B0%D1%80%D0%BF%D0%B0 neerc.ifmo.ru — Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D0%BD%D0%B0%D0%B8%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%B5%D0%B9_%D0%BE%D0%B1%D1%89%D0%B5%D0%B9_%D0%BF%D0%BE%D0%B4%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B8_%D0%B4%D0%B2%D1%83%D1%85_%D1%81%D1%82%D1%80%D0%BE%D0%BA_%D1%81_%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC_%D1%85%D0%B5%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F neerc.ifmo.ru — Поиск наибольшей общей подстроки двух строк с использованием хеширования]
* [https://ru.algorithmica.org/cs/hashing/polynomial/ ru.algorithmica.org — Полиномиальное хеширование]
* [http://habrahabr.ru/post/142589/ habrahabr.ru — Полиномиальные хеши и их применение]
* [http://codeforces.com/blog/entry/4898 codeforces.com — Anti-hash test]
* [http://codeforces.com/blog/entry/60445 codeforces.com — Полиномиальное хеширование + разбор интересных задач]
* [https://blog.algoprog.ru/hash-no-multiply/ Калинин П. — Про хеширование без домножения]
* [https://usaco.guide/gold/string-hashing?lang=cpp usaco.guide — String Hashing]
Код:
* [https://github.com/indy256/codelibrary/blob/master/cpp/strings/hashing.cpp codelibrary/cpp/strings/hashing.cpp]
* [https://github.com/ADJA/algos/blob/master/Strings/Hashing.cpp algos/Strings/Hashing.cpp]
Задачи:
* [[:Категория: Задачи: Хеширование строк|Задачи: Хеширование строк]]

[[Категория:Строки]]

Z-функция

2024-10-25T11:26:18Z

Ctrlalt:

Z-функция строки s — массив длин максимальных подстрок, совпадающих с началом всей строки, для каждого индекса i.

vector<int> zFunction(const string &s) {
vector<int> z(s.size());

int blockL = 0, blockR = 0;
for (int i = 1; i < s.size(); i++) {
int blockLen = 0;

if (i <= blockR)
blockLen = min(z[i - blockL], blockR - i + 1);

while (i + blockLen < s.size() && s[i + blockLen] == s[blockLen])
blockLen++;

z[i] = blockLen;

if (blockR < i + blockLen - 1) {
blockL = i;
blockR = i + blockLen - 1;
}
}

return z;
}

== Ссылки ==
* [https://codeforces.com/edu/course/2/lesson/3 Codeforces EDU — Z-функция]
* [http://e-maxx.ru/algo/z_function E-maxx — Z-функция строки]
* [http://neerc.ifmo.ru/wiki/index.php?title=Z-%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F neerc.ifmo.ru/wiki — Z-функция]
* [https://brestprog.by/topics/zfunction/ Brestprog — Z-функция]
* [https://algorithmica.org/ru/string-searching Algorithmica — Префикс- и Z-функция]

[[Category: Строки]]

Геометрические примитивы

2024-08-15T23:48:10Z

Ctrlalt: /* Точная проверка на пересечение отрезков с целыми координатами */

== Точка ==

#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;

const double EPS = 1e-9;

struct Point {
double x, y;

Point() {}

Point(double x, double y) : x(x), y(y) {}

Point(const Point &a, const Point &b) : x(b.x - a.x), y(b.y - a.y) {}

bool operator == (const Point &that) const {
return abs(x - that.x) < EPS && abs(y - that.y) < EPS;
}

bool operator < (const Point &that) const {
if (abs(x - that.x) >= EPS)
return x < that.x;
return y + EPS < that.y;
}

double angle() const {
double a = atan2(y, x);
if (a < -EPS)
a += 2 * acos(-1.0);
return a;
}

double length() const {
return hypot(x, y);
}

double distanceTo(const Point &that) const {
return hypot(x - that.x, y - that.y);
}

Point operator + (const Point &that) const {
return Point(x + that.x, y + that.y);
}

Point operator - (const Point &that) const {
return Point(x - that.x, y - that.y);
}

Point operator * (double k) const {
return Point(x * k, y * k);
}

Point setLength(double newLength) const {
double k = newLength / length();
return Point(x * k, y * k);
}

Point rotate(double angle) {
return Point(x * cos(angle) - y * sin(angle), y * cos(angle) + x * sin(angle));
}

double dotProduct(const Point &that) const {
return x * that.x + y * that.y;
}

double angleTo(const Point &that) const {
return acos(max(-1.0, min(1.0, dotProduct(that) / (length() * that.length()))));
}

bool isOrthogonalTo(const Point &that) const {
return abs(dotProduct(that)) < EPS;
}

Point orthogonalPoint() const {
return Point(-y, x);
}

double crossProduct(const Point &that) const {
return x * that.y - y * that.x;
}

bool isCollinearTo(const Point &that) const {
return abs(crossProduct(that)) < EPS;
}

friend istream &operator >> (istream &in, Point &p) {
return in >> p.x >> p.y;
}

friend ostream &operator << (ostream &out, const Point &p) {
return out << p.x << " " << p.y;
}
};

== Прямая ==

struct Line {
double a, b, c;

Line() {}

Line(double a, double b, double c) : a(a), b(b), c(c) {}

Line(const Point &p1, const Point &p2) : a(p1.y - p2.y), b(p2.x - p1.x), c(p1.x * p2.y - p2.x * p1.y) {}

static Line LineByVector(const Point &p, const Point &v) {
return Line(p, p + v);
}

static Line LineByNormal(const Point &p, const Point &n) {
return LineByVector(p, n.orthogonalPoint());
}

Point normal() const {
return Point(a, b);
}

Line orthogonalLine(const Point &p) const {
return LineByVector(p, normal());
}

Line parallelLine(const Point &p) const {
return LineByNormal(p, normal());
}

Line parallelLine(double distance) const {
Point p = (abs(a) < EPS ? Point(0, -c / b) : Point(-c / a, 0));
Point p1 = p + normal().setLength(distance);
return LineByNormal(p1, normal());
}

int side(const Point &p) const {
double r = a * p.x + b * p.y + c;
if (abs(r) < EPS)
return 0;
else
return r > 0 ? 1 : -1;
}

double distanceTo(const Point &p) const {
return abs(a * p.x + b * p.y + c) / sqrt(a * a + b * b);
}

bool has(const Point &p) const {
return distanceTo(p) < EPS;
}

double distanceTo(const Line &that) const {
if (normal().isCollinearTo(that.normal())) {
Point p = (abs(a) < EPS ? Point(0, -c / b) : Point(-c / a, 0));
return that.distanceTo(p);
} else
return 0;
}

bool intersectsWith(const Line &that) const {
return distanceTo(that) < EPS;
}

Point intersection(const Line &that) const {
double d = a * that.b - b * that.a;
double dx = -c * that.b - b * -that.c;
double dy = a * -that.c - -c * that.a;
return Point(dx / d, dy / d);
}

friend istream &operator >> (istream &in, Line &l) {
return in >> l.a >> l.b >> l.c;
}

friend ostream &operator << (ostream &out, const Line &l) {
return out << l.a << " " << l.b << " " << l.c;
}
};

== Луч ==

struct Ray {
Point p1, p2;
double a, b, c;

Ray(const Point &p1, const Point &p2) : p1(p1), p2(p2), a(p1.y - p2.y), b(p2.x - p1.x), c(p1.x * p2.y - p2.x * p1.y) {}

double distanceTo(const Point &p) const {
if (Point(p1, p).dotProduct(Point(p1, p2)) >= -EPS)
return abs(a * p.x + b * p.y + c) / sqrt(a * a + b * b);
else
return p1.distanceTo(p);
}

bool has(const Point &p) const {
return distanceTo(p) < EPS;
}

double distanceTo(const Ray &that) const {
Line l(a, b, c), thatL(that.a, that.b, that.c);
if (l.intersectsWith(thatL)) {
Point p = l.intersection(thatL);
if (has(p) && that.has(p))
return 0;
}
return min(distanceTo(that.p1), that.distanceTo(p1));
}

bool intersectsWith(const Ray &that) const {
return distanceTo(that) < EPS;
}
};

== Отрезок ==

struct Segment {
Point p1, p2;
double a, b, c;

Segment(const Point &p1, const Point &p2) : p1(p1), p2(p2), a(p1.y - p2.y), b(p2.x - p1.x), c(p1.x * p2.y - p2.x * p1.y) {}

double distanceTo(const Point &p) const {
if (Point(p1, p).dotProduct(Point(p1, p2)) >= -EPS && Point(p2, p).dotProduct(Point(p2, p1)) >= -EPS)
return abs(a * p.x + b * p.y + c) / sqrt(a * a + b * b);
else
return min(p1.distanceTo(p), p2.distanceTo(p));
}

bool has(const Point &p) const {
return distanceTo(p) < EPS;
}

double distanceTo(const Segment &that) const {
Line l(a, b, c), thatL(that.a, that.b, that.c);
if (l.intersectsWith(thatL)) {
Point p = l.intersection(thatL);
if (has(p) && that.has(p))
return 0;
}
return min(min(distanceTo(that.p1), distanceTo(that.p2)), min(that.distanceTo(p1), that.distanceTo(p2)));
}

bool intersectsWith(const Segment &that) const {
return distanceTo(that) < EPS;
}
};

== Многоугольник ==

struct Polygon {
vector<Point> points;

void addPoint(const Point &p) {
points.push_back(p);
}

bool has(const Point &p) const {
bool pos = 0, neg = 0;
for (int i = 0; i < points.size(); i++) {
const Point &a = points[i], &b = points[(i + 1) % points.size()];
Point ab(a, b), ap(a, p);
double cross = ab.crossProduct(ap);
pos |= cross > EPS;
neg |= cross < -EPS;
}
return !pos || !neg;
}

bool isConvex() {
bool pos = 0, neg = 0;
for (int i = 0; i < points.size(); i++) {
const Point &a = points[i], &b = points[(i + 1) % points.size()], &c = points[(i + 2) % points.size()];
Point ab(a, b), ac(a, c);
double cross = ab.crossProduct(ac);
pos |= cross > EPS;
neg |= cross < -EPS;
}
return !pos || !neg;
}

double perimeter() const {
double p = 0;
for (int i = 0; i < points.size(); i++)
p += points[i].distanceTo(points[(i + 1) % points.size()]);
return p;
}

double area() const {
double s = 0;
for (int i = 0; i < points.size(); i++)
s += points[i].crossProduct(points[(i + 1) % points.size()]);
return abs(s) / 2;
}
};

== Точная проверка на пересечение отрезков с целыми координатами ==
struct Point {
long long x, y;

Point() {}

Point(const Point &a, const Point &b) : x(b.x - a.x), y(b.y - a.y) {}

long long crossProduct(const Point &that) const {
return x * that.y - y * that.x;
}

friend istream &operator >> (istream &in, Point &p) {
return in >> p.x >> p.y;
}
};

struct Segment {
Point p1, p2;

Segment(const Point &p1, const Point &p2) : p1(p1), p2(p2) {}

bool intersectsWith(const Segment &that) const {
long long abx1 = min(p1.x, p2.x), abx2 = max(p1.x, p2.x);
long long cdx1 = min(that.p1.x, that.p2.x), cdx2 = max(that.p1.x, that.p2.x);
if (max(abx1, cdx1) > min(abx2, cdx2))
return 0;

long long aby1 = min(p1.y, p2.y), aby2 = max(p1.y, p2.y);
long long cdy1 = min(that.p1.y, that.p2.y), cdy2 = max(that.p1.y, that.p2.y);
if (max(aby1, cdy1) > min(aby2, cdy2))
return 0;

Point ab(p1, p2), ac(p1, that.p1), ad(p1, that.p2);
long long abc = ab.crossProduct(ac), abd = ab.crossProduct(ad);
if (abc > 0 && abd > 0 || abc < 0 && abd < 0)
return 0;

Point cd(that.p1, that.p2), ca(that.p1, p1), cb(that.p1, p2);
long long cda = cd.crossProduct(ca), cdb = cd.crossProduct(cb);
if (cda > 0 && cdb > 0 || cda < 0 && cdb < 0)
return 0;

return 1;
}

friend istream &operator >> (istream &in, Segment &s) {
return in >> s.p1 >> s.p2;
}
};

== Ссылки ==
Теория:
* [http://e-maxx.ru/bookz/files/andreeva.pdf Андреева Е. В., Егоров Ю. Е. Вычислительная геометрия на плоскости / Е. В. Андреева, Ю. Е. Егоров. // Информатика. — 2002. — №39, 40, 43, 44]
* [http://maratona.ic.unicamp.br/MaratonaVerao2017/documents/geom.pdf Ахмедов М. Geometry, stereometry and spherical geometry]
* [http://e-maxx.ru/algo/segments_intersection_checking E-maxx — Проверка двух отрезков на пересечение]
Задачи:
* [http://codeforces.com/gym/100168 Codeforces 100168 — 2012-2013 Тренировка СПбГУ C #8. Геометрия. База.]
* [[:Категория:Задачи: Геометрия|Задачи: Геометрия]]

[[Category: Геометрия]]

Геометрические примитивы

2024-08-15T23:47:26Z

Ctrlalt: /* Точная проверка на пересечение отрезков с целыми координатами */

Простые числа. Решето Эратосфена

2024-08-14T22:37:47Z

Ctrlalt:

===Проверка числа на простоту, O(sqrt(N))===
{| width="100%"
| width=50% |
bool isPrime(int n) {
if (n < 2)
return 0;

for (long long d = 2; d * d <= n; d++)
if (n % d == 0)
return 0;

return 1;
}

| width="10px" |  
| width=50% |
bool isPrime(int n) {
if (n < 2)
return 0;

static vector<int> primes = getPrimes(1e5);
for (int i = 0; 1LL * primes[i] * primes[i] <= n; i++)
if (n % primes[i] == 0)
return 0;

return 1;
}
|}

===Получение списка делителей числа, O(sqrt(N))===
{| width="100%"
| width=50% |
vector<int> getDivisors(int n) {
vector<int> divisors;

for (long long d = 1; d * d <= n; d++) {
if (n % d == 0) {
divisors.push_back(d);
if (d * d != n)
divisors.push_back(n / d);
}
}

sort(divisors.begin(), divisors.end());
return divisors;
}

| width="10px" |  
| width=50% |
vector<int> getPrimeDivisors(int n) {
vector<int> primeDivisors;

for (long long d = 2; d * d <= n; d++) {
if (n % d == 0) {
primeDivisors.push_back(d);
while (n % d == 0)
n /= d;
}
}
if (n != 1)
primeDivisors.push_back(n);

return primeDivisors;
}
|}

===Факторизация числа (получение списка простых делителей), O(sqrt(N))===
{| width="100%"
| width=50% |
vector<int> factorize(int n) {
vector<int> factorization;

for (long long d = 2; d * d <= n; d++) {
while (n % d == 0) {
factorization.push_back(d);
n /= d;
}
}
if (n != 1)
factorization.push_back(n);

return factorization;
}
| width="10px" |  
| width=50% |
map<int, int> factorize(int n) {
map<int, int> factorization;

for (long long d = 2; d * d <= n; d++) {
while (n % d == 0) {
factorization[d]++;
n /= d;
}
}
if (n != 1)
factorization[n]++;

return factorization;
}
|}

===Решето Эратосфена, O(NloglogN)===

vector<int> getPrimes(int n) {
vector<int> isPrime(n + 1, 1), primes;

for (int i = 2; i < isPrime.size(); i++) {
if (isPrime[i]) {
primes.push_back(i);
for (long long j = 1LL * i * i; j < isPrime.size(); j += i)
isPrime[j] = 0;
}
}

return primes;
}

===Решето Эратосфена, O(N)===
vector<int> getPrimes(int n) {
vector<int> minDivisor(n + 1), primes;

for (int i = 2; i < minDivisor.size(); i++) {
if (!minDivisor[i]) {
minDivisor[i] = i;
primes.push_back(i);
}
for (int j = 0; j < primes.size() && primes[j] <= minDivisor[i] && 1LL * i * primes[j] < minDivisor.size(); j++)
minDivisor[i * primes[j]] = primes[j];
}

return primes;
}

== Ссылки ==
Теория:
:* [http://e-maxx.ru/algo/eratosthenes_sieve E-Maxx — Решето Эратосфена]
:* [http://e-maxx.ru/algo/prime_sieve_linear E-Maxx — Решето Эратосфена с линейным временем работы]
:* [http://brestprog.by/topics/factorization Brestprog — Разложение числа на простые множители (факторизация). Делители числа]
:* [http://brestprog.by/topics/primesieve Brestprog — Решето Эратосфена]
:* [http://algorithmica.org/tg/number-theory algorithmica.org — Теория чисел]
:* [http://algorithmica.org/ru/eratosthenes algorithmica.org — Решето Эратосфена]
:* [https://usaco.guide/gold/divis?lang=cpp#prime-factorization USACO Guide — Prime Factorization]
Код:
:* [https://github.com/indy256/codelibrary/blob/master/cpp/numbertheory/primes_and_divisors.cpp indy256/codelibrary/cpp/numbertheory/primes_and_divisors.cpp]
:* [https://github.com/indy256/codelibrary/blob/master/cpp/numbertheory/factorization.cpp indy256/codelibrary/cpp/numbertheory/factorization.cpp]
Задачи:
:* [http://acmp.ru/?main=task&id_task=200 ACMP #200]
:* [[:Категория: Задачи: Простые числа|Задачи: Простые числа]]
:* [http://informatics.mccme.ru/course/view.php?id=17 informatics.mccme.ru — Курс «Арифметика и числовые алгоритмы» — часть 1]

[[Category:Арифметические алгоритмы]]

Длинная арифметика

2024-08-13T23:40:05Z

Ctrlalt: /* Длинная арифметика на vector */

== Хранение, ввод и вывод ==

class BigInteger {
static const int BASE = 1e9;
static const int BASE_LEN = 9;
static const int MAX_SIZE = 1e4;
int d[MAX_SIZE];
int size;
public:
BigInteger(long long val = 0) {
for (int i = 0; i < MAX_SIZE; i++)
d[i] = 0;
size = 0;
if (val == 0)
d[size++] = 0;
while (val > 0) {
d[size++] = val % BASE;
val /= BASE;
}
}
BigInteger(char val[]) {
for (int i = 0; i < MAX_SIZE; i++)
d[i] = 0;
size = 0;
for (int i = strlen(val) - 1; i >= 0; i -= BASE_LEN) {
int digit = 0;
for (int j = max(0, i - BASE_LEN + 1); j <= i; j++)
digit = digit * 10 + val[j] - '0';
d[size++] = digit;
}
}
void print() const {
static char spec[] = "%00d";
spec[2] = BASE_LEN + '0';
printf("%d", d[size - 1]);
for (int i = size - 2; i >= 0; i--)
printf(spec, d[i]);
}
};

== Сравнение ==

int cmp(const BigInteger &that) const {
if (size != that.size)
return size < that.size ? -1 : 1;
for (int i = size - 1; i >= 0; i--) {
if (d[i] != that.d[i])
return d[i] < that.d[i] ? -1 : 1;
}
return 0;
}
bool operator < (const BigInteger &that) const {
return cmp(that) < 0;
}
bool operator == (const BigInteger &that) const {
return cmp(that) == 0;
}

== Сложение ==

BigInteger operator + (const BigInteger &that) const {
BigInteger res;
int carry = 0;
for (int i = 0; i < max(size, that.size) || carry != 0; i++) {
long long x = 0LL + d[i] + that.d[i] + carry;
res.d[i] = x % BASE;
carry = x / BASE;
}
res.size = max(size, that.size) + 1;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

== Вычитание ==

Предполагается, что уменьшаемое больше вычитаемого.

BigInteger operator - (const BigInteger &that) const {
BigInteger res;
int carry = 0;
for (int i = 0; i < size || carry != 0; i++) {
long long x = 0LL + d[i] - that.d[i] + carry;
res.d[i] = (x + BASE) % BASE;
carry = x < 0 ? -1 : 0;
}
res.size = size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

== Умножение ==

{|
| width="50%" |
BigInteger operator * (const BigInteger &that) const {
BigInteger res;
for (int i = 0; i < size; i++) {
int carry = 0;
for (int j = 0; j < that.size || carry != 0; j++) {
long long x = res.d[i + j] + 1LL * d[i] * that.d[j] + carry;
res.d[i + j] = x % BASE;
carry = x / BASE;
}
}
res.size = size + that.size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}
| width="10px" |
| width="50%" |
BigInteger operator * (int that) const {
BigInteger res;
int carry = 0;
for (int i = 0; i < size || carry != 0; i++) {
long long x = 1LL * d[i] * that + carry;
res.d[i] = x % BASE;
carry = x / BASE;
}
res.size = size + 1;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

|}

== Деление и взятие остатка ==

{|
| width="50%" |
BigInteger operator / (const BigInteger &that) const {
BigInteger res, carry;
for (int i = size - 1; i >= 0; i--) {
carry = carry * BASE;
carry.d[0] = d[i];
int l = 0, r = BASE - 1, m;
while (l + 1 < r) {
m = l + (r - l) / 2;
if ((that * m).cmp(carry) <= 0)
l = m;
else
r = m;
}
res.d[i] = (that * r).cmp(carry) <= 0 ? r : l;
carry = carry - that * res.d[i];
}
res.size = size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}
| width="10px" |
| width="50%" |
BigInteger operator / (int that) const {
BigInteger res;
int carry = 0;
for (int i = size - 1; i >= 0; i--) {
long long x = 1LL * carry * BASE + d[i];
res.d[i] = x / that;
carry = x % that;
}
res.size = size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

|}
{|
| width="50%" |
BigInteger operator % (const BigInteger &that) const {
BigInteger carry;
for (int i = size - 1; i >= 0; i--) {
carry = carry * BASE;
carry.d[0] = d[i];
int l = 0, r = BASE - 1, m;
while (l + 1 < r) {
m = l + (r - l) / 2;
if ((that * m).cmp(carry) <= 0)
l = m;
else
r = m;
}
int digit = (that * r).cmp(carry) <= 0 ? r : l;
carry = carry - that * digit;
}
return carry;
}
| width="10px" |
| width="50%" |
int operator % (int that) const {
int carry = 0;
for (int i = size - 1; i >= 0; i--)
carry = (1LL * carry * BASE + d[i]) % that;
return carry;
}

|}

== Длинная арифметика на vector ==

struct BigInteger {
vector<int> digits;
inline static const int BASE = 1e9;
inline static const int DIGIT_WIDTH = 9;

inline int digit(int index) const {
return index < digits.size() ? digits[index] : 0;
}

inline int &digit(int index) {
if (digits.size() <= index)
digits.resize(index + 1);
return digits[index];
}

inline void removeZeros() {
while (!digits.empty() && !digits.back())
digits.pop_back();
}

BigInteger(long long value = 0) {
for (; value; value /= BASE)
digits.push_back(value % BASE);
}

BigInteger(const string &s) {
for (int r = s.size() - 1; r >= 0; r -= DIGIT_WIDTH) {
int l = max(r - DIGIT_WIDTH + 1, 0);
digits.push_back(stoi(s.substr(l, r - l + 1)));
}
removeZeros();
}

BigInteger operator + (const BigInteger &that) const {
BigInteger res;
for (int i = 0, carry = 0; i < digits.size() || i < that.digits.size() || carry; i++) {
int cur = digit(i) + that.digit(i) + carry;
res.digits.push_back(cur % BASE);
carry = cur / BASE;
}
return res;
}

BigInteger operator * (const BigInteger &that) const {
BigInteger res;
for (int i = 0, carry = 0; i < digits.size(); i++) {
for (int j = 0; j < that.digits.size() || carry; j++) {
long long cur = res.digit(i + j) + 1LL * digit(i) * that.digit(j) + carry;
res.digit(i + j) = cur % BASE;
carry = cur / BASE;
}
}
res.removeZeros();
return res;
}

BigInteger operator / (int that) const {
BigInteger res;
for (int i = digits.size() - 1, carry = 0; i >= 0; i--) {
long long cur = 1LL * carry * BASE + digit(i);
res.digit(i) = cur / that;
carry = cur % that;
}
res.removeZeros();
return res;
}

friend istream &operator >> (istream &in, BigInteger &value) {
string s;
in >> s;
value = BigInteger(s);
return in;
}

friend ostream &operator << (ostream &out, const BigInteger &value) {
if (value.digits.empty()) {
out << 0;
} else {
out << value.digits.back();
for (int i = (int)value.digits.size() - 2; i >= 0; i--) {
out.width(DIGIT_WIDTH);
out.fill('0');
out << value.digits[i];
}
}
return out;
}
};

== Ссылки на задачи ==
* [http://acmp.ru/?main=task&id_task=103 ACMP #103 — Снова A + B]
* [http://acmp.ru/?main=task&id_task=143 ACMP #143 — A - B]
* [http://acmp.ru/?main=task&id_task=144 ACMP #144 — A * B]
* [http://acmp.ru/?main=task&id_task=145 ACMP #145 — A div B]

== Ссылки ==
* [[Сложная длинная арифметика]]
* [http://e-maxx.ru/algo/big_integer e-maxx.ru — Длинная арифметика]
* [http://cppalgo.blogspot.ru/2010/05/blog-post.html cppalgo.blogspot.ru — Длинная арифметика]
* [http://brestprog.neocities.org/lections/longarithmetics.html brestprog.neocities.org — Длинная арифметика]
* [http://informatics.mccme.ru/course/view.php?id=17 informatics.mccme.ru — Курс «Арифметика и числовые алгоритмы» — часть 5]
* [http://github.com/ADJA/algos/blob/master/NumberTheory/BigInt.cpp Algos — Structure implementing long arithmetic in C++]

[[Category:Арифметические алгоритмы]]

Длинная арифметика

2024-07-21T14:16:00Z

Ctrlalt:

== Хранение, ввод и вывод ==

class BigInteger {
static const int BASE = 1e9;
static const int BASE_LEN = 9;
static const int MAX_SIZE = 1e4;
int d[MAX_SIZE];
int size;
public:
BigInteger(long long val = 0) {
for (int i = 0; i < MAX_SIZE; i++)
d[i] = 0;
size = 0;
if (val == 0)
d[size++] = 0;
while (val > 0) {
d[size++] = val % BASE;
val /= BASE;
}
}
BigInteger(char val[]) {
for (int i = 0; i < MAX_SIZE; i++)
d[i] = 0;
size = 0;
for (int i = strlen(val) - 1; i >= 0; i -= BASE_LEN) {
int digit = 0;
for (int j = max(0, i - BASE_LEN + 1); j <= i; j++)
digit = digit * 10 + val[j] - '0';
d[size++] = digit;
}
}
void print() const {
static char spec[] = "%00d";
spec[2] = BASE_LEN + '0';
printf("%d", d[size - 1]);
for (int i = size - 2; i >= 0; i--)
printf(spec, d[i]);
}
};

== Сравнение ==

int cmp(const BigInteger &that) const {
if (size != that.size)
return size < that.size ? -1 : 1;
for (int i = size - 1; i >= 0; i--) {
if (d[i] != that.d[i])
return d[i] < that.d[i] ? -1 : 1;
}
return 0;
}
bool operator < (const BigInteger &that) const {
return cmp(that) < 0;
}
bool operator == (const BigInteger &that) const {
return cmp(that) == 0;
}

== Сложение ==

BigInteger operator + (const BigInteger &that) const {
BigInteger res;
int carry = 0;
for (int i = 0; i < max(size, that.size) || carry != 0; i++) {
long long x = 0LL + d[i] + that.d[i] + carry;
res.d[i] = x % BASE;
carry = x / BASE;
}
res.size = max(size, that.size) + 1;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

== Вычитание ==

Предполагается, что уменьшаемое больше вычитаемого.

BigInteger operator - (const BigInteger &that) const {
BigInteger res;
int carry = 0;
for (int i = 0; i < size || carry != 0; i++) {
long long x = 0LL + d[i] - that.d[i] + carry;
res.d[i] = (x + BASE) % BASE;
carry = x < 0 ? -1 : 0;
}
res.size = size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

== Умножение ==

{|
| width="50%" |
BigInteger operator * (const BigInteger &that) const {
BigInteger res;
for (int i = 0; i < size; i++) {
int carry = 0;
for (int j = 0; j < that.size || carry != 0; j++) {
long long x = res.d[i + j] + 1LL * d[i] * that.d[j] + carry;
res.d[i + j] = x % BASE;
carry = x / BASE;
}
}
res.size = size + that.size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}
| width="10px" |
| width="50%" |
BigInteger operator * (int that) const {
BigInteger res;
int carry = 0;
for (int i = 0; i < size || carry != 0; i++) {
long long x = 1LL * d[i] * that + carry;
res.d[i] = x % BASE;
carry = x / BASE;
}
res.size = size + 1;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

|}

== Деление и взятие остатка ==

{|
| width="50%" |
BigInteger operator / (const BigInteger &that) const {
BigInteger res, carry;
for (int i = size - 1; i >= 0; i--) {
carry = carry * BASE;
carry.d[0] = d[i];
int l = 0, r = BASE - 1, m;
while (l + 1 < r) {
m = l + (r - l) / 2;
if ((that * m).cmp(carry) <= 0)
l = m;
else
r = m;
}
res.d[i] = (that * r).cmp(carry) <= 0 ? r : l;
carry = carry - that * res.d[i];
}
res.size = size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}
| width="10px" |
| width="50%" |
BigInteger operator / (int that) const {
BigInteger res;
int carry = 0;
for (int i = size - 1; i >= 0; i--) {
long long x = 1LL * carry * BASE + d[i];
res.d[i] = x / that;
carry = x % that;
}
res.size = size;
while (res.size > 1 && res.d[res.size - 1] == 0)
res.size--;
return res;
}

|}
{|
| width="50%" |
BigInteger operator % (const BigInteger &that) const {
BigInteger carry;
for (int i = size - 1; i >= 0; i--) {
carry = carry * BASE;
carry.d[0] = d[i];
int l = 0, r = BASE - 1, m;
while (l + 1 < r) {
m = l + (r - l) / 2;
if ((that * m).cmp(carry) <= 0)
l = m;
else
r = m;
}
int digit = (that * r).cmp(carry) <= 0 ? r : l;
carry = carry - that * digit;
}
return carry;
}
| width="10px" |
| width="50%" |
int operator % (int that) const {
int carry = 0;
for (int i = size - 1; i >= 0; i--)
carry = (1LL * carry * BASE + d[i]) % that;
return carry;
}

|}

== Длинная арифметика на vector ==

struct BigInteger {
vector<int> digits;

BigInteger(long long value = 0) {
for ( ; value; value /= 10)
digits.push_back(value % 10);
}

BigInteger operator + (const BigInteger &that) const {
BigInteger res;
for (int i = 0, carry = 0; i < digits.size() || i < that.digits.size() || carry; i++) {
int digit = i < digits.size() ? digits[i] : 0;
int thatDigit = i < that.digits.size() ? that.digits[i] : 0;
int sum = digit + thatDigit + carry;
res.digits.push_back(sum % 10);
carry = sum / 10;
}
return res;
}

friend ostream &operator << (ostream &out, const BigInteger &value) {
if (value.digits.empty()) {
out << 0;
} else {
for (int i = value.digits.size() - 1; i >= 0; i--)
out << value.digits[i];
}
return out;
}
};

== Ссылки на задачи ==
* [http://acmp.ru/?main=task&id_task=103 ACMP #103 — Снова A + B]
* [http://acmp.ru/?main=task&id_task=143 ACMP #143 — A - B]
* [http://acmp.ru/?main=task&id_task=144 ACMP #144 — A * B]
* [http://acmp.ru/?main=task&id_task=145 ACMP #145 — A div B]

== Ссылки ==
* [[Сложная длинная арифметика]]
* [http://e-maxx.ru/algo/big_integer e-maxx.ru — Длинная арифметика]
* [http://cppalgo.blogspot.ru/2010/05/blog-post.html cppalgo.blogspot.ru — Длинная арифметика]
* [http://brestprog.neocities.org/lections/longarithmetics.html brestprog.neocities.org — Длинная арифметика]
* [http://informatics.mccme.ru/course/view.php?id=17 informatics.mccme.ru — Курс «Арифметика и числовые алгоритмы» — часть 5]
* [http://github.com/ADJA/algos/blob/master/NumberTheory/BigInt.cpp Algos — Structure implementing long arithmetic in C++]

[[Category:Арифметические алгоритмы]]

Алгоритм Форда-Беллмана

2024-04-21T13:19:57Z

Ctrlalt: /* TLDR */

== TLDR ==
<youtube width="300" height="180">fwaaNf2N4P8</youtube>
<youtube width="300" height="180">cE5n2IKf7W4</youtube>

<youtube width="300" height="180">LVnPNWwd-yo</youtube>
<youtube width="300" height="180">4njNaLG5p1A</youtube>

[[file:fordbellman.jpg]]

== Ссылки на задачи ==
* [http://acmp.ru/?main=task&id_task=138 ACMP #138 — Алгоритм Форда-Беллмана]
* [http://acmp.ru/?main=task&id_task=139 ACMP #139 — Лабиринт знаний]
* [http://acmp.ru/?main=task&id_task=140 ACMP #140 — Цикл отрицательного веса]

== Ссылки ==
* [http://e-maxx.ru/algo/ford_bellman e-maxx.ru — Алгоритм Форда-Беллмана]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%A4%D0%BE%D1%80%D0%B4%D0%B0-%D0%91%D0%B5%D0%BB%D0%BB%D0%BC%D0%B0%D0%BD%D0%B0 neerc.ifmo.ru/wiki — Алгоритм Форда-Беллмана]
* [http://algorithmica.org/tg/shortest-paths algorithmica.org — Кратчайшие пути в графе]
* [http://informatics.mccme.ru/course/view.php?id=6 informatics.mccme.ru — Курс «Алгоритмы на графах» — часть 6]
* [http://algs4.cs.princeton.edu/lectures/44ShortestPaths.pdf algs4.cs.princeton.edu/lectures — 4.4 Shortest Paths]
* [http://brilliant.org/wiki/bellman-ford-algorithm Brilliant.org — Bellman-Ford Algorithm]
* [http://visualgo.net/sssp.html VisuAlgo — Single-Source Shortest Paths]
* [http://github.com/indy256/codelibrary/blob/master/java/src/BellmanFord2.java CodeLibrary — Bellman–Ford algorithm]
* [http://github.com/ADJA/algos/blob/master/Graphs/BellmanFord.cpp Algos — Bellman-Ford algorithm]

[[Category:Кратчайшие пути из одной вершины]]

Алгоритм Флойда

2024-04-21T13:19:51Z

Ctrlalt: /* TLDR */

== TLDR ==
<youtube width="300" height="180">c7ahlIwBL7o</youtube>
<youtube width="300" height="180">8JQ565Rz7d8</youtube>

<youtube width="300" height="180">LVnPNWwd-yo</youtube>
<youtube width="300" height="180">4njNaLG5p1A</youtube>

== Код ==

Ищем расстояния во взвешенном графе от каждой вершины до всех остальных. Веса могут быть любыми.

Идея алгоритма:
* Инициализация. Пусть dist[a][b] — кратчайшее расстояние от a до b, но длиной не более чем одно ребро. Нетрудно понять, что dist — это просто матрица смежности графа (возможно, с небольшими модификациями):
:* Случай простого графа: dist[a][a] = 0, dist[a][b] = весу ребра (a, b); если ребра (a, b) нет, то dist[a][b] = INF;
:* Если есть кратные рёбра, то dist[a][b] = весу минимального ребра между a и b;
:* Если есть петли, то dist[a][a] = min(0, вес минимальной петли из a);
* Шаг 0. Теперь разрешаем путям проходить через вершину 0. Обновляем dist: dist[a][b] = min(dist[a][b], dist[a][0] + dist[0][b]);
* Шаг 1. Теперь разрешаем путям проходить через вершину 1. Обновляем dist: dist[a][b] = min(dist[a][b], dist[a][1] + dist[1][b]);
* Повторяем до шага vertexCount - 1.

const int INF = 1e9;
vector<vector<int>> dist(vertexCount, vector<int>(vertexCount, INF));

for (int v = 0; v < vertexCount; v++)
dist[v][v] = 0;

for (int i = 0; i < edgeCount; i++) {
int a, b, w;
cin >> a >> b >> w;
dist[a][b] = min(dist[a][b], w);
}

for (int v = 0; v < vertexCount; v++) {
for (int a = 0; a < vertexCount; a++) {
for (int b = 0; b < vertexCount; b++) {
if (dist[a][v] == INF || dist[v][b] == INF)
continue;
dist[a][b] = min(dist[a][b], dist[a][v] + dist[v][b]);
dist[a][b] = max(dist[a][b], -INF);
}
}
}

На что нужно обратить внимание:
* При инициализации матрицы на главной диагонали должны быть нули (если нет петель отрицательного веса), а там, где рёбер нет — бесконечности;
* При наличии отрицательных рёбер следует избегать присваиваний вида (INF - 1). Для этого, если хотя бы один из фрагментов пути равен INF, нужно делать continue;
* При наличии отрицательных циклов расстояния могут очень быстро уменьшаться и приводить к отрицательным переполнениям. Поэтому нужно ограничивать отрицательные числа снизу.

== Отрицательные циклы ==

Вершина v лежит на отрицательном цикле, если после запуска алгоритма Флойда dist[v][v] < 0. Наличие такой вершины — критерий отрицательного цикла в алгоритме Флойда.

При наличии отрицательных циклов между некоторыми парами вершин может не существовать кратчайшего пути. Между вершинами a и b нет кратчайшего пути, если существует вершина v, лежащая на отрицательном цикле, которая достижима из a и из которой достижима b.

const int NO_SHORTEST_PATH = -2e9;

for (int v = 0; v < vertexCount; v++)
for (int a = 0; a < vertexCount; a++)
for (int b = 0; b < vertexCount; b++)
if (dist[a][v] != INF && dist[v][v] < 0 && dist[v][b] != INF)
dist[a][b] = NO_SHORTEST_PATH;

== Ссылки ==
Теория:
* [http://e-maxx.ru/algo/floyd_warshall_algorithm e-maxx.ru — Алгоритм Флойда-Уоршелла]
* [https://cp-algorithms.com/graph/all-pair-shortest-path-floyd-warshall.html cp-algorithms.com — Floyd-Warshall Algorithm]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%A4%D0%BB%D0%BE%D0%B9%D0%B4%D0%B0 neerc.ifmo.ru/wiki — Алгоритм Флойда]
* [http://brestprog.by/topics/floyd/ brestprog.by — Алгоритм Флойда-Уоршелла]
* [http://algorithmica.org/tg/shortest-paths algorithmica.org — Кратчайшие пути в графе]
* [http://brilliant.org/wiki/floyd-warshall-algorithm brilliant.org — Floyd-Warshall Algorithm]
* usaco.guide — [https://usaco.guide/gold/shortest-paths?lang=cpp#floyd-warshall Shortest Paths with Non-Negative Edge Weights: Floyd-Warshall], [https://usaco.guide/adv/sp-neg?lang=cpp#floyd-warshall Shortest Paths with Negative Edge Weights: Floyd-Warshall]
Демонстрация:
* [https://www.cs.usfca.edu/~galles/visualization/Floyd.html www.cs.usfca.edu — Floyd-Warshall All-Pairs Shortest Path]
Код:
* [https://github.com/indy256/codelibrary/blob/master/java/graphs/shortestpaths/FloydWarshall.java indy256/codelibrary/java/graphs/shortestpaths/FloydWarshall.java]
* [https://github.com/ADJA/algos/blob/master/Graphs/FloydWarshall.cpp ADJA/algos/Graphs/FloydWarshall.cpp]
* [https://github.com/kevin-wayne/algs4/blob/master/src/main/java/edu/princeton/cs/algs4/FloydWarshall.java kevin-wayne/algs4/FloydWarshall.java]
Задачи:
* [http://informatics.mccme.ru/course/view.php?id=6 informatics.mccme.ru — Курс «Алгоритмы на графах» — часть 5]
* [http://acmp.ru/?main=task&id_task=135 ACMP #135 — Алгоритм Флойда]
* [http://acmp.ru/?main=task&id_task=136 ACMP #136 — Алгоритм Флойда - 2]
* [http://acmp.ru/?main=task&id_task=137 ACMP #137 — Существование пути]
* [http://acmp.ru/?main=task&id_task=562 ACMP #562 — Слабая K-связность]

[[Category:Кратчайшие пути между всеми парами вершин]]

Алгоритм Флойда

2024-04-21T12:52:41Z

Ctrlalt: /* TLDR */

== TLDR ==
<youtube width="300" height="180">c7ahlIwBL7o</youtube>
<youtube width="300" height="180">8JQ565Rz7d8</youtube>

<youtube width="300" height="180">LVnPNWwd-yo</youtube>
<youtube width="300" height="180">LnOOuNcRLIo</youtube>

== Код ==

Ищем расстояния во взвешенном графе от каждой вершины до всех остальных. Веса могут быть любыми.

Идея алгоритма:
* Инициализация. Пусть dist[a][b] — кратчайшее расстояние от a до b, но длиной не более чем одно ребро. Нетрудно понять, что dist — это просто матрица смежности графа (возможно, с небольшими модификациями):
:* Случай простого графа: dist[a][a] = 0, dist[a][b] = весу ребра (a, b); если ребра (a, b) нет, то dist[a][b] = INF;
:* Если есть кратные рёбра, то dist[a][b] = весу минимального ребра между a и b;
:* Если есть петли, то dist[a][a] = min(0, вес минимальной петли из a);
* Шаг 0. Теперь разрешаем путям проходить через вершину 0. Обновляем dist: dist[a][b] = min(dist[a][b], dist[a][0] + dist[0][b]);
* Шаг 1. Теперь разрешаем путям проходить через вершину 1. Обновляем dist: dist[a][b] = min(dist[a][b], dist[a][1] + dist[1][b]);
* Повторяем до шага vertexCount - 1.

const int INF = 1e9;
vector<vector<int>> dist(vertexCount, vector<int>(vertexCount, INF));

for (int v = 0; v < vertexCount; v++)
dist[v][v] = 0;

for (int i = 0; i < edgeCount; i++) {
int a, b, w;
cin >> a >> b >> w;
dist[a][b] = min(dist[a][b], w);
}

for (int v = 0; v < vertexCount; v++) {
for (int a = 0; a < vertexCount; a++) {
for (int b = 0; b < vertexCount; b++) {
if (dist[a][v] == INF || dist[v][b] == INF)
continue;
dist[a][b] = min(dist[a][b], dist[a][v] + dist[v][b]);
dist[a][b] = max(dist[a][b], -INF);
}
}
}

На что нужно обратить внимание:
* При инициализации матрицы на главной диагонали должны быть нули (если нет петель отрицательного веса), а там, где рёбер нет — бесконечности;
* При наличии отрицательных рёбер следует избегать присваиваний вида (INF - 1). Для этого, если хотя бы один из фрагментов пути равен INF, нужно делать continue;
* При наличии отрицательных циклов расстояния могут очень быстро уменьшаться и приводить к отрицательным переполнениям. Поэтому нужно ограничивать отрицательные числа снизу.

== Отрицательные циклы ==

Вершина v лежит на отрицательном цикле, если после запуска алгоритма Флойда dist[v][v] < 0. Наличие такой вершины — критерий отрицательного цикла в алгоритме Флойда.

При наличии отрицательных циклов между некоторыми парами вершин может не существовать кратчайшего пути. Между вершинами a и b нет кратчайшего пути, если существует вершина v, лежащая на отрицательном цикле, которая достижима из a и из которой достижима b.

const int NO_SHORTEST_PATH = -2e9;

for (int v = 0; v < vertexCount; v++)
for (int a = 0; a < vertexCount; a++)
for (int b = 0; b < vertexCount; b++)
if (dist[a][v] != INF && dist[v][v] < 0 && dist[v][b] != INF)
dist[a][b] = NO_SHORTEST_PATH;

== Ссылки ==
Теория:
* [http://e-maxx.ru/algo/floyd_warshall_algorithm e-maxx.ru — Алгоритм Флойда-Уоршелла]
* [https://cp-algorithms.com/graph/all-pair-shortest-path-floyd-warshall.html cp-algorithms.com — Floyd-Warshall Algorithm]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%A4%D0%BB%D0%BE%D0%B9%D0%B4%D0%B0 neerc.ifmo.ru/wiki — Алгоритм Флойда]
* [http://brestprog.by/topics/floyd/ brestprog.by — Алгоритм Флойда-Уоршелла]
* [http://algorithmica.org/tg/shortest-paths algorithmica.org — Кратчайшие пути в графе]
* [http://brilliant.org/wiki/floyd-warshall-algorithm brilliant.org — Floyd-Warshall Algorithm]
* usaco.guide — [https://usaco.guide/gold/shortest-paths?lang=cpp#floyd-warshall Shortest Paths with Non-Negative Edge Weights: Floyd-Warshall], [https://usaco.guide/adv/sp-neg?lang=cpp#floyd-warshall Shortest Paths with Negative Edge Weights: Floyd-Warshall]
Демонстрация:
* [https://www.cs.usfca.edu/~galles/visualization/Floyd.html www.cs.usfca.edu — Floyd-Warshall All-Pairs Shortest Path]
Код:
* [https://github.com/indy256/codelibrary/blob/master/java/graphs/shortestpaths/FloydWarshall.java indy256/codelibrary/java/graphs/shortestpaths/FloydWarshall.java]
* [https://github.com/ADJA/algos/blob/master/Graphs/FloydWarshall.cpp ADJA/algos/Graphs/FloydWarshall.cpp]
* [https://github.com/kevin-wayne/algs4/blob/master/src/main/java/edu/princeton/cs/algs4/FloydWarshall.java kevin-wayne/algs4/FloydWarshall.java]
Задачи:
* [http://informatics.mccme.ru/course/view.php?id=6 informatics.mccme.ru — Курс «Алгоритмы на графах» — часть 5]
* [http://acmp.ru/?main=task&id_task=135 ACMP #135 — Алгоритм Флойда]
* [http://acmp.ru/?main=task&id_task=136 ACMP #136 — Алгоритм Флойда - 2]
* [http://acmp.ru/?main=task&id_task=137 ACMP #137 — Существование пути]
* [http://acmp.ru/?main=task&id_task=562 ACMP #562 — Слабая K-связность]

[[Category:Кратчайшие пути между всеми парами вершин]]

Хеширование строк

2024-03-05T00:32:11Z

Ctrlalt:

hi = s0xn - 1 + s1xn - 2 + ... + sn - 2x + sn - 1.

struct Hasher {
long long x, mod;
vector<long long> p, h;

Hasher(const string &s, long long x = 31, long long mod = 1e9 + 7) : x(x), mod(mod) {
p.resize(s.size());
h.resize(s.size());

p[0] = 1;
h[0] = s[0] - 'a' + 1;

for (int i = 1; i < s.size(); i++) {
p[i] = p[i - 1] * x % mod;
h[i] = (h[i - 1] * x % mod + s[i] - 'a' + 1) % mod;
}
}

long long getHash(int l, int r) {
long long res = h[r];
if (l)
res = (res - p[r - l + 1] * h[l - 1] % mod + mod) % mod;
return res;
}
};

{| width="100%"
| width=50% |
hi = s0 + s1x + s2x2 + ... + sn - 1xn - 1.

Для выравнивания хеши различных подстрок домножаются на xn - 1 - L.

struct Hasher {
long long x = 31, mod = 1e9 + 7;
vector<long long> p, h;

Hasher(const string &s) {
p.resize(s.size());
h.resize(s.size());

p[0] = 1;
h[0] = s[0] - 'a' + 1;

for (int i = 1; i < s.size(); i++) {
p[i] = p[i - 1] * x % mod;
h[i] = (h[i - 1] + p[i] * (s[i] - 'a' + 1) % mod) % mod;
}
}

long long getHash(int l, int r) {
long long res = h[r];
if (l)
res = (res - h[l - 1] + mod) % mod;
res = res * p[p.size() - 1 - l] % mod;
return res;
}
};

Этот способ непригоден для сравнения участков двух строк разной длины. В данном случае хеш более левого участка следует домножать на x|L1 - L2|.

| width="10px" |  
| width=50% |
hi = s0 + s1x + s2x2 + ... + sn - 1xn - 1.

Для выравнивания хеши различных подстрок домножаются на (x-1)L.

struct Hasher {
long long x = 31, {{Changed|1=xi = 129032259,}} mod = 1e9 + 7;
vector<long long> p, {{Changed|pi,}} h;

Hasher(const string &s) {
p.resize(s.size());
{{Changed|pi.resize(s.size());}}
h.resize(s.size());

p[0] = {{Changed|1=pi[0] = }} 1;
h[0] = s[0] - 'a' + 1;

for (int i = 1; i < s.size(); i++) {
p[i] = p[i - 1] * x % mod;
{{Changed|1=pi[i] = pi[i - 1] * xi % mod;}}
h[i] = (h[i - 1] + p[i] * (s[i] - 'a' + 1) % mod) % mod;
}
}

long long getHash(int l, int r) {
long long res = h[r];
if (l) {
res = (res - h[l - 1] + mod) % mod;
{{Changed|1=res = (res * pi[l]) % mod}};
}
return res;
}
};
|}

== Ссылки ==
Теория:
* [http://e-maxx.ru/algo/string_hashes e-maxx.ru — Алгоритмы хэширования в задачах на строки]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D0%BF%D0%BE%D0%B4%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B8_%D0%B2_%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B5_%D1%81_%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC_%D1%85%D0%B5%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F._%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%A0%D0%B0%D0%B1%D0%B8%D0%BD%D0%B0-%D0%9A%D0%B0%D1%80%D0%BF%D0%B0 neerc.ifmo.ru — Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D0%BD%D0%B0%D0%B8%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%B5%D0%B9_%D0%BE%D0%B1%D1%89%D0%B5%D0%B9_%D0%BF%D0%BE%D0%B4%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B8_%D0%B4%D0%B2%D1%83%D1%85_%D1%81%D1%82%D1%80%D0%BE%D0%BA_%D1%81_%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC_%D1%85%D0%B5%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F neerc.ifmo.ru — Поиск наибольшей общей подстроки двух строк с использованием хеширования]
* [https://ru.algorithmica.org/cs/hashing/polynomial/ ru.algorithmica.org — Полиномиальное хеширование]
* [http://habrahabr.ru/post/142589/ habrahabr.ru — Полиномиальные хеши и их применение]
* [http://codeforces.com/blog/entry/4898 codeforces.com — Anti-hash test]
* [http://codeforces.com/blog/entry/60445 codeforces.com — Полиномиальное хеширование + разбор интересных задач]
* [https://blog.algoprog.ru/hash-no-multiply/ Калинин П. — Про хеширование без домножения]
* [https://usaco.guide/gold/string-hashing?lang=cpp usaco.guide — String Hashing]
Код:
* [https://github.com/indy256/codelibrary/blob/master/cpp/strings/hashing.cpp codelibrary/cpp/strings/hashing.cpp]
* [https://github.com/ADJA/algos/blob/master/Strings/Hashing.cpp algos/Strings/Hashing.cpp]
Задачи:
* [[:Категория: Задачи: Хеширование строк|Задачи: Хеширование строк]]

[[Категория:Строки]]

Категория:Учебный курс «Алгоритмы и структуры данных»

2024-02-16T22:21:09Z

Ctrlalt:

{|
|
;Сортировка и поиск
:
:* [[Асимптотический анализ алгоритмов]]
:* [[Анализ рекуррентных соотношений. Мастер-теорема]]
: Простейшие алгоритмы сортировки
:* 📄 [[Сортировка выбором]]
:* 📄 [[Сортировка вставками]]
: Улучшенные алгоритмы сортировки
:* 📄 [[Сортировка слиянием]]
:* 📄 [[Быстрая сортировка]]
: Сортировка за линейное время
:* [[Сортировка подсчётом]]
:* [[Поразрядная сортировка]]
: Алгоритмы поиска
:* [[Бинарный поиск]]
:* [[Тернарный поиск]]
: Применение сортировки
:* [[Сканирующая прямая]]
;Структуры данных
:
: Базовые структуры и абстрактные типы данных
:* [[Динамический массив]]
:* [[Связный список]]
:* [[Стек]]
:* [[Очередь]]
:* [[Очередь с приоритетами]]
:* [[Множество. Реализация на битовых векторах]]
:* [[Множество и словарь. Реализация на деревьях поиска]]
:* [[Множество и словарь. Реализация на хеш-таблицах]]
:* [[Система непересекающихся множеств]]
: Балансирующиеся деревья
:* 📄 [[АВЛ-дерево]]
:* 📄 [[Красно-чёрное дерево]]
:* [[Декартово дерево]]
:* 📄 [[Расширения декартова дерева]]
: Обработка запросов на отрезках
:* 📄 [[Префиксные суммы]]
:* [[Дерево Фенвика]]
:* 📄 [[Дерево отрезков]]
:* 📄 [[Sparse table]]
:* Sqrt-декомпозиция
:* [[Алгоритм Мо]]
|width=450px|
;Алгоритмы для работы с графами
:
:* [[Основные определения. Представление графов]]
: Поиск в глубину и его приложения
:* 📄 [[Поиск в глубину]]''O(V+E)''
:* 📄 [[Компоненты связности]]
:* 📄 [[Циклы в графе. Двудольность]]
:* 📄 [[Топологическая сортировка]]
:* 📄 [[Компоненты сильной связности. Алгоритм Косараю-Шарира|Компоненты сильной связности]]
:* 📄 [[Мосты. Компоненты рёберной двусвязности|Мосты]]
:* 📄 [[Точки сочленения. Компоненты вершинной двусвязности|Точки сочленения]]
:* 📄 [[Эйлеров цикл. Эйлеров путь]]
: Кратчайшие пути из одной вершины
:* 📄 [[Поиск в ширину]]''O(V+E)''
:* 📝 [[Алгоритм Дейкстры]]''O(V2+E) или O(ElogV)''
:* 📄 [[Алгоритм A*]]
:* [[Алгоритм Форда-Беллмана]]''O(VE)''
:* [[Кратчайшие пути в ациклических орграфах]]''O(V+E)''
: Кратчайшие пути между всеми парами вершин
:* 📄 [[Алгоритм Флойда]]''O(V3)''
:* [[Алгоритм Джонсона]]''O(VElogV)''
: Минимальное остовное дерево
:* 📝 [[Алгоритм Краскала]]''O(ElogV)''
:* 📄 [[Алгоритм Прима]]''O(V2+E) или O(ElogV)''
: Максимальный поток
:* 📄 [[Алгоритм Форда-Фалкерсона]]''O(Flow×E)''
:* 📄 [[Алгоритм Эдмондса-Карпа]]''O(VE2)''
:* 📄 [[Алгоритм Диница]]''O(V2E)''
:* 📝 [[Максимальный поток минимальной стоимости]]
:* [[Применения максимального потока]]
: Максимальное паросочетание
:* 📄 [[Алгоритм Куна]]''O(VE)''
:* 📄 [[Минимальное вершинное покрытие, максимальное независимое множество]]
: Наименьший общий предок
:* 📄 [[Метод двоичного подъёма]]''O(NlogN), O(logN)''
:* [[Сведение LCA к RMQ и RMQ к LCA]]
:* [[Алгоритм Тарьяна (offline)]]''O(N), O(1)''
: Декомпозиции деревьев
:* 📝 [[Heavy-light-декомпозиция]]
|
;Полный перебор и методы его оптимизации
:
:* [[Полный перебор]]
:* [[Два указателя]]
:* Meet in the middle
:* [[Жадные алгоритмы]]
: Динамическое программирование
:* [[Динамическое программирование]]
:* [[Задача о рюкзаке и связанные задачи]]
:* [[Оптимизации динамического программирования]]
;Математика
:
: Теория чисел
:* 📄 [[НОД. Алгоритм Евклида]]
:* 📄 [[Простые числа. Решето Эратосфена]]
:* 📄 [[Быстрое возведение в степень]]
:* 📄 [[Модульная арифметика]]
:* 📝 [[Длинная арифметика]]
:* 📄 [[Метод Гаусса]]
:* 📄 [[Быстрое преобразование Фурье]]
: Комбинаторика
:* 📄 [[Подсчёт и перечисление комбинаторных объектов]]
:* [[Получение номера по объекту и объекта по номеру]]
:* [[Перестановки]]
: Теория игр
:* [[Игры]]
: Геометрия
:* 📝 [[Геометрические примитивы]]
:* 📄 [[Выпуклая оболочка]]

; Алгоритмы для работы со строками
:
:* 📄 [[Хеширование строк]]
:* 📄 [[Префикс-функция]]
:* 📄 [[Алгоритм Ахо-Корасик]]
:* 📄 [[Z-функция]]
:* 📄 [[Алгоритм Манакера]]
:* 📄 [[Суффиксный массив]]
: Разбор выражений
:* 📝 [[Наивный рекурсивный разбор]]
:* 📄 [[Алгоритм сортировочной станции]]

; Разное
:
:* 📄 [[Часто используемые фрагменты]]
|}

''© В. А. Фолунин, 2012–2024''

Быстрое возведение в степень

2023-09-17T16:09:56Z

Ctrlalt:

== Базовая реализация ==

long long binPow(long long x, long long p, long long mod) {
if (!p)
return 1;
if (p % 2)
return binPow(x, p - 1, mod) * x % mod;
long long r = binPow(x, p / 2, mod);
return r * r % mod;
}

== Вычисление степеней, превышающих размер long long ==

Если x и mod взаимно просты, то binPow(x, p, mod) == binPow(x, p % phi(mod), mod), где phi — функция Эйлера.

Если x и mod не взаимно просты, но p ≥ log2(mod), то binPow(x, p, mod) == binPow(x, p % phi(mod) + phi(mod), mod).

long long phi(long long n) {
long long res = n;
for (long long d = 2; d * d <= n; d++) {
if (n % d == 0) {
while (n % d == 0)
n /= d;
res -= res / d;
}
}
if (n > 1)
res -= res / n;
return res;
}

== Возведение в степень матриц ==

const long long MOD = 1e9 + 7;

using Matrix = vector<vector<long long>>;

Matrix identityMatrix(int size) {
Matrix res(size, vector<long long>(size));
for (int i = 0; i < res.size(); i++)
res[i][i] = 1;
return res;
}

Matrix operator * (const Matrix &a, const Matrix &b) {
Matrix res(a.size(), vector<long long>(b[0].size()));
for (int y = 0; y < res.size(); y++)
for (int x = 0; x < res[0].size(); x++)
for (int i = 0; i < a[0].size(); i++)
res[y][x] = (res[y][x] + a[y][i] * b[i][x] % MOD) % MOD;
return res;
}

Matrix pow(const Matrix &m, long long p) {
if (!p)
return identityMatrix(m.size());
if (p % 2)
return pow(m, p - 1) * m;
Matrix r = pow(m, p / 2);
return r * r;
}

== Ссылки ==
* [http://e-maxx.ru/algo/binary_pow E-maxx — Бинарное возведение в степень]
* [https://cp-algorithms.com/algebra/binary-exp.html cp-algorithms.com — Binary Exponentiation]
* [https://cp-algorithms.com/algebra/phi-function.html#application cp-algorithms.com — Euler's totient function application in Euler's theorem]
* [http://algorithmica.org/tg/number-theory algorithmica.org — Теория чисел]
* [http://codeforces.com/blog/entry/43225 Codeforces — Cool tricks using Matrix Exponential]
* [http://habr.com/ru/post/148901 Habr — Используем быстрое возведение матриц в степень для написания очень быстрого интерпретатора простого языка программирования]
* [http://habr.com/ru/post/236689 Habr — Автоматическая оптимизация алгоритмов с помощью быстрого возведения матриц в степень]

[[Category:Арифметические алгоритмы]]

Часто используемые фрагменты

2023-09-13T17:25:20Z

Ctrlalt:

== Split и join ==

{| width="100%"
| width=50% |

vector<string> split(string &line) {
vector<string> words;
string word;
for (char c : line) {
if (c != ' ') {
word += c;
} else if (!word.empty()) {
words.push_back(word);
word.clear();
}
}
if (!word.empty())
words.push_back(word);
return words;
}

| width="10px" |  
| width=50% |

string join(vector<string> &words) {
string line;
for (int i = 0; i < words.size(); i++)
line += words[i] + (i + 1 < words.size() ? " " : "");
return line;
}

|}

{| width="100%"
| width=50% |

vector<string> split(string &line, const string &separators) {
vector<string> words;
string word;
for (char c : line) {
if (separators.find(c) == -1) {
word += c;
} else if (!word.empty()) {
words.push_back(word);
word.clear();
}
}
if (!word.empty())
words.push_back(word);
return words;
}

| width="10px" |  
| width=50% |

string join(vector<string> &words, const string &separator) {
string line;
for (int i = 0; i < words.size(); i++)
line += words[i] + (i + 1 < words.size() ? separator : "");
return line;
}

|}

== Сумма цифр ==
{| width="100%"
| width=50% |

int digitSum(int n) {
int sum = 0;
while (n) {
sum += n % 10;
n /= 10;
}
return sum;
}

| width="10px" |  
| width=50% |

int ones(int n) {
int res = 0;
while (n) {
res++;
n &= n - 1;
}
return res;
}

|}

== Перевод систем счисления ==

{| width="100%"
| width=50% |

long long toDec(string s, int base) {
static const string DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
long long res = 0;
for (char c : s)
res = res * base + DIGITS.find(c);
return res;
}

| width="10px" |  
| width=50% |

string fromDec(long long n, int base) {
static const string DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string res;
while (n >= base) {
res += DIGITS[n % base];
n /= base;
}
res += DIGITS[n];
reverse(res.begin(), res.end());
return res;
}

|}

== Римская система счисления ==

{| width="100%"
| width=50% |

string toRoman(int n) {
static const vector<pair<string, int>> CODES = {
{"M", 1000}, {"CM", 900}, {"D", 500}, {"CD", 400},
{"C", 100}, {"XC", 90}, {"L", 50}, {"XL", 40},
{"X", 10}, {"IX", 9}, {"V", 5}, {"IV", 4}, {"I", 1}
};

string res;
for (auto &[code, value] : CODES) {
while (n >= value) {
n -= value;
res += code;
}
}
return res;
}

| width="10px" |  
| width=50% |

int fromRoman(string &s) {
static const vector<pair<string, int>> CODES = {
{"M", 1000}, {"CM", 900}, {"D", 500}, {"CD", 400},
{"C", 100}, {"XC", 90}, {"L", 50}, {"XL", 40},
{"X", 10}, {"IX", 9}, {"V", 5}, {"IV", 4}, {"I", 1}
};

int pos = 0, res = 0;
for (auto &[code, value] : CODES) {
while (s.substr(pos, code.size()) == code) {
pos += code.size();
res += value;
}
}
return res;
}

|}

== Задача Иосифа ==

int size, step;
cin >> size >> step;

vector<int> a(size);
iota(a.begin(), a.end(), 1);

int pos = 0;
while (!a.empty()) {
pos = (pos + step - 1) % a.size();
cout << a[pos] << " ";
a.erase(a.begin() + pos);
}

== Даты ==

struct Date {
int day, month, year, dayOfWeek;

bool isLeap(int year) {
return year % 400 == 0 || year % 100 && year % 4 == 0;
}

int daysInMonth(int month, int year) {
vector<int> days = { 0, 31, 28 + isLeap(year), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
return days[month];
}

Date &operator++(int) {
day++;
if (day > daysInMonth(month, year)) {
day = 1;
month++;
if (month > 12) {
month = 1;
year++;
}
}
dayOfWeek = (dayOfWeek + 1) % 7;
return *this;
}

friend ostream &operator << (ostream &out, Date &date) {
static vector<string> names = {
"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"
};
out << names[date.dayOfWeek] << ", ";
out << setw(2) << setfill('0') << date.day << ".";
out << setw(2) << setfill('0') << date.month;
return out;
}
};

== Время ==

{| width="100%"
| width=50% |

int readTime() {
int hours, minutes;
char colon;
cin >> hours >> colon >> minutes;

return hours * 60 + minutes;
}

| width="10px" |  
| width=50% |

void writeTime(int time) {
cout << setw(2) << setfill('0') << time / 60 << ":";
cout << setw(2) << setfill('0') << time % 60;
}

|}

== Дроби ==

struct Fraction {
long long num, den;

Fraction(long long n = 0, long long d = 1) : num(n), den(d) {
long long g = gcd(num, den);
num /= g;
den /= g;

if (den < 0) {
num = -num;
den = -den;
}
}

Fraction operator + (const Fraction &that) const {
return { num * that.den + that.num * den, den * that.den };
}

Fraction operator - (const Fraction &that) const {
return { num * that.den - that.num * den, den * that.den };
}

Fraction operator * (const Fraction &that) const {
return { num * that.num, den * that.den };
}

Fraction operator / (const Fraction &that) const {
return { num * that.den, den * that.num };
}

friend istream &operator >> (istream &in, Fraction &f) {
long long num, den = 1;
in >> num;
if (in.peek() == '/') {
in.ignore();
in >> den;
}
f = { num, den };
return in;
}

friend ostream &operator << (ostream &out, const Fraction &f) {
out << f.num;
if (f.den != 1)
out << "/" << f.den;
return out;
}
};

Часто используемые фрагменты

2023-09-11T23:04:39Z

Ctrlalt: /* Время */

Алгоритм Ахо-Корасик

2023-09-10T13:01:36Z

Ctrlalt:

== Описание ==

Автомат Ахо-Корасик позволяет находить в тексте вхождения любой строки из заданного набора строк.

Автомат строится на основе бора. Каждая вершина в боре соответствует некоторой строке. Терминальные вершины соответствуют строкам из исходного набора.

Суффиксная ссылка из вершины, соответствующей строке s, ведёт в вершину, соответствующую длиннейшему из имеющихся в боре суффиксов строки s. 
Суть суффиксных ссылок та же, что и ячеек префикс-функции — они определяют, в какое состояние (в какую вершину) мы переходим, если очередной символ текста не совпал с ожидаемым (в данном случае ожидаемыми будут символы, имеющиеся в next у соответствующей вершины бора).

Чтобы за O(1) определять, в какую вершину мы должны перейти, если были в вершине v и встретили символ c, дополнительно вычисляются автоматные ссылки: v->autLink[c].

Если мы будем просматривать вершины бора в порядке обхода BFSом, то суффиксные и автоматные ссылки можно вычислять так:
* Суффиксная ссылка из вершины to при просмотре ребра v → (c, to): Если v — корень, то to->sufLink = v, иначе to->sufLink = v->sufLink->autLink[c].
* Автоматные ссылки из вершины v: Перебираем все символы алфавита. Если символ c есть в v->next, то v->autLink[c] = &v->next[c], иначе, если v — корень, то v->autLink[c] = v, иначе v->autLink[c] = v->sufLink->autLink[c].

Чтобы не пропустить вхождения строк, являющиеся суффиксами других строк (набор строк — ABA и B, текст — AB, хотим не пропустить вхождение B), нужно помечать вершину v как терминальную, если терминальной была вершина v->sufLink.

== Определение позиций вхождений каждой строки ==
Если нужно не просто проверить, содержал ли текст хотя бы одну строку из набора, а найти позиции вхождений каждой строки, вносятся следующие изменения:
* Вместо bool isTerminal используются vector<int> termIndexes и Vertex *termLink;
* termIndexes — массив номеров исходных строк, заканчивающихся в данной вершине (если в наборе не могло быть одинаковых строк, то достаточно одного номера);
* termLink — ссылка на ближайшую вершину, отличную от данной, у которой isTerminal был бы равен true (то есть эта вершина либо сама является концом какой-то из исходных строк, либо из неё по суффиксным ссылкам достижим такой конец);
* Признаком того, что найдено вхождение какой-то из исходных строк, раньше было isTerminal == true у текущей вершины. Сейчас это будет либо !termIndexes.empty(), либо termLink != nullptr;
* Когда мы обнаруживаем вершину с вхождением, от неё нужно переходить по termLink, пока такой переход возможен, и добавлять в ответ termIndexes всех посещённых вершин.

== Оптимизации ==
* Если не важен порядок символов, тип next и autLink можно заменить на unordered_map;
* Тип autLink можно заменить на vector или array;
* Новые вершины можно складывать в отдельный vector или list, тогда тип next можно будет заменить на map<char, int> (если вершины хранятся в vector) или map<char, Vertex *> (если вершины хранятся в list);
* Можно объединить next и autLink.

== Код ==
{| width="100%"
| width=50% |

class Trie {
struct Vertex {
bool isTerminal = 0;
map<char, Vertex> next;
Vertex *sufLink = 0;
map<char, Vertex *> autLink;
} root;

public:
void insert(const string &s) {
Vertex *v = &root;
for (char c : s)
v = &v->next[c];
v->isTerminal = 1;
}

void build(int alphabetSize) {
queue<Vertex *> q;
root.sufLink = &root;
q.push(&root);

while (!q.empty()) {
Vertex *v = q.front();
q.pop();

for (auto &[c, to] : v->next) {
to.sufLink = (v == &root ? &root : v->sufLink->autLink[c]);
q.push(&to);
}

for (char c = 'a'; c < 'a' + alphabetSize; c++) {
if (v->next.count(c))
v->autLink[c] = &v->next[c];
else
v->autLink[c] = (v == &root ? &root : v->sufLink->autLink[c]);
}

v->isTerminal |= v->sufLink->isTerminal;
}
}

bool check(const string &s) {
Vertex *v = &root;
for (char c : s) {
v = v->autLink[c];
if (v->isTerminal)
return 1;
}
return 0;
}
};

| width="10px" |  
| width=50% |

class Trie {
struct Vertex {
vector<int> termIndexes;
Vertex *termLink = 0;
unordered_map<char, Vertex> next;
Vertex *sufLink = 0;
unordered_map<char, Vertex *> autLink;
} root;
int stringCount = 0;

public:
void insert(const string &s) {
Vertex *v = &root;
for (char c : s)
v = &v->next[c];
v->termIndexes.push_back(stringCount++);
}

void build(int alphabetSize) {
queue<Vertex *> q;
root.sufLink = &root;
q.push(&root);

while (!q.empty()) {
Vertex *v = q.front();
q.pop();

for (auto &[c, to] : v->next) {
to.sufLink = (v == &root ? &root : v->sufLink->autLink[c]);
q.push(&to);
}

for (char c = 'a'; c < 'a' + alphabetSize; c++) {
if (v->next.count(c))
v->autLink[c] = &v->next[c];
else
v->autLink[c] = (v == &root ? &root : v->sufLink->autLink[c]);
}

v->termLink = (!v->sufLink->termIndexes.empty() ? v->sufLink : v->sufLink->termLink);
}
}

vector<vector<int>> check(const string &s) {
vector<vector<int>> res(stringCount);

Vertex *v = &root;
for (int i = 0; i < s.size(); i++) {
v = v->autLink[s[i]];

if (!v->termIndexes.empty() || v->termLink)
for (Vertex *term = (!v->termIndexes.empty() ? v : v->termLink); term; term = term->termLink)
for (int termIndex : term->termIndexes)
res[termIndex].push_back(i);
}

return res;
}
};

|}

== Ссылки ==
Теория:
* [http://e-maxx.ru/algo/aho_corasick e-maxx.ru — Алгоритм Ахо-Корасик]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%90%D1%85%D0%BE-%D0%9A%D0%BE%D1%80%D0%B0%D1%81%D0%B8%D0%BA neerc.ifmo.ru/wiki — Алгоритм Ахо-Корасик]
* [https://codeforces.com/blog/entry/14854 Codeforces — Алгоритм Ахо-Корасик. Построение]
* Algorithmica — Алгоритм Ахо-Корасик: [https://algorithmica.org/ru/aho-corasick 1], [https://wiki.algocode.ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%90%D1%85%D0%BE-%D0%9A%D0%BE%D1%80%D0%B0%D1%81%D0%B8%D0%BA 2]
Код:
* [https://github.com/indy256/codelibrary/blob/master/cpp/strings/aho-corasick.cpp Codelibrary — aho-corasick.cpp]
* [https://github.com/ADJA/algos/blob/master/Strings/Aho-Corasick.cpp Algos — Aho-Corasick.cpp]

[[Category: Строки]]

Алгоритм Ахо-Корасик

2023-09-10T13:00:38Z

Ctrlalt:

== Описание ==

Автомат Ахо-Корасик позволяет находить в тексте вхождения любой строки из заданного набора строк.

Автомат строится на основе бора. Каждая вершина в боре соответствует некоторой строке. Терминальные вершины соответствуют строкам из исходного набора.

Суффиксная ссылка из вершины, соответствующей строке s, ведёт в вершину, соответствующую длиннейшему из имеющихся в боре суффиксов строки s. 
Суть суффиксных ссылок та же, что и ячеек префикс-функции — они определяют, в какое состояние (в какую вершину) мы переходим, если очередной символ текста не совпал с ожидаемым (в данном случае ожидаемыми будут символы, имеющиеся в next у соответствующей вершины бора).

Чтобы за O(1) определять, в какую вершину мы должны перейти, если были в вершине v и встретили символ c, дополнительно вычисляются автоматные ссылки: v->autLink[c].

Если мы будем просматривать вершины бора в порядке обхода BFSом, то суффиксные и автоматные ссылки можно вычислять так:
* Суффиксная ссылка из вершины to при просмотре ребра v → (c, to): Если v — корень, то to->sufLink = v, иначе to->sufLink = v->sufLink->autLink[c].
* Автоматные ссылки из вершины v: Перебираем все символы алфавита. Если символ c есть в v->next, то v->autLink[c] = &v->next[c], иначе, если v — корень, то v->autLink[c] = v, иначе v->autLink[c] = v->sufLink->autLink[c].

Чтобы не пропустить вхождения строк, являющиеся суффиксами других строк (набор строк — ABA и B, текст — AB, хотим не пропустить вхождение B), нужно помечать вершину v как терминальную, если терминальной была вершина v->sufLink.

== Определение позиций вхождений каждой строки ==
Если нужно не просто проверить, содержал ли текст хотя бы одну строку из набора, а найти позиции вхождений каждой строки, вносятся следующие изменения:
* Вместо bool isTerminal используются vector<int> termIndexes и Vertex *termLink;
* termIndexes — массив номеров исходных строк, заканчивающихся в данной вершине (если в наборе не могло быть одинаковых строк, то достаточно одного номера);
* termLink — ссылка на ближайшую вершину, отличную от данной, у которой isTerminal был бы равен true (то есть эта вершина либо сама является концом какой-то из исходных строк, либо из неё по суффиксным ссылкам достижим такой конец);
* Признаком того, что найдено вхождение какой-то из исходных строк, раньше было isTerminal == true у текущей вершины. Сейчас это будет либо !termIndexes.empty(), либо termLink != nullptr;
* Когда мы обнаруживаем вершину с вхождением, от неё нужно переходить по termLink, пока такой переход возможен, и добавлять в ответ termIndexes всех посещённых вершин.

== Оптимизации ==
* Если не важен порядок символов, тип next и autLink можно заменить на unordered_map;
* Тип autLink можно заменить на vector или array;
* Новые вершины можно складывать в отдельный vector или list, тогда тип next можно будет заменить на map<char, int> (если вершины хранятся в vector) или map<char, Vertex *> (если вершины хранятся в list);
* Можно объединить next и autLink.

== Код ==
{| width="100%"
| width=50% |

class Trie {
struct Vertex {
bool isTerminal = 0;
map<char, Vertex> next;
Vertex *sufLink = 0;
map<char, Vertex *> autLink;
} root;

public:
void insert(const string &s) {
Vertex *v = &root;
for (char c : s)
v = &v->next[c];
v->isTerminal = 1;
}

void build(int alphabetSize) {
queue<Vertex *> q;
root.sufLink = &root;
q.push(&root);

while (!q.empty()) {
Vertex *v = q.front();
q.pop();

for (auto &[c, to] : v->next) {
to.sufLink = (v == &root ? &root : v->sufLink->autLink[c]);
q.push(&to);
}

for (char c = 'a'; c < 'a' + alphabetSize; c++) {
if (v->next.count(c))
v->autLink[c] = &v->next[c];
else
v->autLink[c] = (v == &root ? &root : v->sufLink->autLink[c]);
}

v->isTerminal |= v->sufLink->isTerminal;
}
}

bool check(const string &s) {
Vertex *v = &root;
for (char c : s) {
v = v->autLink[c];
if (v->isTerminal)
return 1;
}
return 0;
}
};

| width="10px" |  
| width=50% |

class Trie {
struct Vertex {
vector<int> termIndexes;
Vertex *termLink = 0;
map<char, Vertex> next;
Vertex *sufLink = 0;
map<char, Vertex *> autLink;
} root;
int stringCount = 0;

public:
void insert(const string &s) {
Vertex *v = &root;
for (char c : s)
v = &v->next[c];
v->termIndexes.push_back(stringCount++);
}

void build(int alphabetSize) {
queue<Vertex *> q;
root.sufLink = &root;
q.push(&root);

while (!q.empty()) {
Vertex *v = q.front();
q.pop();

for (auto &[c, to] : v->next) {
to.sufLink = (v == &root ? &root : v->sufLink->autLink[c]);
q.push(&to);
}

for (char c = 'a'; c < 'a' + alphabetSize; c++) {
if (v->next.count(c))
v->autLink[c] = &v->next[c];
else
v->autLink[c] = (v == &root ? &root : v->sufLink->autLink[c]);
}

v->termLink = (!v->sufLink->termIndexes.empty() ? v->sufLink : v->sufLink->termLink);
}
}

vector<vector<int>> check(const string &s) {
vector<vector<int>> res(stringCount);

Vertex *v = &root;
for (int i = 0; i < s.size(); i++) {
v = v->autLink[s[i]];

if (!v->termIndexes.empty() || v->termLink)
for (Vertex *term = (!v->termIndexes.empty() ? v : v->termLink); term; term = term->termLink)
for (int termIndex : term->termIndexes)
res[termIndex].push_back(i);
}

return res;
}
};

|}

== Ссылки ==
Теория:
* [http://e-maxx.ru/algo/aho_corasick e-maxx.ru — Алгоритм Ахо-Корасик]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%90%D1%85%D0%BE-%D0%9A%D0%BE%D1%80%D0%B0%D1%81%D0%B8%D0%BA neerc.ifmo.ru/wiki — Алгоритм Ахо-Корасик]
* [https://codeforces.com/blog/entry/14854 Codeforces — Алгоритм Ахо-Корасик. Построение]
* Algorithmica — Алгоритм Ахо-Корасик: [https://algorithmica.org/ru/aho-corasick 1], [https://wiki.algocode.ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%90%D1%85%D0%BE-%D0%9A%D0%BE%D1%80%D0%B0%D1%81%D0%B8%D0%BA 2]
Код:
* [https://github.com/indy256/codelibrary/blob/master/cpp/strings/aho-corasick.cpp Codelibrary — aho-corasick.cpp]
* [https://github.com/ADJA/algos/blob/master/Strings/Aho-Corasick.cpp Algos — Aho-Corasick.cpp]

[[Category: Строки]]

Алгоритм Ахо-Корасик

2023-09-07T01:03:07Z

Ctrlalt:

Автомат Ахо-Корасик позволяет находить в тексте вхождения любой строки из заданного набора строк.

Автомат строится на основе бора. Каждая вершина в боре соответствует некоторой строке. Терминальные вершины соответствуют строкам из исходного набора.

Суффиксная ссылка из вершины, соответствующей строке s, ведёт в вершину, соответствующую длиннейшему из имеющихся в боре суффиксов строки s. 
Суть суффиксных ссылок та же, что и ячеек префикс-функции — они определяют, в какое состояние (в какую вершину) мы переходим, если очередной символ текста не совпал с ожидаемым (в данном случае ожидаемыми будут символы, имеющиеся в next у соответствующей вершины бора).

Чтобы за O(1) определять, в какую вершину мы должны перейти, если были в вершине v и встретили символ c, дополнительно вычисляются автоматные ссылки: v->autLink[c].

Если мы будем просматривать вершины бора в порядке обхода BFSом, то суффиксные и автоматные ссылки можно вычислять так:
* Суффиксная ссылка из вершины to при просмотре ребра v → (c, to): Если v — корень, то to->sufLink = v, иначе to->sufLink = v->sufLink->autLink[c].
* Автоматные ссылки из вершины v: Перебираем все символы алфавита. Если символ c есть в v->next, то v->autLink[c] = &v->next[c], иначе, если v — корень, то v->autLink[c] = v, иначе v->autLink[c] = v->sufLink->autLink[c].

Чтобы не пропустить вхождения строк, являющиеся суффиксами других строк (набор строк — ABA и B, текст — AB, хотим не пропустить вхождение B), нужно помечать вершину v как терминальную, если терминальной была вершина v->sufLink.

class Trie {
struct Vertex {
bool isTerminal = false;
map<char, Vertex> next;
Vertex *sufLink = nullptr;
map<char, Vertex *> autLink;
} root;

public:
void add(const string &s) {
Vertex *v = &root;
for (const char &c : s)
v = &v->next[c];
v->isTerminal = true;
}

void build(int alphabetSize) {
queue<Vertex *> q;
root.sufLink = &root;
q.push(&root);

while (!q.empty()) {
Vertex *v = q.front();
q.pop();

for (auto &[c, to] : v->next) {
to.sufLink = (v == &root ? &root : v->sufLink->autLink[c]);
q.push(&to);
}

for (char c = 'a'; c < 'a' + alphabetSize; c++) {
if (v->next.count(c))
v->autLink[c] = &v->next[c];
else
v->autLink[c] = (v == &root ? &root : v->sufLink->autLink[c]);
}

v->isTerminal |= v->sufLink->isTerminal;
}
}

bool check(const string &s) {
Vertex *v = &root;
for (const char &c : s) {
v = v->autLink[c];
if (v->isTerminal)
return true;
}
return false;
}
};

== Ссылки ==
Теория:
* [http://e-maxx.ru/algo/aho_corasick e-maxx.ru — Алгоритм Ахо-Корасик]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%90%D1%85%D0%BE-%D0%9A%D0%BE%D1%80%D0%B0%D1%81%D0%B8%D0%BA neerc.ifmo.ru/wiki — Алгоритм Ахо-Корасик]
* [https://codeforces.com/blog/entry/14854 Codeforces — Алгоритм Ахо-Корасик. Построение]
* Algorithmica — Алгоритм Ахо-Корасик: [https://algorithmica.org/ru/aho-corasick 1], [https://wiki.algocode.ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%90%D1%85%D0%BE-%D0%9A%D0%BE%D1%80%D0%B0%D1%81%D0%B8%D0%BA 2]
Код:
* [https://github.com/indy256/codelibrary/blob/master/cpp/strings/aho-corasick.cpp Codelibrary — aho-corasick.cpp]
* [https://github.com/ADJA/algos/blob/master/Strings/Aho-Corasick.cpp Algos — Aho-Corasick.cpp]

[[Category: Строки]]

Алгоритм Ахо-Корасик

2023-09-07T00:59:57Z

Ctrlalt:

Автомат Ахо-Корасик позволяет находить в тексте вхождения любой строки из заданного набора строк.

Автомат строится на основе бора. Каждая вершина в боре соответствует некоторой строке. Терминальные вершины соответствуют строкам из исходного набора.

Суффиксная ссылка из вершины, соответствующей строке s, ведёт в вершину, соответствующую длиннейшему из имеющихся в боре суффиксов строки s. 
Суть суффиксных ссылок та же, что и ячеек префикс-функции — они определяют, в какое состояние (в какую вершину) мы переходим, если очередной символ текста не совпал с ожидаемым (в данном случае ожидаемыми будут символы, имеющиеся в next у соответствующей вершины бора).

Чтобы за O(1) определять, в какую вершину мы должны перейти, если были в вершине v и встретили символ c, дополнительно вычисляются автоматные ссылки: v->autLink[c].

Если мы будем просматривать вершины бора в порядке обхода BFSом, то суффиксные и автоматные ссылки можно вычислять так:
* Суффиксная ссылка из вершины to при просмотре ребра v → (c, to): Если v — корень, то to->sufLink = v, иначе to->sufLink = v->sufLink->autLink[c].
* Автоматные ссылки из вершины v: Перебираем все символы алфавита. Если символ c есть в v->next, то v->autLink[c] = &v->next[c], иначе, если v — корень, то v->autLink[c] = v, иначе v->autLink[c] = v->sufLink->autLink[c].

Чтобы не пропустить вхождения строк, являющиеся суффиксами других строк (набор строк — ABA и B, текст — AB, хотим не пропустить вхождение B), нужно помечать вершину v как терминальную, если терминальной была вершина v->sufLink.

class Trie {
struct Vertex {
bool isTerminal = false;
map<char, Vertex> next;
Vertex *sufLink = nullptr;
map<char, Vertex *> autLink;
} root;

public:
void add(const string &s) {
Vertex *v = &root;
for (const char &c : s)
v = &v->next[c];
v->isTerminal = true;
}

void build(int alphabetSize) {
queue<Vertex *> q;
q.push(&root);

while (!q.empty()) {
Vertex *v = q.front();
q.pop();

for (auto &[c, to] : v->next) {
to.sufLink = (v == &root ? &root : v->sufLink->autLink[c]);
q.push(&to);
}

for (char c = 'a'; c < 'a' + alphabetSize; c++) {
if (v->next.count(c))
v->autLink[c] = &v->next[c];
else
v->autLink[c] = (v == &root ? &root : v->sufLink->autLink[c]);
}

v->isTerminal |= v->sufLink->isTerminal;
}
}

bool check(const string &s) {
Vertex *v = &root;
for (const char &c : s) {
v = v->autLink[c];
if (v->isTerminal)
return true;
}
return false;
}
};

== Ссылки ==
Теория:
* [http://e-maxx.ru/algo/aho_corasick e-maxx.ru — Алгоритм Ахо-Корасик]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%90%D1%85%D0%BE-%D0%9A%D0%BE%D1%80%D0%B0%D1%81%D0%B8%D0%BA neerc.ifmo.ru/wiki — Алгоритм Ахо-Корасик]
* [https://codeforces.com/blog/entry/14854 Codeforces — Алгоритм Ахо-Корасик. Построение]
* Algorithmica — Алгоритм Ахо-Корасик: [https://algorithmica.org/ru/aho-corasick 1], [https://wiki.algocode.ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%90%D1%85%D0%BE-%D0%9A%D0%BE%D1%80%D0%B0%D1%81%D0%B8%D0%BA 2]
Код:
* [https://github.com/indy256/codelibrary/blob/master/cpp/strings/aho-corasick.cpp Codelibrary — aho-corasick.cpp]
* [https://github.com/ADJA/algos/blob/master/Strings/Aho-Corasick.cpp Algos — Aho-Corasick.cpp]

[[Category: Строки]]

Часто используемые фрагменты

2023-09-01T10:36:02Z

Ctrlalt:

== Split и join ==

{| width="100%"
| width=50% |

vector<string> split(string &line) {
vector<string> words;
string word;
for (char c : line) {
if (c != ' ') {
word += c;
} else if (!word.empty()) {
words.push_back(word);
word.clear();
}
}
if (!word.empty())
words.push_back(word);
return words;
}

| width="10px" |  
| width=50% |

string join(vector<string> &words) {
string line;
for (int i = 0; i < words.size(); i++)
line += words[i] + (i + 1 < words.size() ? " " : "");
return line;
}

|}

{| width="100%"
| width=50% |

vector<string> split(string &line, const string &separators) {
vector<string> words;
string word;
for (char c : line) {
if (separators.find(c) == -1) {
word += c;
} else if (!word.empty()) {
words.push_back(word);
word.clear();
}
}
if (!word.empty())
words.push_back(word);
return words;
}

| width="10px" |  
| width=50% |

string join(vector<string> &words, const string &separator) {
string line;
for (int i = 0; i < words.size(); i++)
line += words[i] + (i + 1 < words.size() ? separator : "");
return line;
}

|}

== Сумма цифр ==
{| width="100%"
| width=50% |

int digitSum(int n) {
int sum = 0;
while (n) {
sum += n % 10;
n /= 10;
}
return sum;
}

| width="10px" |  
| width=50% |

int ones(int n) {
int res = 0;
while (n) {
res++;
n &= n - 1;
}
return res;
}

|}

== Перевод систем счисления ==

{| width="100%"
| width=50% |

long long toDec(string s, int base) {
static const string DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
long long res = 0;
for (char c : s)
res = res * base + DIGITS.find(c);
return res;
}

| width="10px" |  
| width=50% |

string fromDec(long long n, int base) {
static const string DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string res;
while (n >= base) {
res += DIGITS[n % base];
n /= base;
}
res += DIGITS[n];
reverse(res.begin(), res.end());
return res;
}

|}

== Римская система счисления ==

{| width="100%"
| width=50% |

string toRoman(int n) {
static const vector<pair<string, int>> CODES = {
{"M", 1000}, {"CM", 900}, {"D", 500}, {"CD", 400},
{"C", 100}, {"XC", 90}, {"L", 50}, {"XL", 40},
{"X", 10}, {"IX", 9}, {"V", 5}, {"IV", 4}, {"I", 1}
};

string res;
for (auto &[code, value] : CODES) {
while (n >= value) {
n -= value;
res += code;
}
}
return res;
}

| width="10px" |  
| width=50% |

int fromRoman(string &s) {
static const vector<pair<string, int>> CODES = {
{"M", 1000}, {"CM", 900}, {"D", 500}, {"CD", 400},
{"C", 100}, {"XC", 90}, {"L", 50}, {"XL", 40},
{"X", 10}, {"IX", 9}, {"V", 5}, {"IV", 4}, {"I", 1}
};

int pos = 0, res = 0;
for (auto &[code, value] : CODES) {
while (s.substr(pos, code.size()) == code) {
pos += code.size();
res += value;
}
}
return res;
}

|}

== Задача Иосифа ==

int size, step;
cin >> size >> step;

vector<int> a(size);
iota(a.begin(), a.end(), 1);

int pos = 0;
while (!a.empty()) {
pos = (pos + step - 1) % a.size();
cout << a[pos] << " ";
a.erase(a.begin() + pos);
}

== Даты ==

struct Date {
int day, month, year, dayOfWeek;

bool isLeap(int year) {
return year % 400 == 0 || year % 100 && year % 4 == 0;
}

int daysInMonth(int month, int year) {
vector<int> days = { 0, 31, 28 + isLeap(year), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
return days[month];
}

Date &operator++(int) {
day++;
if (day > daysInMonth(month, year)) {
day = 1;
month++;
if (month > 12) {
month = 1;
year++;
}
}
dayOfWeek = (dayOfWeek + 1) % 7;
return *this;
}

friend ostream &operator << (ostream &out, Date &date) {
static vector<string> names = {
"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"
};
out << names[date.dayOfWeek] << ", ";
out << setw(2) << setfill('0') << date.day << ".";
out << setw(2) << setfill('0') << date.month;
return out;
}
};

== Время ==

{| width="100%"
| width=50% |

int readTime() {
int hours, minutes;
char colon;
cin >> hours >> colon >> minutes;

return h * 60 + m;
}

| width="10px" |  
| width=50% |

void writeTime(int time) {
cout << setw(2) << setfill('0') << time / 60 << ":";
cout << setw(2) << setfill('0') << time % 60;
}

|}

Часто используемые фрагменты

2023-08-13T00:13:44Z

Ctrlalt:

== Split и join ==

{| width="100%"
| width=50% |

vector<string> split(string &line) {
vector<string> words;
string word;
for (char c : line) {
if (c != ' ') {
word += c;
} else if (!word.empty()) {
words.push_back(word);
word.clear();
}
}
if (!word.empty())
words.push_back(word);
return words;
}

| width="10px" |  
| width=50% |

string join(vector<string> &words) {
string line;
for (int i = 0; i < words.size(); i++)
line += words[i] + (i + 1 < words.size() ? " " : "");
return line;
}

|}

{| width="100%"
| width=50% |

vector<string> split(string &line, const string &separators) {
vector<string> words;
string word;
for (char c : line) {
if (separators.find(c) == -1) {
word += c;
} else if (!word.empty()) {
words.push_back(word);
word.clear();
}
}
if (!word.empty())
words.push_back(word);
return words;
}

| width="10px" |  
| width=50% |

string join(vector<string> &words, const string &separator) {
string line;
for (int i = 0; i < words.size(); i++)
line += words[i] + (i + 1 < words.size() ? separator : "");
return line;
}

|}

== Сумма цифр ==

int digitSum(int n) {
int sum = 0;
while (n) {
sum += n % 10;
n /= 10;
}
return sum;
}

== Перевод систем счисления ==

{| width="100%"
| width=50% |

long long toDec(string s, int base) {
static const string DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
long long res = 0;
for (char c : s)
res = res * base + DIGITS.find(c);
return res;
}

| width="10px" |  
| width=50% |

string fromDec(long long n, int base) {
static const string DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string res;
while (n >= base) {
res += DIGITS[n % base];
n /= base;
}
res += DIGITS[n];
reverse(res.begin(), res.end());
return res;
}

|}

== Римская система счисления ==

{| width="100%"
| width=50% |

string toRoman(int n) {
static const vector<pair<string, int>> CODES = {
{"M", 1000}, {"CM", 900}, {"D", 500}, {"CD", 400},
{"C", 100}, {"XC", 90}, {"L", 50}, {"XL", 40},
{"X", 10}, {"IX", 9}, {"V", 5}, {"IV", 4}, {"I", 1}
};

string res;
for (auto &[code, value] : CODES) {
while (n >= value) {
n -= value;
res += code;
}
}
return res;
}

| width="10px" |  
| width=50% |

int fromRoman(string &s) {
static const vector<pair<string, int>> CODES = {
{"M", 1000}, {"CM", 900}, {"D", 500}, {"CD", 400},
{"C", 100}, {"XC", 90}, {"L", 50}, {"XL", 40},
{"X", 10}, {"IX", 9}, {"V", 5}, {"IV", 4}, {"I", 1}
};

int pos = 0, res = 0;
for (auto &[code, value] : CODES) {
while (s.substr(pos, code.size()) == code) {
pos += code.size();
res += value;
}
}
return res;
}

|}

== Задача Иосифа ==

int size, step;
cin >> size >> step;

vector<int> a(size);
iota(a.begin(), a.end(), 1);

int pos = 0;
while (!a.empty()) {
pos = (pos + step - 1) % a.size();
cout << a[pos] << " ";
a.erase(a.begin() + pos);
}

== Даты ==

struct Date {
int day, month, year, dayOfWeek;

bool isLeap(int year) {
return year % 400 == 0 || year % 100 && year % 4 == 0;
}

int daysInMonth(int month, int year) {
vector<int> days = { 0, 31, 28 + isLeap(year), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
return days[month];
}

Date &operator++(int) {
day++;
if (day > daysInMonth(month, year)) {
day = 1;
month++;
if (month > 12) {
month = 1;
year++;
}
}
dayOfWeek = (dayOfWeek + 1) % 7;
return *this;
}

friend ostream &operator << (ostream &out, Date &date) {
static vector<string> names = {
"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"
};
out << names[date.dayOfWeek] << ", ";
out << setw(2) << setfill('0') << date.day << ".";
out << setw(2) << setfill('0') << date.month;
return out;
}
};

Алгоритм Форда-Фалкерсона

2023-07-01T13:23:05Z

Ctrlalt:

class Graph {
struct Edge {
int a, b, capacity, flow = 0;

Edge(int a, int b, int capacity) :
a(a), b(b), capacity(capacity) {}

int other(int v) const {
return v == a ? b : a;
}

int capacityTo(int v) const {
return v == b ? capacity - flow : flow;
}

void addFlowTo(int v, int deltaFlow) {
flow += (v == b ? deltaFlow : -deltaFlow);
}
};

vector<Edge> edges;
vector<vector<int>> graph;
vector<bool> visited;
vector<int> edgeTo;

void dfs(int v) {
visited[v] = 1;
for (int e : graph[v]) {
int to = edges[e].other(v);
if (!visited[to] && edges[e].capacityTo(to)) {
edgeTo[to] = e;
dfs(to);
}
}
}

bool hasPath(int start, int finish) {
visited.assign(visited.size(), 0);
dfs(start);
return visited[finish];
}

int bottleneckCapacity(int start, int finish) {
int bCapacity = 1e9;
for (int v = finish; v != start; v = edges[edgeTo[v]].other(v))
bCapacity = min(bCapacity, edges[edgeTo[v]].capacityTo(v));
return bCapacity;
}

void addFlow(int start, int finish, int deltaFlow) {
for (int v = finish; v != start; v = edges[edgeTo[v]].other(v))
edges[edgeTo[v]].addFlowTo(v, deltaFlow);
}

public:
Graph(int vertexCount) :
graph(vertexCount), visited(vertexCount), edgeTo(vertexCount) {}

void addEdge(int from, int to, int capacity) {
edges.push_back(Edge(from, to, capacity));
graph[from].push_back(edges.size() - 1);
graph[to].push_back(edges.size() - 1);
}

long long maxFlow(int start, int finish) {
long long flow = 0;
while (hasPath(start, finish)) {
int deltaFlow = bottleneckCapacity(start, finish);
addFlow(start, finish, deltaFlow);
flow += deltaFlow;
}
return flow;
}
};

== Ссылки ==
Теория:
* [https://algs4.cs.princeton.edu/lectures/keynote/64MaxFlow.pdf algs4.cs.princeton.edu — 6.4 Maximum Flow]
* [http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%A4%D0%BE%D1%80%D0%B4%D0%B0-%D0%A4%D0%B0%D0%BB%D0%BA%D0%B5%D1%80%D1%81%D0%BE%D0%BD%D0%B0,_%D1%80%D0%B5%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F_%D1%81_%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_%D0%B2_%D0%B3%D0%BB%D1%83%D0%B1%D0%B8%D0%BD%D1%83 neerc.ifmo.ru/wiki — Алгоритм Форда-Фалкерсона]
* [http://brilliant.org/wiki/ford-fulkerson-algorithm Brilliant.org — Ford-Fulkerson Algorithm]
Демонстрация:
* [https://visualgo.net/en/maxflow VisuAlgo — Network Flow]
Код:
* [https://github.com/indy256/codelibrary/blob/master/java/graphs/flows/MaxFlowFordFulkerson.java CodeLibrary — Maximum flow. Ford-Fulkerson alogithm in O(V^2 * FLOW)]
* [http://github.com/ADJA/algos/blob/master/Graphs/FordFulkerson.cpp Algos — Ford-Fulkerson maxflow]
* algs4.cs.princeton.edu/code — [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/FlowEdge.java.html capacitated edge with flow], [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/FlowNetwork.java.html capacitated network], [http://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/FordFulkerson.java.html maxflow–mincut] (несмотря на название, используется алгоритм Эдмондса-Карпа)
Задачи:
* [http://informatics.mccme.ru/course/view.php?id=6 informatics.mccme.ru — Курс «Алгоритмы на графах» — часть 9]
* [[:Категория:Задачи: Максимальный поток|Задачи: Максимальный поток]]

[[Category: Максимальный поток]]