Add ru version (#1865)

* Add Russian docs site baseline

* Add Russian localized codebase

* Polish Russian code wording

* Update ru code translation.

* Update code translation and chapter covers.

* Fix pythontutor extraction.

* Add README and landing page.

* placeholder of profiles

* Use figures of English version

* Remove chapter paperbook

ru/codes/dart/chapter_backtracking/n_queens.dart

@@ -0,0 +1,75 @@
+/**
+ * File: n_queens.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: n ферзей */
+void backtrack(
+  int row,
+  int n,
+  List<List<String>> state,
+  List<List<List<String>>> res,
+  List<bool> cols,
+  List<bool> diags1,
+  List<bool> diags2,
+) {
+  // Когда все строки уже обработаны, записать решение
+  if (row == n) {
+    List<List<String>> copyState = [];
+    for (List<String> sRow in state) {
+      copyState.add(List.from(sRow));
+    }
+    res.add(copyState);
+    return;
+  }
+  // Обойти все столбцы
+  for (int col = 0; col < n; col++) {
+    // Вычислить главную и побочную диагонали, соответствующие этой клетке
+    int diag1 = row - col + n - 1;
+    int diag2 = row + col;
+    // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей
+    if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+      // Попытка: поставить ферзя в эту клетку
+      state[row][col] = "Q";
+      cols[col] = true;
+      diags1[diag1] = true;
+      diags2[diag2] = true;
+      // Перейти к размещению следующей строки
+      backtrack(row + 1, n, state, res, cols, diags1, diags2);
+      // Откат: восстановить эту клетку как пустую
+      state[row][col] = "#";
+      cols[col] = false;
+      diags1[diag1] = false;
+      diags2[diag2] = false;
+    }
+  }
+}
+
+/* Решить задачу о n ферзях */
+List<List<List<String>>> nQueens(int n) {
+  // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку
+  List<List<String>> state = List.generate(n, (index) => List.filled(n, "#"));
+  List<bool> cols = List.filled(n, false); // Отмечать, есть ли ферзь в столбце
+  List<bool> diags1 = List.filled(2 * n - 1, false); // Отмечать наличие ферзя на главной диагонали
+  List<bool> diags2 = List.filled(2 * n - 1, false); // Отмечать наличие ферзя на побочной диагонали
+  List<List<List<String>>> res = [];
+
+  backtrack(0, n, state, res, cols, diags1, diags2);
+
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  int n = 4;
+  List<List<List<String>>> res = nQueens(n);
+  print("Размер входной доски = $n");
+  print("Количество способов расстановки ферзей: ${res.length}");
+  for (List<List<String>> state in res) {
+    print("--------------------");
+    for (List<String> row in state) {
+      print(row);
+    }
+  }
+}

ru/codes/dart/chapter_backtracking/permutations_i.dart

@@ -0,0 +1,51 @@
+/**
+ * File: permutations_i.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: все перестановки I */
+void backtrack(
+  List<int> state,
+  List<int> choices,
+  List<bool> selected,
+  List<List<int>> res,
+) {
+  // Когда длина состояния равна числу элементов, записать решение
+  if (state.length == choices.length) {
+    res.add(List.from(state));
+    return;
+  }
+  // Перебор всех вариантов выбора
+  for (int i = 0; i < choices.length; i++) {
+    int choice = choices[i];
+    // Отсечение: нельзя выбирать один и тот же элемент повторно
+    if (!selected[i]) {
+      // Попытка: сделать выбор и обновить состояние
+      selected[i] = true;
+      state.add(choice);
+      // Перейти к следующему выбору
+      backtrack(state, choices, selected, res);
+      // Откат: отменить выбор и восстановить предыдущее состояние
+      selected[i] = false;
+      state.removeLast();
+    }
+  }
+}
+
+/* Все перестановки I */
+List<List<int>> permutationsI(List<int> nums) {
+  List<List<int>> res = [];
+  backtrack([], nums, List.filled(nums.length, false), res);
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [1, 2, 3];
+
+  List<List<int>> res = permutationsI(nums);
+
+  print("Входной массив nums = $nums");
+  print("Все перестановки res = $res");
+}

