Update

Author: ex01tus

.gitignore

@@ -75,3 +75,5 @@ fabric.properties
 # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
 hs_err_pid*
 env.list
+
+.DS_Store

src/sp3/recursion/and/sorting/SegmentedPlots.java

@@ -6,7 +6,7 @@
 import java.util.List;
 
 /**
- * Алла захотела, чтобы у неё под окном были узкие клумбы с тюльпанам.
+ * Алла захотела, чтобы у неё под окном были узкие клумбы с тюльпанами.
  * На схеме земельного участка клумбы обозначаются просто горизонтальными отрезками, лежащими на одной прямой.
  * Для ландшафтных работ было нанято n садовников. Каждый из них обрабатывал какой-то отрезок на схеме.
  * Процесс был организован не очень хорошо, иногда один и тот же отрезок или его часть могли быть обработаны сразу

src/sp3/recursion/and/sorting/finals/InPlaceQuickSort.java

@@ -24,7 +24,7 @@
  * Пусть мы как-то выбрали опорный элемент. Заведём два указателя left и right, которые изначально будут указывать
  * на левый и правый концы отрезка соответственно. Затем будем двигать левый указатель вправо до тех пор, пока он указывает
  * на элемент, меньший опорного. Аналогично двигаем правый указатель влево, пока он стоит на элементе, превосходящем опорный.
- * В итоге окажется, что что левее от left все элементы точно принадлежат первой группе, а правее от right — второй.
+ * В итоге окажется, что левее от left все элементы точно принадлежат первой группе, а правее от right — второй.
  * Элементы, на которых стоят указатели, нарушают порядок. Поменяем их местами и продвинем указатели на следующие элементы.
  * Будем повторять это действие до тех пор, пока left и right не столкнутся.
  *
@@ -46,12 +46,12 @@
  * `r` движется влево пока элемент, на который он указывает, больше `pivot`. Когда оба указателя останавливаются, они
  * указывают на элементы, находящиеся не на своих местах. Элементы переставляются. Таким образом получаем, что все элементы,
  * левее `r` меньше `pivot`, а все элементы правее `l` – больше. Рекурсивно повторяем вышеописанные действия для левой и правой
- * частей инвервала.
+ * частей интервала.
  *
  * -- ДОКАЗАТЕЛЬСТВО КОРРЕКТНОСТИ --
  * На каждом уровне рекурсии слева оказываются элементы, меньшие некоторого числа из интервала, а справа – большие.
  * Рекурсивные вызовы продолжаются, пока не будет получен пустой массив или массив из одного элемента,
- * которые по определению являются отстортированными. Поскольку все перестановки совершаются in-place в исходном массиве,
+ * которые по определению являются отсортированными. Поскольку все перестановки совершаются in-place в исходном массиве,
  * то весь массив – отсортированный.
  *
  * -- ВРЕМЕННАЯ СЛОЖНОСТЬ --

src/sp7/greedy/and/dynamic/CashMachine.java

@@ -0,0 +1,55 @@
+package sp7.greedy.and.dynamic;
+
+import java.io.*;
+import java.util.Arrays;
+import java.util.List;
+
+import static java.util.stream.Collectors.toList;
+
+/**
+ * Тимофей пошёл снять деньги в банкомат. Ему нужно m франков. В банкомате в бесконечном количестве имеются купюры
+ * различных достоинств. Всего различных достоинств n. Купюр каждого достоинства можно взять бесконечно много.
+ * Нужно определить число способов, которыми Тимофей сможет набрать нужную сумму.
+ *
+ * В первой строке записано целое число m — сумма, которую нужно набрать. Во второй строке n — количество монет в банкомате.
+ * Оба числа не превосходят 300. Далее в третьей строке записано n уникальных натуральных чисел,
+ * каждое в диапазоне от 1 до 1000 –– достоинства купюр.
+ *
+ * Нужно вывести число способов, которым Тимофей сможет набрать нужную сумму.
+ */
+public class CashMachine {
+
+    private static long count(int amount, List<Integer> coins) {
+        if (amount < 1) return 0;
+
+        long[] memo = new long[amount + 1];
+        memo[0] = 1;
+
+        for (int coin : coins) {
+            for (int currentAmount = coin; currentAmount <= amount; currentAmount++) {
+                int prev = currentAmount - coin;
+                memo[currentAmount] += memo[prev];
+            }
+        }
+
+        return memo[amount];
+    }
+
+    public static void main(String[] args) throws IOException {
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+             BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out))) {
+            int amount = readInt(reader);
+            int n = readInt(reader);
+            List<Integer> coins = Arrays.stream(reader.readLine().split(" "))
+                    .map(Integer::parseInt)
+                    .collect(toList());
+
+            long count = count(amount, coins);
+            System.out.println(count);
+        }
+    }
+
+    private static int readInt(BufferedReader reader) throws IOException {
+        return Integer.parseInt(reader.readLine());
+    }
+}