ru/codes/dart/chapter_backtracking/permutations_ii.dart

@@ -0,0 +1,53 @@
+/**
+ * File: permutations_ii.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: все перестановки II */
+void backtrack(
+  List<int> state,
+  List<int> choices,
+  List<bool> selected,
+  List<List<int>> res,
+) {
+  // Когда длина состояния равна числу элементов, записать решение
+  if (state.length == choices.length) {
+    res.add(List.from(state));
+    return;
+  }
+  // Перебор всех вариантов выбора
+  Set<int> duplicated = {};
+  for (int i = 0; i < choices.length; i++) {
+    int choice = choices[i];
+    // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы
+    if (!selected[i] && !duplicated.contains(choice)) {
+      // Попытка: сделать выбор и обновить состояние
+      duplicated.add(choice); // Записать значения уже выбранных элементов
+      selected[i] = true;
+      state.add(choice);
+      // Перейти к следующему выбору
+      backtrack(state, choices, selected, res);
+      // Откат: отменить выбор и восстановить предыдущее состояние
+      selected[i] = false;
+      state.removeLast();
+    }
+  }
+}
+
+/* Все перестановки II */
+List<List<int>> permutationsII(List<int> nums) {
+  List<List<int>> res = [];
+  backtrack([], nums, List.filled(nums.length, false), res);
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [1, 2, 2];
+
+  List<List<int>> res = permutationsII(nums);
+
+  print("Входной массив nums = $nums");
+  print("Все перестановки res = $res");
+}

ru/codes/dart/chapter_backtracking/preorder_traversal_i_compact.dart

@@ -0,0 +1,35 @@
+/**
+ * File: preorder_traversal_i_compact.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+/* Предварительный обход: пример 1 */
+void preOrder(TreeNode? root, List<TreeNode> res) {
+  if (root == null) {
+    return;
+  }
+  if (root.val == 7) {
+    // Записать решение
+    res.add(root);
+  }
+  preOrder(root.left, res);
+  preOrder(root.right, res);
+}
+
+/* Driver Code */
+void main() {
+  TreeNode? root = listToTree([1, 7, 3, 4, 5, 6, 7]);
+  print("\nИнициализация двоичного дерева");
+  printTree(root);
+
+  // Предварительный обход
+  List<TreeNode> res = [];
+  preOrder(root, res);
+
+  print("\nВсе узлы со значением 7");
+  print(List.generate(res.length, (i) => res[i].val));
+}

ru/codes/dart/chapter_backtracking/preorder_traversal_ii_compact.dart

@@ -0,0 +1,47 @@
+/**
+ * File: preorder_traversal_ii_compact.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+/* Предварительный обход: пример 2 */
+void preOrder(
+  TreeNode? root,
+  List<TreeNode> path,
+  List<List<TreeNode>> res,
+) {
+  if (root == null) {
+    return;
+  }
+
+  // Попытка
+  path.add(root);
+  if (root.val == 7) {
+    // Записать решение
+    res.add(List.from(path));
+  }
+  preOrder(root.left, path, res);
+  preOrder(root.right, path, res);
+  // Откат
+  path.removeLast();
+}
+
+/* Driver Code */
+void main() {
+  TreeNode? root = listToTree([1, 7, 3, 4, 5, 6, 7]);
+  print("\nИнициализация двоичного дерева");
+  printTree(root);
+
+  // Предварительный обход
+  List<TreeNode> path = [];
+  List<List<TreeNode>> res = [];
+  preOrder(root, path, res);
+
+  print("\nВсе пути от корня к узлу 7");
+  for (List<TreeNode> vals in res) {
+    print(List.generate(vals.length, (i) => vals[i].val));
+  }
+}

ru/codes/dart/chapter_backtracking/preorder_traversal_iii_compact.dart

@@ -0,0 +1,47 @@
+/**
+ * File: preorder_traversal_iii_compact.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+/* Предварительный обход: пример 3 */
+void preOrder(
+  TreeNode? root,
+  List<TreeNode> path,
+  List<List<TreeNode>> res,
+) {
+  if (root == null || root.val == 3) {
+    return;
+  }
+
+  // Попытка
+  path.add(root);
+  if (root.val == 7) {
+    // Записать решение
+    res.add(List.from(path));
+  }
+  preOrder(root.left, path, res);
+  preOrder(root.right, path, res);
+  // Откат
+  path.removeLast();
+}
+
+/* Driver Code */
+void main() {
+  TreeNode? root = listToTree([1, 7, 3, 4, 5, 6, 7]);
+  print("\nИнициализация двоичного дерева");
+  printTree(root);
+
+  // Предварительный обход
+  List<TreeNode> path = [];
+  List<List<TreeNode>> res = [];
+  preOrder(root, path, res);
+
+  print("\nВсе пути от корня к узлу 7");
+  for (List<TreeNode> vals in res) {
+    print(List.generate(vals.length, (i) => vals[i].val));
+  }
+}

ru/codes/dart/chapter_backtracking/preorder_traversal_iii_template.dart

@@ -0,0 +1,73 @@
+/**
+ * File: preorder_traversal_iii_template.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+/* Проверить, является ли текущее состояние решением */
+bool isSolution(List<TreeNode> state) {
+  return state.isNotEmpty && state.last.val == 7;
+}
+
+/* Записать решение */
+void recordSolution(List<TreeNode> state, List<List<TreeNode>> res) {
+  res.add(List.from(state));
+}
+
+/* Проверить, допустим ли этот выбор в текущем состоянии */
+bool isValid(List<TreeNode> state, TreeNode? choice) {
+  return choice != null && choice.val != 3;
+}
+
+/* Обновить состояние */
+void makeChoice(List<TreeNode> state, TreeNode? choice) {
+  state.add(choice!);
+}
+
+/* Восстановить состояние */
+void undoChoice(List<TreeNode> state, TreeNode? choice) {
+  state.removeLast();
+}
+
+/* Алгоритм бэктрекинга: пример 3 */
+void backtrack(
+  List<TreeNode> state,
+  List<TreeNode?> choices,
+  List<List<TreeNode>> res,
+) {
+  // Проверить, является ли текущее состояние решением
+  if (isSolution(state)) {
+    // Записать решение
+    recordSolution(state, res);
+  }
+  // Перебор всех вариантов выбора
+  for (TreeNode? choice in choices) {
+    // Отсечение: проверить допустимость выбора
+    if (isValid(state, choice)) {
+      // Попытка: сделать выбор и обновить состояние
+      makeChoice(state, choice);
+      // Перейти к следующему выбору
+      backtrack(state, [choice!.left, choice.right], res);
+      // Откат: отменить выбор и восстановить предыдущее состояние
+      undoChoice(state, choice);
+    }
+  }
+}
+
+/* Driver Code */
+void main() {
+  TreeNode? root = listToTree([1, 7, 3, 4, 5, 6, 7]);
+  print("\nИнициализация двоичного дерева");
+  printTree(root);
+
+  // Алгоритм бэктрекинга
+  List<List<TreeNode>> res = [];
+  backtrack([], [root!], res);
+  print("\nВсе пути от корня к узлу 7, в которых путь не содержит узлов со значением 3");
+  for (List<TreeNode> path in res) {
+    print(List.from(path.map((e) => e.val)));
+  }
+}

ru/codes/dart/chapter_backtracking/subset_sum_i.dart

@@ -0,0 +1,56 @@
+/**
+ * File: subset_sum_i.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: сумма подмножеств I */
+void backtrack(
+  List<int> state,
+  int target,
+  List<int> choices,
+  int start,
+  List<List<int>> res,
+) {
+  // Если сумма подмножества равна target, записать решение
+  if (target == 0) {
+    res.add(List.from(state));
+    return;
+  }
+  // Обойти все варианты выбора
+  // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+  for (int i = start; i < choices.length; i++) {
+    // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+    // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+    if (target - choices[i] < 0) {
+      break;
+    }
+    // Попытка: сделать выбор и обновить target и start
+    state.add(choices[i]);
+    // Перейти к следующему выбору
+    backtrack(state, target - choices[i], choices, i, res);
+    // Откат: отменить выбор и восстановить предыдущее состояние
+    state.removeLast();
+  }
+}
+
+/* Решить задачу суммы подмножеств I */
+List<List<int>> subsetSumI(List<int> nums, int target) {
+  List<int> state = []; // Состояние (подмножество)
+  nums.sort(); // Отсортировать nums
+  int start = 0; // Стартовая вершина обхода
+  List<List<int>> res = []; // Список результатов (список подмножеств)
+  backtrack(state, target, nums, start, res);
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [3, 4, 5];
+  int target = 9;
+
+  List<List<int>> res = subsetSumI(nums, target);
+
+  print("Входной массив nums = $nums, target = $target");
+  print("Все подмножества с суммой $target: res = $res");
+}