src/sp7/greedy/and/dynamic/CoinChange.java

@@ -0,0 +1,72 @@
+package sp7.greedy.and.dynamic;
+
+import java.io.*;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static java.util.stream.Collectors.toList;
+
+/**
+ * Алла хочет купить дом на Алгосах. Для этого ей надо много наличных, которые она собирается получить в банкомате.
+ * Банкомат приличный, поэтому в нём есть бесконечно много банкнот каждого номинала.
+ * Всего номиналов k штук. Дом мечты Аллы стоит x франков.
+ * Найдите минимальное количество банкнот, которые в сумме дадут x франков. Если в набор входит несколько банкнот
+ * одинакового номинала, то учитывать надо их все.
+ * Например, если необходимо набрать 15 франков, а в банкомате купюры по 5 франков, то минимальное число купюр —- 3.
+ *
+ * В первой строке дана сумма, которую хочет получить Алла –— натуральное число x (1 ≤ x ≤ 10^4).
+ * Во второй строке дано число различных номиналов k. В третьей строке даны k чисел (1 ≤ k ≤ 1000) —– номиналы купюр.
+ * Все номиналы лежат в диапазоне от 1 до 10^4. Номиналы купюр могут повторяться.
+ *
+ * Выведите единственное число —– минимальное количество купюр, которыми можно набрать x франков.
+ * Если нельзя набрать в точности x франков, то выведите -1.
+ */
+public class CoinChange {
+
+    private static int minCoinsNumber(int amount, List<Integer> coins) {
+        if (amount < 1) return 0;
+
+        Map<Integer, Integer> memo = new HashMap<>();
+        memo.put(0, 0);
+
+        for (int i = 1; i <= amount; i++) {
+            int count = Integer.MAX_VALUE;
+            for (int coin : coins) {
+                if (i - coin < 0) continue;
+
+                Integer prev = memo.get(i - coin);
+                if (prev != null) {
+                    count = Math.min(count, prev + 1);
+                }
+            }
+
+            if (count != Integer.MAX_VALUE) {
+                memo.put(i, count);
+            }
+        }
+
+        return memo.getOrDefault(amount, -1);
+    }
+
+
+
+    public static void main(String[] args) throws IOException {
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+             BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out))) {
+            int amount = readInt(reader);
+            int n = readInt(reader);
+            List<Integer> coins = Arrays.stream(reader.readLine().split(" "))
+                    .map(Integer::parseInt)
+                    .collect(toList());
+
+            int min = minCoinsNumber(amount, coins);
+            System.out.println(min);
+        }
+    }
+
+    private static int readInt(BufferedReader reader) throws IOException {
+        return Integer.parseInt(reader.readLine());
+    }
+}

src/sp7/greedy/and/dynamic/CollectingFlowers.java