ru/codes/dart/chapter_backtracking/subset_sum_i_naive.dart

@@ -0,0 +1,54 @@
+/**
+ * File: subset_sum_i_naive.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: сумма подмножеств I */
+void backtrack(
+  List<int> state,
+  int target,
+  int total,
+  List<int> choices,
+  List<List<int>> res,
+) {
+  // Если сумма подмножества равна target, записать решение
+  if (total == target) {
+    res.add(List.from(state));
+    return;
+  }
+  // Перебор всех вариантов выбора
+  for (int i = 0; i < choices.length; i++) {
+    // Отсечение: если сумма подмножества превышает target, пропустить этот выбор
+    if (total + choices[i] > target) {
+      continue;
+    }
+    // Попытка: сделать выбор и обновить элемент и total
+    state.add(choices[i]);
+    // Перейти к следующему выбору
+    backtrack(state, target, total + choices[i], choices, res);
+    // Откат: отменить выбор и восстановить предыдущее состояние
+    state.removeLast();
+  }
+}
+
+/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */
+List<List<int>> subsetSumINaive(List<int> nums, int target) {
+  List<int> state = []; // Состояние (подмножество)
+  int total = 0; // Сумма элементов
+  List<List<int>> res = []; // Список результатов (список подмножеств)
+  backtrack(state, target, total, nums, res);
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [3, 4, 5];
+  int target = 9;
+
+  List<List<int>> res = subsetSumINaive(nums, target);
+
+  print("Входной массив nums = $nums, target = $target");
+  print("Все подмножества с суммой $target: res = $res");
+  print("Обратите внимание: результат этого метода содержит повторяющиеся множества");
+}

ru/codes/dart/chapter_backtracking/subset_sum_ii.dart

@@ -0,0 +1,61 @@
+/**
+ * File: subset_sum_ii.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: сумма подмножеств II */
+void backtrack(
+  List<int> state,
+  int target,
+  List<int> choices,
+  int start,
+  List<List<int>> res,
+) {
+  // Если сумма подмножества равна target, записать решение
+  if (target == 0) {
+    res.add(List.from(state));
+    return;
+  }
+  // Обойти все варианты выбора
+  // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+  // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента
+  for (int i = start; i < choices.length; i++) {
+    // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+    // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+    if (target - choices[i] < 0) {
+      break;
+    }
+    // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить
+    if (i > start && choices[i] == choices[i - 1]) {
+      continue;
+    }
+    // Попытка: сделать выбор и обновить target и start
+    state.add(choices[i]);
+    // Перейти к следующему выбору
+    backtrack(state, target - choices[i], choices, i + 1, res);
+    // Откат: отменить выбор и восстановить предыдущее состояние
+    state.removeLast();
+  }
+}
+
+/* Решить задачу суммы подмножеств II */
+List<List<int>> subsetSumII(List<int> nums, int target) {
+  List<int> state = []; // Состояние (подмножество)
+  nums.sort(); // Отсортировать nums
+  int start = 0; // Стартовая вершина обхода
+  List<List<int>> res = []; // Список результатов (список подмножеств)
+  backtrack(state, target, nums, start, res);
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [4, 4, 5];
+  int target = 9;
+
+  List<List<int>> res = subsetSumII(nums, target);
+
+  print("Входной массив nums = $nums, target = $target");
+  print("Все подмножества с суммой $target: res = $res");
+}