@@ -0,0 +1,54 @@
+package sp7.greedy.and.dynamic;
+
+import java.io.*;
+
+/**
+ * Черепаха Кондратина путешествует по клетчатому полю из n строк и m столбцов.
+ * В каждой клетке либо растёт цветочек, либо не растёт. Кондратине надо добраться из левого нижнего
+ * в правый верхний угол и собрать как можно больше цветочков.
+ * Помогите ей с этой сложной задачей и определите, какое наибольшее число цветочков она сможет собрать при условии,
+ * что Кондратина умеет передвигаться только на одну клетку вверх или на одну клетку вправо за ход.
+ *
+ * В первой строке даны размеры поля n и m (через пробел). Оба числа лежат в диапазоне от 1 до 1000.
+ * В следующих n строках задано поле. Каждая строка состоит из m символов 0 или 1, записанных подряд без пробелов,
+ * и завершается переводом строки. Если в клетке записана единица, то в ней растёт цветочек.
+ *
+ * Выведите единственное число — максимальное количество цветочков, которое сможет собрать Кондратина.
+ */
+public class CollectingFlowers {
+
+    private static int collect(int[][] field) {
+        int[][] memo = new int[field.length][field[0].length];
+
+        for (int i = field.length - 1; i >= 0; i--) {
+            for (int j = 0; j < field[0].length; j++) {
+                int left = j - 1 >= 0 ? memo[i][j - 1] : 0;
+                int bottom = i + 1 < memo.length ? memo[i + 1][j] : 0;
+
+                memo[i][j] = field[i][j] + Math.max(left, bottom);
+            }
+        }
+
+        return memo[0][field[0].length - 1];
+    }
+
+    public static void main(String[] args) throws IOException {
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+             BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out))) {
+            String[] s = reader.readLine().split(" ");
+            int n = Integer.parseInt(s[0]);
+            int m = Integer.parseInt(s[1]);
+
+            int[][] field = new int[n][m];
+            for (int i = 0; i < n; i++) {
+                String line = reader.readLine();
+                for (int c = 0; c < line.length(); c++) {
+                    field[i][c] = Character.getNumericValue(line.charAt(c));
+                }
+            }
+
+            int flowers = collect(field);
+            System.out.println(flowers);
+        }
+    }
+}

src/sp7/greedy/and/dynamic/CollectingFlowersWithPath.java

@@ -0,0 +1,86 @@
+package sp7.greedy.and.dynamic;
+
+import java.io.*;
+import java.util.Deque;
+import java.util.LinkedList;
+
+/**
+ * Теперь черепашке Кондратине надо узнать не только, сколько цветочков она может собрать,
+ * но и как ей построить свой маршрут для этого. Помогите ей!
+ * Напомним, что Кондратине надо дойти от левого нижнего до правого верхнего угла,
+ * а передвигаться она умеет только вверх и вправо.
+ *
+ * В первой строке даны размеры поля n и m (через пробел). Оба числа лежат в диапазоне от 1 до 1000.
+ * В следующих n строках задано поле. Каждая строка состоит из m символов 0 или 1 и завершается переводом строки.
+ * Если в клетке записана единица, то в ней растет цветочек.
+ *
+ * Выведите в первой строке максимальное количество цветочков, которое сможет собрать Кондратина.
+ * Во второй строке выведите маршрут в виде последовательности символов «U» и «R»,
+ * где «U» означает передвижение вверх, а «R» – передвижение вправо.
+ * Если возможных оптимальных путей несколько, то выведите любой.
+ */
+public class CollectingFlowersWithPath {
+
+    private static Deque<Character> path(int[][] memo) {
+        Deque<Character> path = new LinkedList<>();
+
+        int i = 0;
+        int j = memo[0].length - 1;
+        while (i < memo.length && j >= 0) {
+            int left = j - 1 >= 0 ? memo[i][j - 1] : -1;
+            int bottom = i + 1 < memo.length ? memo[i + 1][j] : -1;
+
+            if (left == -1 && bottom == -1) break;
+
+            if (left == -1 || left < bottom) {
+                path.push('U');
+                i += 1;
+            } else {
+                path.push('R');
+                j -= 1;
+            }
+        }
+
+        return path;
+    }
+
+    private static int[][] count(int[][] field) {
+        int[][] memo = new int[field.length][field[0].length];
+
+        for (int i = field.length - 1; i >= 0; i--) {
+            for (int j = 0; j < field[0].length; j++) {
+                int left = j - 1 >= 0 ? memo[i][j - 1] : 0;
+                int bottom = i + 1 < memo.length ? memo[i + 1][j] : 0;
+
+                memo[i][j] = field[i][j] + Math.max(left, bottom);
+            }
+        }
+
+        return memo;
+    }
+
+    public static void main(String[] args) throws IOException {
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+             BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out))) {
+            String[] s = reader.readLine().split(" ");
+            int n = Integer.parseInt(s[0]);
+            int m = Integer.parseInt(s[1]);
+
+            int[][] field = new int[n][m];
+            for (int i = 0; i < n; i++) {
+                String line = reader.readLine();
+                for (int c = 0; c < line.length(); c++) {
+                    field[i][c] = Character.getNumericValue(line.charAt(c));
+                }
+            }
+
+            int[][] count = count(field);
+            Deque<Character> path = path(count);
+
+            System.out.println(count[0][field[0].length - 1]);
+            while (!path.isEmpty()) {
+                writer.write(path.pop());
+            }
+        }
+    }
+}