200 |
201 | Apart from this, you can try implementing basic programs in C++ to get a feel for the language.
202 |
--------------------------------------------------------------------------------
/Week 3/1. Two Pointers.md:
--------------------------------------------------------------------------------
1 | # Two Pointers
2 |
3 | Two pointers in an approach for solving problems which require you to find a pair of numbers in an array (or a subarray bound by them) that satisfies a certain property.
4 | It is used to obtain an $O(n)$ solution to certain problems whose solutions would otherwise take $O(n^2)$ time.
5 | For example, one problem that can be solved using two pointers is finding whether there exists two integers in an array whose sum is equal to some number x (commonly known as the 2SUM problem).
6 | Let us examine the working of two pointers by constructing a solution to the above problem using it.
7 |
8 |
9 |
10 | ## 2SUM Problem
11 |
12 | Given an array of numbers, we must find whether there exists two numbers in the array such that there sum is equal to a given x.
13 | Let us say that the array of numbers is [7, 12, 3, 15, 8, 2, 14, 9] and the required sum is x = 20.
14 | The first approach that might occur to you is to use two nested for loops to iterate through every possible pair of two numbers from the array and check whether their sum is 20.
15 |
16 | ```cpp
17 | for (int i = 0; i < n; i++) {
18 | for (int j = i + 1; j < n; j++) {
19 | if (arr[i] + arr[j] == x) {
20 | cout << "YES\n";
21 | return;
22 | }
23 | }
24 | }
25 | cout << "NO\n";
26 | ```
27 |
28 | Although this approach works, it is not very efficient as it makes use of two nested for loops, resulting in a time complexity of $O(n^2)$.
29 | Now, let us use two pointers to solve the problem with lower time complexity.
30 | The first step is to sort the elements in the array in non-decreasing order.
31 |
32 | [2, 3, 7, 8, 9, 12, 14, 15]
33 |
34 | Next, we define two 'pointer' variables l and r.
35 | Note that pointers here does not refer to the C++ pointers datatype and is just an arbitrary name given to two int variables that keep track of indices in the array.
36 | l is initialised to 0 (the position of the first element in the array) and r is initialised to 7 (the position of the last element in the array).
37 |
38 | ```
39 | [2, 3, 7, 8, 9, 12, 14, 15]
40 | ^ ^
41 | l r
42 | ```
43 |
44 | The elements at l and r, that is 2 and 15, add upto 17, which is less than our required sum 20.
45 | As 2 paired with the maximum element cannot sum upto 20, we can conclude that any pair containing 2 cannot add upto 20.
46 | Since 2 has been eliminated, we increment l by 1, so that it now points to the next element, 3.
47 |
48 | ```
49 | [2, 3, 7, 8, 9, 12, 14, 15]
50 | ^ ^
51 | ```
52 |
53 | As 3 and 15 add upto 18, which is still less than 20, we can eliminate 3 too and move onto the next element 7.
54 |
55 | ```
56 | [2, 3, 7, 8, 9, 12, 14, 15]
57 | ^ ^
58 | ```
59 |
60 | 7 and 15 add upto 22, which is greater than 20, making this case different from the previous two cases.
61 | Now, instead of altering l, we alter r, decrementing it until the sum is less than or equal to 20.
62 | As it turns out, r has to be decremented until it becomes 5 and points to 12.
63 |
64 | ```
65 | [2, 3, 7, 8, 9, 12, 14, 15]
66 | ^ ^
67 | ```
68 |
69 | l is incremented to 3 (and now points to 8) as 19 is less than 20.
70 |
71 | ```
72 | [2, 3, 7, 8, 9, 12, 14, 15]
73 | ^ ^
74 | ```
75 |
76 | If you notice, the numbers that the two pointers now point to add upto exactly 20.
77 | Thus, we got the solution to our problem.
78 | The important thing to notice here is that incrementing l increases our sum while decrementing r decreases our sum.
79 |
What about the case where no problem exists, such as when x = 13?
80 | Then, we continue the process until l becomes equal to r, at which point we break out of the loop and conclude that no answer exists.
81 |
82 |
83 | C++ Implementation
84 |
85 | ```cpp
86 | void solve() {
87 | int n, x;
88 | cin >> n >> x;
89 | vector arr (n);
90 | for (int i = 0; i < n; i++) cin >> arr[i];
91 | sort (arr.begin(), arr.end());
92 | int l = 0, r = n - 1;
93 | while (l < r) {
94 | if (arr [l] + arr [r] < x)
95 | l++;
96 | else if (arr[l] + arr[r] > x)
97 | r--;
98 | else {
99 | cout << "YES\n" ;
100 | cout << arr[l] << ' ' << arr[r] << "\n";
101 | return;
102 | }
103 | }
104 | cout << "NO\n";
105 | }
106 | ```
107 |
108 |
109 |
110 |
111 | Python Implementation
112 |
113 | ```py
114 | def solve ():
115 | n, x = tuple (map (int, input ().split (' ')))
116 | arr = list (map (int, input ().split (' ')))
117 | arr.sort()
118 | l = 0
119 | r = n - 1
120 | while l < r:
121 | if arr[l] + arr[r] < x:
122 | l++
123 | elif arr[l] + arr[r] > x:
124 | r--
125 | else:
126 | print('YES')
127 | print(arr [l] + ' ' + arr [r])
128 | print('YES')
129 | ```
130 |
131 |
132 |
133 |
134 |
135 | ## Time Complexity
136 |
137 | It turns out that two pointers actually takes $O(n)$ time.
138 | If you notice, in every iteration of the loop, either l and r takes on a value that it has never taken beforei while maintaining the l ≤ r condition.
139 | It is not too hard to see that the maximum number of iterations is n - 1 (the two pointers will always collide after that and cannot move past each other due to the condition).
140 | Hence, there can only be a maximum of n - 1 iterations of the inner loop over all the iterations of the outer loop, resulting in the time complexity of the algorithm being $O(n)$.
141 | Note that the time complexity of the overall code is $O (n log n)$, as the array is sorted first in this case.
142 | In general, you can apply two pointers for greedy solutions when you can find certain properties that guarantee that both your two pointers always move in a specific direction (either left or right) without crossing over each other.
143 |
144 | ## Practice Problems
145 |
146 | 1. [Codeforces 381A - Sereja and Dima](https://codeforces.com/problemset/problem/381/A)
147 | 2. [Codeforces 1462A - Favorite Sequence](https://codeforces.com/problemset/problem/1462/A)
148 | 3. [Codeforces 1791 - Prepend and Append](https://codeforces.com/problemset/problem/1791/C)
149 | 4. [Codeforces 6C - Alex, Bob and Chocolate](https://codeforces.com/problemset/problem/6/C)
150 | 5. [Sum of Two Values](https://cses.fi/problemset/task/1640)
151 | 6. [Subarray Sums I](https://cses.fi/problemset/task/1660)
152 |
153 | ## Links
154 |
155 | 1. [GeeksForGeeks tutorial](https://www.geeksforgeeks.org/two-pointers-technique/)
156 | 2. [USACO tutorial](https://usaco.guide/silver/two-pointers?lang=cpp)
157 | 3. [Video visualisation by Josh's Dev Box](https://www.youtube.com/watch?v=On03HWe2tZM)
158 | 4. [Overview by Team AlgoDaily](https://www.youtube.com/watch?v=-gjxg6Pln50)
159 | 5. [Errichto solving LeetCode problems](https://www.youtube.com/watch?v=QwN-weNSrAg)
160 |
--------------------------------------------------------------------------------
/Week 2/1. Brute Force.md:
--------------------------------------------------------------------------------
1 | # Brute Force
2 |
3 | ## What is it?
4 |
5 |
Brute force is an approach of problem-solving that involves examining every potential solution to a problem.
6 | It is generally used in problems where you are asked to count the number of solutions or find the 'best' solution when the input size is quite small.
7 | Writing a brute force algorithm does not require a lot of logic building as it is the most simple and naive way of solving a particular problem.
8 |
9 | ## Number of subarrays with even sum
10 |
11 | ### Problem Statement
12 |
13 | You are given an array consisting of n integers.
14 | Your task is to find the number of subarrays of the array whose sum is even.
15 | Note that a subarray of an array is a contiguous section of an array that can be obtained by deleting elements at the beginning and at the end of the array.
16 |
17 | ### Sample Case
18 |
19 | Let us take the array [3, 7, 2, 6, 3, 4].
20 | [7, 2, 6, 3] is one subarray of this array whose sum is even.
21 | Our task is to write a program that calculates the total number of such subarrays.
22 | As it turns out, the answer for this particular array is 9.
23 |
24 | ### Solution
25 |
26 | The first step is to input the size of the original array and the values it contains.
27 | We declare a variable result that keeps track of the number of even sum subarrays.
28 | This is initialised to 0 as we have not examined any subarrays yet.
29 | As we are writing a brute force algorithm, we must examine every possible subarray of the array and count the number of subarrays whose sum is even.
30 | To iterate over every subarray, we use a nested for loop.
31 | The outer loop goes through every value for the start index of the subarray (l from 1 to n) and the inner loop goes through every corresponding possible values for the end index (r from i to n).
32 | Another loop is written to calculate the sum of the subarray - that is the sum of the elements in the array from index l to r.
33 | If the sum happens to be even, result is incremented by 1, else it is left unchanged.
34 | The code which is an implementation of this solution to the problem is given below.
35 |
36 |
37 | C++ Implementation
38 |
39 | ```cpp
40 | void solve () {
41 | int n;
42 | cin >> n;
43 | int array [n];
44 | for (int i = 0; i < n; i ++) {
45 | cin >> array [i];
46 | }
47 | int result = 0;
48 | for (int l = 0; l < n; l ++) {
49 | for (int r = l; r < n; r ++) {
50 | int sum = 0;
51 | for (int i = l; i <= r; i ++) {
52 | sum += array [i];
53 | }
54 | if (sum % 2 == 0) {
55 | result++;
56 | }
57 | }
58 | }
59 | cout << result << '\n';
60 | }
61 | ```
62 |
63 |
64 |
65 |
66 | Python Implementation
67 |
68 | ```py
69 | def solve ():
70 | n = int (input ())
71 | array = list (map (int, input ().split (' ')))
72 | result = 0
73 | for l in range (n):
74 | for r in range (l, n):
75 | sum = 0
76 | for i in range (l, r + 1):
77 | sum += arr [i]
78 | if sum % 2 == 0:
79 | result += 1
80 | print (result)
81 | ```
82 |
83 |
84 |
85 | To calculate the time complexity of the code, we see that the `l` and `r` loops will together run in $O(n^2)$ (to be precise, the number of iterations will be $n * (n - 1) / 2$, but we can ignore constants and lower order terms).
86 |
87 | The innermost loop that calculates the `sum` will (in the worst case) run in $O(n)$, making the total time complexity $O(n^3)$. (bonus: can you think of an algorithm to solve it in $O(n^2)$?)
88 |
89 | ## Number of Fibonacci sequences
90 |
91 | ### Problem statement
92 |
93 | In this problem, you have to find the number of Fibonacci sequences of length n and ending with the element k.
94 | A Fibonacci sequence is a sequence of non-decreasing positive integers defined by two starting elements (a1 ≤ a2) and the relation ai = ai-1 + ai-2 for i ≥ 3.
95 |
96 | ### Sample case
97 |
98 | Let us take n = 6 and k = 40.
99 | There are two valid sequences that can be constructed for these parameters, and they have beens listed below.
100 |
101 |
102 | 0, 8, 8, 16, 24, 405, 5, 10, 15, 25, 40
105 |
106 | Hence, the answer to this case is 2.
107 |
108 | ### Solution
109 |
110 | One way to approach this problem is to iterate over the possible values for the first two elements and construct the corresponding sequence.
111 | However, this is not ideal as there is no upper bound for the values that the two elements can take and this will result in high time complexity.
112 | The best alternative is to instead iterate over the values that the second-last element can take on.
113 | The values that it can take on are all integers from 0 to k.
114 | Using the last two elements, the sequence is constructed backwards using the relation ai = ai+2 - ai+1 for 0 ≤ i ≤ n - 2.
115 | If the constructed sequence is valid (non-decreasing with no negative integers), the sequence is considered as a possible solution.
116 |
117 |
118 | C++ Implementation
119 |
120 | ```cpp
121 | void solve () {
122 | int n, k;
123 | cin >> n >> k;
124 | int result = 0;
125 | for (int i = 0; i <= k; i ++) {
126 | int array [n];
127 | array [n - 1] = k;
128 | array [n - 2] = i;
129 | bool valid = true;
130 | for (int j = n - 2; j >= 0; j --) {
131 | array [j] = array [j + 2] - array [j + 1];
132 | if (array [j] < 0 || array [j] > array [j + 1]) {
133 | valid = false;
134 | break;
135 | }
136 | }
137 | if (valid) {
138 | result++;
139 | }
140 | }
141 | cout << result << '\n';
142 | }
143 | ```
144 |
145 |
146 |
147 |
148 | Python Implementation
149 |
150 | ```py
151 | def solve ():
152 | n, k = tuple (map (int, input ().split (' ')))
153 | result = 0
154 | for i in range (k + 1):
155 | array = [0] * n
156 | array [n - 1] = k
157 | array [n - 2] = i
158 | valid = True
159 | for j in range (n - 2, -1, -1):
160 | array [j] = array [j + 2] - array [j + 1]
161 | if array [j] < 0 or array [j] > array [j + 1]:
162 | valid = False
163 | break
164 | if valid:
165 | result += 1
166 | print (result)
167 | ```
168 |
169 |
170 |
171 | Looking at the code, the time complexity is clearly $O(k \cdot n)$.
172 |
173 | ## Note
174 |
175 | While brute force algorithms are very easy to implement most of the time as they do not require a lot of thinking, sometimes you will need to make some clever observations to simplify your implementation.
176 | However, the downside to using brute force algorithms is that they take a lot of time to execute, resulting in a high chance that your code gets the Time Limit Exceeded verdict.
177 | Brute force algorithms generally work for easy problems, but as you move towards solving tougher problems with tighter constraints, you will need to find better algorithms.
178 | In general, before coding anything, plan out your solution and calculate its time complexity. Based on the input size (and the rule of thumb about execution time), you will know if your approach will TLE or not.
179 |
180 | ## Practice problems
181 |
182 | 1. [Codeforces 4A - Watermelon](https://codeforces.com/problemset/problem/4/A)
183 | 2. [Codeforces 271A - Beautiful Year](https://codeforces.com/problemset/problem/271/A)
184 | 3. [Codeforces 1703C - Cypher](https://codeforces.com/problemset/problem/1703/C)
185 | 4. [Codeforces 25A - IQ test](https://codeforces.com/problemset/problem/25/A)
186 | 5. [Codeforces 1368A - C+=](https://codeforces.com/problemset/problem/1368/A)
187 | 6. [Codeforces 320A - Magic Numbers](https://codeforces.com/problemset/problem/320/A)
188 | 7. [Codeforces 734B - Anton and Digits](https://codeforces.com/problemset/problem/734/B)
189 | 8. [Codeforces 1382A - Common Subsequence](https://codeforces.com/problemset/problem/1382/A)
190 |
191 | ## Links to external resources
192 |
193 | 1. [Brute force algorithms](https://www.youtube.com/watch?v=BYWf6-tpQ4k)
194 | 2. [Introduction to brute force by GeeksForGeeks](https://www.geeksforgeeks.org/brute-force-approach-and-its-pros-and-cons/)
195 | 3. [Using brute force to crack passwords](https://www.kaspersky.com/resource-center/definitions/brute-force-attack)
196 |
--------------------------------------------------------------------------------
/Week 5/4. Graph Traversal.md:
--------------------------------------------------------------------------------
1 | # Graph Traversal
2 |
3 | There are two basic graph traversal algorithms:
4 | - Depth First Search (DFS)
5 | - Breadth First Search (BFS).
6 |
7 | Both do similar things: from one vertex $u$, go to another unvisited vertex $v$ by following the edge $(u, v)$. They are just using different underlying data structures (usually implicit–stack/recursion for DFS versus a queue for BFS) and so the order of visited nodes is different.
8 |
9 | Both DFS and BFS are $O(V+E)$ algorithms. However, on a case by case basis, one is more natural and efficient to implement than the other.
10 |
11 | You can look [this demo]((https://visualgo.net/en/dfsbfs?slide=1)) for a cool visualization of graph traversal.
12 |
13 | ## Breadth First Search
14 |
15 | BFS begins from a source and traverses nodes "breadth" wise. Nodes are traversed in order of shortest distance from the source node, which makes it useful to find distances from the source. The algorithm works alike for both directed and unweighted graphs. Finding distances using BFS, however, works only for unweighted graphs.
16 |
17 | The BFS uses a queue to simulate the graph traversal. We push nodes into the queue in the order of distances (the BFS order). Note that the front of the queue always will have the closest node to the source, and the source itself in the beginning of the BFS.
18 |
19 | In every iteration, we pop the first node from the queue and push all its adjacent unvisited vertices into the queue. Therefore, each node is visited atmost once. We can find the distances from the source while doing the BFS traversal itself.
20 |
21 | Suppose the node $a$ has a distance $d$ from the source $s$. The node $a$ is then popped from the queue and an adjacent node $b$ is pushed into the queue. Since the graph is unweighted, the distance from $b$ to the source $s$ will be $d + 1$. Using this property, we find the distances from the source $s$. The initial node pushed into the queue is the source itself with distance as 0.
22 |
23 | ```cpp
24 | void bfs(int source) {
25 | vector d(n, -1); //-1 is unvisited
26 | d[source] = 0;
27 | queue q;
28 | q.push(source);
29 | while(!q.empty()) {
30 | int v = q.front(); q.pop();
31 | for(int u : g[v]) { //g is adjacency list of the graph
32 | if(d[u] == -1) {
33 | d[u] = d[v] + 1;
34 | q.push(u);
35 | }
36 | }
37 | }
38 | }
39 | ```
40 |
41 | You can also do a BFS from multiple sources: instead of pushing just the single source into the queue initially, you push all the sources into the queue (with their distances marked as 0). We can use this to find the minimum distance of any node v to any of the sources. This is a technique known as multi-source BFS.
42 |
43 | ## Depth First Search (DFS)
44 |
45 | Starting from a source vertex, DFS will traverse the graph ‘depth-first’. Every time it hits a branching point (a vertex with more than one neighbors), DFS will choose one of the unvisited neighbor(s) and visit this neighbor vertex.
46 |
47 | DFS repeats this process and goes deeper until it reaches a vertex where it cannot go any deeper. When this happens, DFS will ‘backtrack’ and explore another unvisited neighbor(s), if any. One call of `dfs(u)` will only visit all vertices that are directly / indirectly connected to (or reachable from) vertex u.
48 |
49 | There are two ways to implement DFS: using recursion or a stack. The stack implementation is rarely used in competitive programming, mainly because using recursion is much shorter and cleaner.
50 |
51 | (Sidenote: the recursive implementation actually uses the fact that function calls also operate on an internal stack, which means that coneceptually the two approaches are still the same.)
52 |
53 | ```cpp
54 | set seen;
55 | void dfs(int cur)
56 | {
57 | seen.insert(cur);
58 | for (auto &[v, w] : list[u])
59 | {
60 | if (seen.count(v))
61 | dfs(v);
62 | }
63 | }
64 | ```
65 |
66 | One easy application of DFS is in checking if a directed graph is acyclic or not as directed acyclic graphs (DAGs) have very useful properties that can simplify certain types of problems greatly.
67 |
68 | We can simply run DFS / BFS from some source vertex. If we see a vertex that we have already seen, we have just traversed a cycle. Running a DFS from this vertex and storing the sequence of nodes we visit will give you the cycle.
69 |
70 | ## Connected Components
71 |
72 | A connected component is a maximal connected subgraph (it is a connected subgraph that is not part of any larger connected subgraph). Any graph can be partitioned into a number of connected components and in many graph problems, we come up with a solution for a connected graph and extend it for all graphs by repeating for each connected component.
73 |
74 | To list all connected components, we first pick some vertex and then run DFS / BFS to find all vertices that are connected to it. The set of vertices we visit forms a connected component. We then pick some vertex we have not visited and repeat until we visit every single vertex.
75 |
76 | ```cpp
77 | int seen[n];
78 | vector comp;
79 |
80 | void dfs(int cur)
81 | {
82 | if (seen[cur]) return;
83 | seen[cur] = 1;
84 | comp.pb(i);
85 | for (auto &i : g[cur])
86 | {
87 | dfs(i);
88 | }
89 | }
90 |
91 | int main()
92 | {
93 | // ...graph input in g...
94 | vector> comps;
95 | for (int i = 0; i < n; i++)
96 | {
97 | if (seen[i]) continue;
98 | comp.clear();
99 | dfs(i);
100 | comps.push_back(comp);
101 | }
102 | }
103 | ```
104 |
105 | ## Flood Fill
106 |
107 | Flood fill is similar to BFS and DFS. The only change is that instead of nodes of a graph, we are dealing with adjacent squares in a 2D grid. You can think of the cells in the grid as nodes, and when two cells are next to each other, you can make an edge between them.
108 |
109 | Here is some code that finds the size of the connected component that encloses $(r, c)$ in a 2D grid:
110 | ```cpp
111 | int dr[] = { 1, 1, 0,-1,-1,-1, 0, 1};
112 | int dc[] = { 0, 1, 1, 1, 0,-1,-1,-1}; // the order is: // S/SE/E/NE/N/NW/W/SW
113 |
114 | int floodfill(int r, int c, char c1, char c2) // returns the size of CC
115 | {
116 | if ((r < 0) || (r >= R)) return 0; // outside grid, part 1
117 | if ((c < 0) || (c >= C)) return 0; // outside grid, part 2
118 | if (grid[r][c] != c1) return 0; // does not have color c1
119 | int ans = 1; // (r, c) has color c1
120 | grid[r][c] = c2; // to avoid cycling
121 |
122 | for (int d = 0; d < 8; ++d)
123 | ans += floodfill(r+dr[d], c+dc[d], c1, c2); // the code is neat as we use dr[] and dc[]
124 | return ans;
125 | }
126 | ```
127 |
128 | ## Bipartite Graphs
129 |
130 | A bipartite graph is a graph whose nodes can be partitioned into two sets such that each edge is from one set to another and no edge connects nodes in the same set.
131 |
132 | Another way to think about it as that each node can be 'coloured' in one of two colours and no two nodes of the same colour are adjacent. Many problems often not even evident to be a graph problem can be solved by modelling it as a bipartite graph problem.
133 |
134 | Lets look at the problem [Among Us](https://www.codechef.com/INOIPRAC/problems/AMONGUS2) from INOI 2021.
135 |
136 | There are $N$ astronauts (numbered $1$ to $N$) who suspect there are parasites among them and $Q$ statements from them. Each statement made by astronaut $i$ about $j$ is of two types:
137 | - Type 1 : i accuses j of being a parasite
138 | - Type 2 : i vouches j of being a human.
139 |
140 | Given that no human tells a lie and no parasite tells the truth, you need to find whether the statements made by the astronauts are consistent. If they are consistent, report the maximum possible number of parasites.
141 |
142 | For the solution, we'll call the two types of people liars and truthfuls.
143 |
144 | There are two types of statements.
145 |
146 | - `1 i j` : $i$ accuses $j$ of being a liar.
147 |
148 | If $i$ is truthful, then $j$ is a liar.
149 |
150 | If $i$ is a liar, then $j$ is truthful.
151 |
152 | - `2 i j` : $i$ vouches of $j$ being truthful.
153 |
154 | If $i$ is truthful, then $j$ is truthful.
155 |
156 | If $i$ is a liar, then $j$ is a liar.
157 |
158 | This means that any pair $(i,j)$ associated with type 1 statements are of opposite types and those associated with type 2 statements are of the same types.
159 |
160 | This means that we can model the problem as a graph with $N$ nodes and $Q$ edges where each edge is of 2 types: a type 1 edge connects two nodes $i$ and $j$ of opposite colours while a type 2 edge connects two nodes $i$ and $j$ of the same colour.
161 |
162 | We can then colour the nodes using DFS by arbitarily asssigning a colour to the starting node. If the same node is coloured twice with opposite colours, it is inconsistent.
163 |
164 | Since we can always flip the colour of all nodes and still have a valid colouring, count the number of nodes of each kind of colour and print the maximum among them for the answer.
165 |
166 | ## Problems
167 |
168 | - [Labyrinth](https://cses.fi/problemset/task/1193)
169 | - [Maze](https://codeforces.com/problemset/problem/377/A)
170 | - [Wealth Disparity](https://www.codechef.com/INOIPRAC/problems/INOI1601)
171 | - [Multihedgehog](https://codeforces.com/contest/1068/problem/E)
172 | - [Department Strengths](https://www.codechef.com/INOIPRAC/problems/INOI2001)
173 | - [Counting Rooms](https://cses.fi/problemset/task/1192)
174 | - [Building Roads](https://cses.fi/problemset/task/1666)
175 | - [Labyrinth](https://cses.fi/problemset/task/1193)
176 | - [Icy Perimeter](http://www.usaco.org/index.php?page=viewproblem2&cpid=895)
177 | - [Fence](http://www.usaco.org/index.php?page=viewproblem2&cpid=895)
178 | - [UVa 00469 - Wetlands of Florida](https://onlinejudge.org/index.php?option=onlinejudge&Itemid=8&page=show_problem&problem=410)
179 | - [Building Teams](https://cses.fi/problemset/task/1668)
180 |
--------------------------------------------------------------------------------
/Week 4/2. Binary Search.md:
--------------------------------------------------------------------------------
1 | # Binary Search
2 |
3 | ## Introduction
4 |
5 | Divide and Conquer (D&C) is a problem-solving paradigm in which a problem is made simpler by ‘dividing’ it into smaller parts and then conquering each part. The steps:
6 |
7 | 1. Divide the original problem into sub-problems—usually by half or nearly half,
8 | 2. Find (sub)-solutions for each of these sub-problems—which are now easier,
9 | 3. If needed, combine the sub-solutions to get a complete solution for the main problem.
10 |
11 | You have learnt in the previous weeks about a few divide and conquer techniques. $O(n \log n) $ Sorting algorithms like merge sort, heap sort etc work on this principle. Data structures like `set` use D&C methods to store date. However, the most common use of it is binary search.
12 |
13 |
14 |
15 | ## Standard Usage
16 |
17 | Binary search refers to searching for an element in a sorted array by repeatedly splitting it into halves and referring to the middle element. Consider an array sorted in ascending order. The following code can be used to search for an element in the array.
18 |
19 | ```cpp
20 | while (l <= r)
21 | {
22 | mid = (l + r) / 2;
23 | if (arr[mid] == x)
24 | cout << "Found!" << "\n";
25 | if (x < arr[mid])
26 | r = mid - 1;
27 | if (x > arr[mid])
28 | l = mid + 1;
29 | }
30 | ```
31 |
32 | Notice how the left and right limits of the search range are dynamically changed to narrow down on the element we want to search.
33 |
34 | We check the middle of the sorted array to determine if it contains what we are looking for. If it is or there are no more items to consider (l > r), we stop.
35 |
36 | Otherwise, we can decide whether the answer is to the left or right of the middle element and continue searching. If `x` is smaller than the middle element, it will obviously be smaller than everything in the left half (because it's in ascending order) and so we can update `l` to ignore that part.
37 |
38 | As the size of search space is halved (in binary fashion) after each check, we can see that:
39 |
40 | $$ 2^{ops} \approx n $$
41 |
42 | This means that its time complexity is $O(log n)$.
43 |
44 | (If you're curious about analysing divide and conquer time complexities in general, read up on the [master theorem](https://en.wikipedia.org/wiki/Master_theorem_(analysis_of_algorithms)))
45 |
46 | As mentioned before, two C++ STL functions `lower_bound` and `upper_bound` are very useful in this context and will save you the effort of implementing the binary search.
47 |
48 | - `lower_bound(start_ptr, end_ptr, num)`:
49 |
50 | Returns a pointer to the first position of a number greater than or equal to num
51 |
52 | - `upper_bound(start_ptr, end_ptr, num)`:
53 |
54 | Returns a pointer to the first position of a number strictly greater than num
55 |
56 | The `start_ptr` variable holds the starting point of the binary search and `end_ptr` holds the ending position of binary search space and `num` is the value to be found.
57 |
58 | To get the actual index, just subtract the first position i.e `vec.begin()` from the pointer.
59 |
60 | While this method is quite useful on its own, it becomes very powerful when extended in general.
61 |
62 |
63 |
64 | ## Bisection Method
65 |
66 | The binary search principle can be extended to compute the root of a function (its zero) **as long as it is monotonic**.
67 |
68 | Assume you are taking a loan of $x$ rupees from the bank at an interest rate of $i$ % for $m$ months. You need to compute the installment $d$ that you need to pay per month such that the loan is payed in the given time.
69 |
70 | The bank charges interst on the unpaid loan at the end of each month. In short, you need to compute $d$ such that $f(d) \approx 0$ for given $x$, $m$ and $i$.
71 |
72 | Let us take an example with $m$ = 2 months, $x$ = 1000 rupees and $i$ = 10%.
73 |
74 | An easy way to solve this root finding problem is to use the bisection method.
75 |
76 | We pick a reasonable range as a starting point. We want to find $d$ within the range $[a, b]$ where $a = 0.01$ (we have to pay at least one paisa) and $b = (1 + \frac{i}{100}) * x$ (the earliest we can complete is $m = 1$ if we pay exactly $(1 + \frac{i}{100}) * x$ rupees after one month. In this example, $b = (1 + 0.1) * 1000 = 1100.00$ rupees.
77 |
78 | 
79 |
80 | Notice that bisection method only requires $O(log((b-a)/\epsilon))$ iterations to get an answer with error smaller than $\epsilon$. In this example, bisection method only takes $log(1099.99/\epsilon)$ tries, which is only 40 iterations for $\epsilon = 10^{-9}$ , this yields only $\approxeq$ 40 iterations, which is incomprehensibly faster than the brute force solution.
81 |
82 | However, this is still not the most general form of binary search.
83 |
84 |
85 |
86 | ## Binary Search on Answer
87 |
88 | Consider a boolean function $f: {l, l + 1, ... r} \rightarrow {0, 1}$ that is monotonous on $[l, r]$, that is:
89 |
90 | $$ f(l) \le f(l + 1) \le ... \le f(r) $$
91 |
92 | or
93 |
94 | $$ f(l) \ge f(l + 1) \ge ... \ge f(r) $$
95 |
96 | Binary search finds the unique index $x$ such that $f(x) = f(l)$ and $f(x + 1) = f(r)$ or reports that it does not exist.
97 |
98 | The time complexity will be $O(T * (r - l))$ where $T$ is the time complexity of the function $f$. This means that we can use binary search for **finding the changing point of any monotonous function we define**.
99 |
100 | This can be very useful for certain problems where checking if a solution is valid is easy but finding the solution with a specific property is much harder (as long as the associated boolean function is monotonic).
101 |
102 | We can take the initial range $[l, r]$ as the range of all possible solutions and run our binary search by checking if the current solution is valid:
103 |
104 | ```cpp
105 | // This finds the first index on [l, r] at which `f` is true
106 | ll ans = r + 1;
107 | while (l <= r)
108 | {
109 | ll mid = (l + r) / 2;
110 | if (f(mid))
111 | {
112 | ans = mid;
113 | r = mid - 1;
114 | }
115 | else
116 | {
117 | l = mid + 1;
118 | }
119 | }
120 | cout << ans << "\n";
121 | ```
122 |
123 | To make things clear, let's look at an example.
124 |
125 |
126 |
127 | ## Array Division
128 |
129 | Given an array of positive integers $a_1, a_2...a_n$, divide it into $k$ subarrays such that the maximum sum of a subarray is as small as possible.
130 |
131 | On its own, this type of minimising the maximum along with the partitions seems pretty hard to solve using normal methods.
132 |
133 | Let us think of the related checking problem: given a value $x$, can you divide array $a$ into $k$ subarrays such that the maximum sum of a subarray is atmost $x$?
134 |
135 | Note that this would mean that all subarray would have to have sum less than $x$. This means we can use a greedy strategy: greedily extend the current subarray as long as its sum is atmost $x$ and start a new subarray once it exceeds $x$.
136 |
137 | Finally, we will check if the number of subarrays created is atmost $k$ to see if using $x$ as the solution is valid or not. This will have time complexity $O(n)$.
138 |
139 | (Note that having fewer partitions is never a problem, we can always split it up more and the sum will still never cross $k$)
140 |
141 | Now, we can binary search on the answer $x$ since if $x$ is a valid solution, any $y \gt x$ is also a valid solution (if the maximum sum of a subarray is less than $x$, then clearly it is less than $y$ as well), which means it is monotonic.
142 |
143 | The total time complexity will be $O(n * log (MAXSUM))$.
144 |
145 |
146 |
147 | Implementation
148 |
149 | ```cpp
150 | #include
151 | using namespace std;
152 | typedef long long ll;
153 |
154 | bool f(const vector &arr, const ll k, ll maxsum)
155 | {
156 | ll count = 0;
157 | ll cur = 0;
158 |
159 | for (auto &i : arr)
160 | {
161 | if (i > maxsum)
162 | return false;
163 | if (cur + i > maxsum)
164 | {
165 | count++;
166 | cur = 0;
167 | }
168 | cur += i;
169 | }
170 |
171 | if (cur > 0)
172 | count++;
173 |
174 | return count <= k;
175 | }
176 |
177 |
178 | int main()
179 | {
180 | ll n, k;
181 | cin >> n >> k;
182 |
183 | vector arr(n);
184 | for (ll &i : arr)
185 | cin >> i;
186 |
187 | ll l = 0, r = 3e14;
188 |
189 | ll ans = r + 1;
190 | while (l <= r)
191 | {
192 | ll mid = (l + r) / 2;
193 | if (f(arr, k, mid))
194 | {
195 | ans = mid;
196 | r = mid - 1;
197 | }
198 | else
199 | {
200 | l = mid + 1;
201 | }
202 | }
203 | cout << ans << "\n";
204 | return 0;
205 | }
206 | ```
207 |
208 |
209 |
210 |
211 |
212 | ## Problems
213 |
214 | A great resource for binary search in general is the Codeforces EDU course.
215 |
216 | **1. Workout Prep:**
217 | - [Binary Search](https://leetcode.com/problems/binary-search)
218 | - [Search Insert Position](https://leetcode.com/problems/search-insert-position/)
219 | - [Sum of Two Values](https://cses.fi/problemset/task/1640)
220 | - [Sum of Three Values](https://cses.fi/problemset/task/1641)
221 |
222 | **2. Warmup:**
223 | - [Firefly](https://open.kattis.com/problems/firefly)
224 | - [Room Painting](https://open.kattis.com/problems/roompainting) [hint : use `lower_bound`]
225 | - [Out of Sorts](https://open.kattis.com/problems/outofsorts)
226 | - [Fibonaccharsis](https://codeforces.com/problemset/problem/1853/B)
227 | - [Search a 2D Matrix II](https://leetcode.com/problems/search-a-2d-matrix-ii/)
228 | - [Valid Perfect Square](https://leetcode.com/problems/valid-perfect-square/)
229 | - [Subarray Sums II](https://cses.fi/problemset/task/1661)
230 |
231 | **3. Core Workout:**
232 | - [Vika and the Bridge](https://codeforces.com/problemset/problem/1848/B)
233 | - [XOR Partition](https://codeforces.com/problemset/problem/1849/F)
234 | - [Toy Blocks](https://codeforces.com/problemset/problem/1452/B)
235 | - [Sage's Birthday](https://codeforces.com/problemset/problem/1419/D2)
236 | - [Keshi Is Throwing a Party](https://codeforces.com/problemset/problem/1610/C)
237 | - [Dubious Cyrpto](https://codeforces.com/problemset/problem/1379/B)
238 | - [Subarray Divisibility](https://cses.fi/problemset/task/1662)
239 | - [Array Division](https://cses.fi/problemset/task/1085)
240 |
241 |
242 |
--------------------------------------------------------------------------------
/Week 1/6. Basic Math.md:
--------------------------------------------------------------------------------
1 | # Basic Math
2 | ## Modular Arithmetic:
3 |
4 | In mathematics, modular arithmetic is a system of arithmetic for integers, where numbers "wrap around" when reaching a certain value, which is called the modulus. This means that a "modulo $m$" system has only $m$ numbers: $0, 1 ... m - 1$.
5 |
6 | Meanwhile in programming, the modulo operator `a % b` calculates the remainder on dividing `a` by `b`. Most elementary properties of modular arithmetic are quite obvious:
7 | - $`(a + b) \, mod \, m \equiv (a \, mod \, m + b \, mod \, m) \, mod \, m`$
8 | - $`(a - b) \, mod \, m \equiv (a \, mod \, m - b \, mod \, m) \, mod \, m`$
9 | - $`(a \cdot b) \, mod m \equiv (a \, mod \, m \cdot b \, mod \, m) \, mod \, m`$
10 |
11 | Often in competitive coding, you will come across problems in which the input constraint would be such that the output exceeds even $10^{18}$! And such problems often ask you to output the answer modulo m where m is a large number like $10^9+7$. In such scenarios, you would require modular arithmetic to compute the answer efficiently and accurately.
12 |
13 | Given 3 numbers $p$, $q$ and $m$, we may need to compute the value of $p^q mod m$. However, if $q$ is very large ($\approx 10^{18}$), simply multiplying $p$ with itself $q$ times (while taking modulo) will be too inefficient as the time complexity is $O(q)$.
14 |
15 | Instead, notice this property:
16 | - $`p^2 \, mod \, m \equiv (p)^2 \, mod \, m`$
17 | - $`p^4 \, mod \, m \equiv (p^2)^2 \, mod \, m`$
18 | - $`p^8 \, mod \, m \equiv (p^4)^2 \, mod \, m`$
19 |
20 | ...and so on.
21 |
22 | So, we can calculate $p^k$ where $k$ is a power of 2 simply by repeated squaring.
23 |
24 | Since $a^{b+c} = a^b \cdot a^c$, if we can write $q$ as a sum of some powers of 2, we could multiply the corresponding values from the squaring (while taking modulo) and get our answer.
25 |
26 | Since the binary representation of $q$ tells us exactly that, we can go over each bit from right to left, multiply the current power value if the bit is set and update the power value by squaring it.
27 |
28 | Since our loop goes over each bit of $q$ once and the number of bits in $x$ is approximately $`log \, x`$, the time complexity of this approach is $`O(log \, x)`$.
29 |
30 |
31 | C++ Implementation
32 |
33 | ```cpp
34 | long long mod_exp(long long p, long long q , long long m)
35 | {
36 | long long ans = 1;
37 | // stores the current value of p^k where k is a power of 2 representing the current bit
38 | long long cur = p;
39 |
40 | while (q != 0)
41 | {
42 | // if last bit is 1, multiply cur to ans
43 | if (q % 2 == 1)
44 | ans = (ans * cur) % m;
45 |
46 | // remove last bit
47 | q /= 2;
48 |
49 | // update cur by squaring
50 | cur = (cur * cur) % m;
51 | }
52 | return ans;
53 | }
54 | ```
55 |
56 |
57 |
58 | Python Implementation
59 |
60 | ```py
61 | def expo(p, q, m):
62 | ans = 1
63 | # stores the current value of p^k where k is a power of 2 representing the current bit
64 | cur = p
65 |
66 | while q != 0:
67 | # If q is odd, multiply p with ans
68 | if q % 2 == 1:
69 | ans = (ans * cur) % m
70 |
71 | # remove last bit
72 | q /= 2
73 |
74 | # update cur by squaring
75 | cur = (cur * cur) % m
76 |
77 | return ans
78 | ```
79 |
80 |
81 | **Links:**
82 | 1. https://cp-algorithms.com/algebra/binary-exp.html
83 | 2. [Exponentiation](https://cses.fi/problemset/task/1095)
84 | 3. [Count Good Numbers](https://leetcode.com/problems/count-good-numbers/)
85 |
86 |
87 |
88 | ## Primes and Factors:
89 |
90 | ### Sieve of Eratosthenes:
91 |
92 | Given a number $n$, we can find all prime numbers smaller than $n$ using the Sieve of Eratosthenes.
93 |
94 | The algorithm works on the principle that multiples of a prime are not prime numbers. We first mark every number as a prime and then iterate over them. If a number is marked as a prime, we mark all of its multiples as being not prime.
95 |
96 | While the below implementation may seem like an $O(n^2)$ algorithm because of the two nested loops, its actual time complexity is $`O(n \, log(log \, n)))`$ ([here](https://cp-algorithms.com/algebra/sieve-of-eratosthenes.html#asymptotic-analysis) is the derivation if you're interested).
97 |
98 | You can use this to precompute all primes (up to a certain number) and then use them for every test case/query with $O(1)$ access time.
99 |
100 |
101 | C++ Implementation
102 |
103 | ```cpp
104 | // prime[i] = 1 if prime, 0 if not
105 | // first, we mark everything as prime
106 | vector prime (n+1, 1);
107 | prime[1] = 0;
108 | prime[0] = 0;
109 | for (int i = 2; i <= n; i++)
110 | {
111 | if (!prime[i]) continue;
112 | // Here, we know i is prime
113 | // The multiples of i below i^2 would have already been marked previously under the other prime factor (that would be smaller than i) and so we start marking from i^2
114 | for (int j = i * i; j <= n; j += i)
115 | prime[j] = 0;
116 | }
117 | ```
118 |
119 |
120 |
121 | Python Implementation
122 |
123 | ```py
124 | # prime[i] = True if prime, False if not
125 | # first, we mark everything as prime
126 | n = 100
127 | prime = [True] * (n + 1)
128 | prime[0] = False
129 | prime[1] = False
130 | for i in range(2, n + 1):
131 | if not prime[i]:
132 | continue
133 | # Here, we know i is prime
134 | # The multiples of i below i^2 would have already been marked previously under the other prime factor (that would be smaller than i) and so we start marking from i^2
135 | j = i * i
136 | while j <= n:
137 | prime[j] = False
138 | j += i
139 | ```
140 |
141 |
142 |
143 |
144 | ### Prime Factorisation :
145 |
146 | Every positive integer $n$ can be expressed in the form of:
147 | $$n = p_1^{a_1} \cdot p_2^{a_2} ... p_i^{a_i}$$
148 | where $p_i$ is a prime number and $a_i$ is a positive integer.
149 |
150 | A simple way of computing the prime factors of $n$ can be done by repeatedly dividing $n$ by its smallest factor. Since it is impossible that all prime factors of $n$ are bigger than
151 | $\sqrt{n}$, we only need to test factors till $\sqrt{n}$, making the time complexity of this approach is $O(\sqrt{n})$.
152 |
153 |
154 | C++ Implementation
155 |
156 | ```cpp
157 | vector fact(int n)
158 | {
159 | vector pf;
160 | // Iterate over all possible divisors from 2 to sqrt(n)
161 | for (int i = 2; i * i <= n; i++)
162 | {
163 | // as long as it is a factor, repeatedly divide it out
164 | while (n % i == 0)
165 | {
166 | pf.push_back(i);
167 | n /= i;
168 | }
169 | }
170 | // if we could not find any factors from 2 to sqrt(n), the number itself is prime
171 | if (n > 1)
172 | pf.push_back(n);
173 | return pf;
174 | }
175 | ```
176 |
177 |
178 |
179 | Python Implementation
180 |
181 | ```py
182 | def fact(n):
183 | pf = []
184 | # Iterate over all possible divisors from 2 to sqrt(n)
185 | i = 2
186 | while i * i <= n:
187 | # as long as it is a factor, repeatedly divide it out
188 | while n % i == 0:
189 | pf.append(i)
190 | n //= i
191 | i += 1
192 | # if we could not find any factors from 2 to sqrt(n), the number itself is prime
193 | if n > 1:
194 | pf.append(n)
195 | return pf
196 | ```
197 |
198 |
199 |
200 |
201 | ### LCM and GCD:
202 |
203 | Given two integers $a$ and $b$ such that $c = gcd(a,b)$ and $d = lcm(a,b)$, then :
204 | $$a \cdot b = c \cdot d$$
205 |
206 | The Euclidean algorithm for finding $gcd(a,b)$ is
207 |
208 | ```math
209 |
210 | \text{gcd}(a, b) =
211 | \begin{cases}
212 | a & \text{if } b = 0 \\
213 | \text{gcd}(b, a \bmod b) & \text{otherwise}
214 | \end{cases}
215 |
216 |
217 | ```
218 |
219 | GCD and LCM computations are quite common in many competitive coding problems owing to their vast applications.
220 |
221 |
222 | C++ Implementation
223 |
224 | ```cpp
225 | int gcd(int a, int b)
226 | {
227 | return b == 0 ? a : gcd(b, a % b);
228 | }
229 | ```
230 |
231 |
232 |
233 | Python Implementation
234 |
235 | ```py
236 | def gcd(a, b):
237 | return b == 0 ? a : gcd(b, a % b)
238 | ```
239 |
240 |
241 |
242 |
243 | ### Links:
244 | 1. https://cp-algorithms.com/algebra/sieve-of-eratosthenes.html
245 | 2. https://cp-algorithms.com/algebra/factorization.html#trial-division
246 | 3. [Count Primes](https://leetcode.com/problems/count-primes/)
247 | 4. [Factorial Trailing Zeroes](https://leetcode.com/problems/factorial-trailing-zeroes/)
248 | 5. [Sum of Divisors](https://cses.fi/problemset/task/1082)
249 | 6. [Counting Divisors](https://cses.fi/problemset/task/1713)
250 | 7. [Omkar and Last Class of Math](https://codeforces.com/problemset/problem/1372/B)
251 |
252 |
253 |
254 | ## Binomial Coefficients:
255 | The binomial coefficient, which is denoted be $n \choose k$, is the number of ways of choosing k elements from a set of n elements. Combinatorics problems often involve manipulating the properties of binomial systems to calculate outputs in the most efficient way. Some of the key properties are:
256 |
257 | ```math
258 | {n \choose k} = {n-1 \choose k-1} + {n-1 \choose k} \\
259 | and \\
260 | {n \choose k} = {n \choose n-k}
261 | ```
262 |
263 | This recursive nature can be used to compute the binomial coefficients of a required system:
264 |
265 |
266 | C++ Implementation
267 |
268 | ```cpp
269 | int choose(int n, int k)
270 | {
271 | // n choose 0 = n choose n = 1
272 | if k == 0 or k == n:
273 | return 1
274 | return choose(n - 1, k - 1) + choose(n - 1, k);
275 | }
276 | ```
277 |
278 |
279 |
280 | Python Implementation
281 |
282 | ```py
283 | def choose(n, k):
284 | # n choose 0 = n choose n = 1
285 | if k == 0 or k == n:
286 | return 1
287 | return choose(n - 1, k - 1) + choose(n - 1, k)
288 | ```
289 |
290 |
291 | However, this method is will fail after about $n = 20$. Better methods that are required to compute the same will be explored in further sections.
292 |
--------------------------------------------------------------------------------
/Week 4/1. Data Structures.md:
--------------------------------------------------------------------------------
1 | # Data Structures
2 |
3 | ## Introduction
4 |
5 | A data structure is some structure chosen for organising, managing, and storing data.
6 | Arrays, sets, maps, stacks, queues etc. are some commonly-used data structures.
7 | We have already covered several basic data structures over the previous weeks of this workshop. In this section, we will be jumping straight ahead into some of the more advanced and useful ones.
8 |
9 | ## `pair`
10 |
11 | A pair is an ordered collection of two elements.
12 | One use case of pairs is representing points on the cartesian plane, as each point has two values associated with it - its x-coordinate and y-coordinate.
13 |
14 | ```cpp
15 | pair p;
16 | p.first = 3;
17 | p.second = 5;
18 |
19 | // different types + nesting also supported
20 | pair> q;
21 | q.first = "hello";
22 | q.second = {1, 2}; // initialiser lists can be used to initialise pairs
23 | ```
24 |
25 | While comparing two pairs, the first elements in each pair are first compared, followed by their second elements.
26 | This means that they also easily support sorting like other data types.
27 |
28 | ## `stack`
29 |
30 | A stack is an ordered collection of elements in which elements are added and removed from only one side (usually called the top).
31 | To visualise the working of a stack, think of a stack of books.
32 | When you want to add a new book to the stack, you can only place it at the top.
33 | Similarly, the only book in a stack that can be directly removed is the top-most one.
34 | Removing books apart from the topmost one would require removing all the books above it first.
35 | A stack is often described as a Last In First Out (LIFO) data structure as the last element to be inserted into a stack is also the first to be removed.
36 |
37 | ```cpp
38 | stack s;
39 | ```
40 |
41 | Here are some commonly-used stack methods.
42 |
43 | 1. `push (x)` - adds the element `x` to the end of the stack
44 | 2. `top ()` - returns the topmost element
45 | 3. `pop ()` - removes the topmost element
46 | 4. `size ()` - returns the number of elements
47 | 5. `empty ()` - removes every element
48 |
49 | Don't forget to check if the stack is non-empty before calling `top()` or `pop()` to prevent runtime errors.
50 |
51 | Two great use cases for stacks in CP are to find the position of the matching bracket in an expression and to find the next smaller / larger element of all elements in an array.
52 |
53 | ## `queue`
54 |
55 | A queue is also an ordered collection of elements, but what differentiates queues from stacks is the fact that elements are removed from the side opposite to the one where elements are added.
56 | Queues are named as such because queues in the real world are also First In First Out (FIFO) - the first element to be inserted (enter) into a queue is the first to be removed (exit).
57 | The below code instantiates a queue of integers.
58 |
59 | ```cpp
60 | queue q;
61 | ```
62 |
63 | Given below are some commonly-used queue methods.
64 |
65 | 1. `push (x)` - adds the element `x` to the end of the queue
66 | 2. `front ()` - returns the first element
67 | 3. `back ()` - returns the last element
68 | 4. `pop ()` - removes the first element
69 | 5. `size ()` - returns the number of elements
70 | 6. `empty ()` - removes every element
71 |
72 | ## `priority_queue`
73 |
74 | A priority queue is similar to a regular queue, except that the elements in a priority queue are sorted according to their values and not according to the order in which they are inserted in.
75 | This means that no matter what order elements are inserted in, they will always remain sorted in ascending order inside the container.
76 | The below code instantiates a priority queue of integers.
77 |
78 | ```cpp
79 | priority_queue pq;
80 | ```
81 |
82 | To demonstrate the difference between a regular queue and a priority queue, let us consider a queue q and a priority queue pq, both of which currently hold the elements [2, 3, 5, 11, 13, 17].
83 |
We now add the element 7 to both q and pq.
84 | In q, the elements now follow the order [2, 3, 5, 11, 13, 17, 7], as new elements always get added to the end regardless of their value.
85 | However, in pq, the elements are stored in the order [2, 3, 5, 7, 11, 13, 17], as new elements are added in such a way that the ascending order is maintained.
86 | Now, let us look at some commonly-used priority queue methods.
87 |
88 | 1. `push (x)` - adds the element `x` to the priority queue
89 | 2. `top ()` - returns the greatest element
90 | 3. `pop ()` - removes the greatest element
91 | 4. `size ()` - returns the number of elements
92 | 5. `empty ()` - removes every element
93 |
94 | You can specify the comparator of the sorting as well:
95 | ```cpp
96 | // for ascending order, use the inbuilt `greater` comparator
97 | priority_queue, greater> pq;
98 | ```
99 |
100 | An interesting thing to note is that a `set` / `map` is nearly identical to a `priority_queue`, with the main difference being that `set` / `map` sorts in ascending while `prioriity_queue`sorts in descending by default.
101 |
102 | ## `iterator`
103 |
104 | An iterator is a object that can point to elements in C++ STL data structures.
105 | It is the STL equivalent of regular C++ pointers.
106 | For the purpose of simplicity, in this section, we will be dealing with iterators to vector elements specifically.
107 | Here is the syntax for defining an iterator it.
108 |
109 | ```cpp
110 | vector :: iterator it;
111 | ```
112 |
113 | Let us look at how to loop over the elements of a vector using iterators.
114 |
115 | ```cpp
116 | for (it = arr.begin (); it < arr.end (); it ++) {
117 |
118 | }
119 | ```
120 |
121 | The begin () method returns an iterator to the first element of the vector.
122 | The end () method, however, does not return an iterator to the last element like how you would expect it to.
123 | Instead, it returns a pointer to an imaginary element that lies right after the last element.
124 | Incrementing an iterator shifts the iterator one element to the right, and decrementing it shifts it to the left.
125 |
126 | ```
127 | [1, 2, 3, 4, 5, 6, 7]
128 | ^ ^
129 | begin () end ()
130 | ```
131 |
132 | Here are two cool methods used on sorted vectors that work using iterators.
133 | lower_bound (arr.begin (), arr.end (), x) returns an iterator pointing to the smallest element in arr whose value is greater than or equal to x.
134 | upper_bound (arr.begin (), arr.end (), x) returns an iterator pointing to the largest element in arr whose value is less than or equal to x.
135 |
136 | Since these methods use binary search, their time complexity is only $O(n log n)$.
137 |
138 | Note that sort(), lower_bound() and upper_bound all take in iterators as parameters, the first one denoting the left-most element and the second one denoting the right-most element in the range to be considered.
139 |
140 |
141 | ## Optimal Task Scheduling
142 |
143 | We are given a list of tasks that need to be completed.
144 | Each task has its own duration and deadline before which it needs to be completed.
145 | The problem is to find the maximum number of tasks that can be completed if we schedule the tasks optimally.
146 |
147 | ### Example
148 |
149 |
150 |
151 | | ID |
152 | Deadline |
153 | Duration |
154 |
155 |
156 | | 1 |
157 | 5 |
158 | 3 |
159 |
160 |
161 | | 2 |
162 | 8 |
163 | 4 |
164 |
165 |
166 | | 3 |
167 | 9 |
168 | 2 |
169 |
170 |
171 | | 4 |
172 | 15 |
173 | 5 |
174 |
175 |
176 | | 5 |
177 | 18 |
178 | 6 |
179 |
180 |
181 |
182 | The highest number of tasks that can be completed is 4.
183 | One strategy to achieve this is given below.
184 |
185 | 1. Start task 1 at the 0th minute.
186 | 2. Start task 2 at the 3rd minute.
187 | 3. Start task 3 at the 7th minute.
188 | 4. Start task 5 at the 9th minute.
189 |
190 | ### Solution
191 |
192 | There is a greedy approach to solving this problem.
193 | First, we store all the elements in a vector, and sort them in descending order of their deadlines.
194 | Each task will be represented by a pair - the deadline and duration.
195 | We process the tasks one-by-one in the decreasing order of their deadlines.
196 | The ith task is first inserted into a priority queue.
197 | We then calculate the time t between the deadline of the ith task and the (i-1)th task.
198 | We use the priority queue to find the task with the least duration of time and execute it.
199 | This process continues as long as the total time duration of the tasks remains below t.
200 | If a task cannot be completely executed under the time t, the portion of it that can be executed is and the rest is put back into the priority queue.
201 |
202 | The running time of this algorithm is $O (n log n)$.
203 |
204 |
205 |
206 | Implementation
207 |
208 | ```cpp
209 | void solve () {
210 | int n;
211 | cin >> n;
212 | vector < pair > jobs;
213 | for (int i = 0; i < n; i ++) {
214 | pair j;
215 | int dl, dur;
216 | cin >> dl >> dur;
217 | j.first = dl;
218 | j.second = dur;
219 | jobs.push_back (j);
220 | }
221 | sort (jobs.rbegin (), jobs.rend ());
222 | priority_queue < pair > q;
223 | int result = 0;
224 | for (int i = 0; i < n; i ++) {
225 | pair j_inv;
226 | // The minus sign is a common trick to make the elements in ascending order
227 | j_inv.first = - jobs [i].second;
228 | j_inv.second = jobs [i].first;
229 | q.push (j_inv);
230 | int t = jobs[i].first - (i != n - 1 ? jobs [i + 1].first : 0);
231 | while (t > 0) {
232 | pair j = q.top ();
233 | q.pop ();
234 | // Don't forget to flip the sign back :)
235 | j.first = - j.first;
236 | if (j.first <= t) {
237 | t -= j.first;
238 | result ++;
239 | } else {
240 | pair j_new;
241 | j_new.first = t - j.first;
242 | j_new.second = j.second;
243 | q.push (j_new);
244 | break;
245 | }
246 | }
247 | }
248 | cout << result << "\n";
249 | }
250 | ```
251 |
252 |
253 |
254 | ## Links
255 |
256 | 1. [Pairs](https://www.geeksforgeeks.org/pair-in-cpp-stl/)
257 | 2. [Stacks](https://www.geeksforgeeks.org/stack-in-cpp-stl/)
258 | 3. [Queues](https://www.geeksforgeeks.org/queue-cpp-stl/)
259 | 4. [Priority Queues](https://www.geeksforgeeks.org/priority-queue-in-cpp-stl/)
260 | 5. [Video on scheduling problem](https://www.youtube.com/watch?v=nnHRrnZsPwo)
261 | 6. [Nearest Smaller Values](https://cses.fi/problemset/task/1645)
262 | 7. [Course Schedule III](https://leetcode.com/problems/course-schedule-iii/)
263 | 8. [The Skyline Problem](https://leetcode.com/problems/the-skyline-problem/)
264 | 9. [Task Scheduler](https://leetcode.com/problems/task-scheduler/)
265 | 10. [Concert Tickets](https://cses.fi/problemset/task/1091)
266 |
267 |
268 |
--------------------------------------------------------------------------------
/Week 2/3. Sorting & Greedy Algorithms.md:
--------------------------------------------------------------------------------
1 | # Sorting
2 |
3 | ## Introduction:
4 |
5 | Sorting forms the primary subroutine to solve many problems and forms the basis for many algorithms. In fact, you would have come across many problems that you would have solved (without realizing) using sorting.
6 |
7 | Some of the basic yet very hard to compute; questions that arise when we deal with an array of data can be answered by preprocessing the data first by sorting.
8 |
9 | Given an array of numbers, questions like "What is the largest number in the set that is $\le k$ for some integer $k$?" or "What is the most frequent number in the array?" can be answered by initially preprocessing the array by sorting.
10 |
11 | There are many sorting algorithms and they are classified on the basis of time complexity.
12 |
13 | 0. $O(n^2)$ comparision based algorithms:
14 |
15 | Some examples of this are bubble, selection and insertion sort. These are often quite slow and are not usable in most problems and are avoided. However, a rudimentary understanding on their working principle does help in a few problems.
16 |
17 | 1. $O(n \log(n))$ comparison based algorithms:
18 |
19 | Some examples of this are merge, quick and heap sort. These algorithms are the default choice in programming contests as the time complexity is optimal for comparison-based sorting. Therefore, these sorting algorithms run in the ‘best possible’ time in most cases.
20 |
21 | To avoid reinventing the wheel, we use the STL implementation of these using `sort`, `stable_sort` or `partial_sort` in C++, `Collections.sort` in Java or `sorted(list_name)` in Python.
22 |
23 | Watch the video on merge sort in `Sorting Algorithms` and `Technique Analysis` to understand how C++ STL sorts data.
24 |
25 | 3. $O(n)$ special purpose algorithms:
26 |
27 | Counting, radix and bucket sort are a few examples. Although not as generic as the others, these special purpose algorithms can reduce the required sorting time if the data has certain special characteristics.
28 |
29 | Additionally, you can use the links below for a better understanding by visualizing these algorithms :
30 | - [Sorting Algorithms](https://www.youtube.com/watch?feature=shared&v=WaNLJf8xzC4)
31 | - [Technique Analysis](https://youtube.com/playlist?list=PL2ONYsvCDiDsQ2AwqRxh0EE6AKm4jW7hp&feature=shared)
32 | - [Sort Visualization ](https://visualgo.net/en/sorting)
33 |
34 |
35 |
36 | ## C++ Implementation:
37 |
38 | Sorting can be done on arrays or any sequence container like vectors and deques.
39 |
40 | The C++ function for sort is `std::sort` and it runs in $O(n\log(n))$.
41 |
42 | - On arrays, it is called as:
43 |
44 | ```cpp
45 | // For an array 'a' of length 'n'
46 |
47 | sort(a, a + n); // ascending order
48 |
49 | sort(a, a + n, greater()); // descending order
50 | ```
51 |
52 | - On sequence containers, it can be done as:
53 |
54 | ```cpp
55 |
56 | sort(v.begin(), v.end()); //sort vector 'v' in ascending order
57 |
58 | sort(dq.begin(), dq.end(), greater()); //sort deque 'dq' in descending order
59 |
60 | ```
61 |
62 | - Custom comparators:
63 |
64 | Sorting can also be done using customised sorting rules according to various problem requirements. These arbitary comparision rules are incorporated using custom comparator functions.
65 |
66 | Assume that we need to sort a vector `v` of pairs $(x, y)$ in descending order of the value of $x^3 - y^2$:
67 |
68 | ```cpp
69 | bool comp(pair a, pair b)
70 | {
71 | int x = pow(a.first, 3), y = pow(a.second, 2);
72 | int p = pow(b.first, 3), q = pow(b.second, 2);
73 |
74 | if((x - y) > (p - q)) return true; //place a before b
75 | else return false; //place a after b
76 | }
77 |
78 | ...
79 |
80 | void solve()
81 | {
82 | ...
83 | sort(v.begin(), v.end(), comp);
84 | ...
85 | }
86 |
87 | ```
88 |
89 | When you write a comparator `bool cmp(a, b)`, return true if you want a to be before b in the sorted list and false if you want b to be before a in the sorted list.
90 |
91 | As this rather (in)famous [CF blogpost](https://codeforces.com/blog/entry/70237) points out, `cmp` must return false when `a = b` (failing to do this can make your operator non-transitive in certain situations, leading to runtime errors and veery weird side effects).
92 |
93 | Alternatively, we can use anonymous 'lambda' functions to do the same in a more concise format:
94 |
95 | ```cpp
96 | // we can take advantage of type inference and use `auto` instead of mentioning the actual data type
97 | // this snippet sorts a vector of pairs (x, y) in ascending order of x * y
98 | sort(v.begin(), v.end(), [] (auto a, auto b) {
99 | return a.first * a.second < b.first * b.second;
100 | });
101 | ```
102 |
103 | PS: While this is what most people use lambda functions for, they are far more powerful and versatile. Their conciseness and variable capturing means that they can be used instead of regular functions most of the time, except that you can declare them inside normal / lambda functions. This can simplify variable scope management for slightly more complicated CC problems and is slightly more efficient. (perhaps a topic for a future doc?)
104 |
105 |
106 |
107 | # Greedy Algorithms
108 |
109 | ## Introduction:
110 |
111 | Greedy algorithms are exactly what they sound like - they exploit certain properties of the given problem that optimise the computation of the result by eliminating or minimizing the simulation process. Since greedy algorithms are mostly problem-specific and aren't particularly classified into typical cases, we will explore some illustrations to understand the concept of greedy algorithms.
112 |
113 | There are usually two common traits in most greedy problems exhibit:
114 | - It has optimal substructures (the optimal solution to the problem contains the optimal solution to all sub-structures)
115 | - It has a greedy property (the globally optimal solution can be made by making a locally optimal choice)
116 |
117 | Sometimes, it can be quite difficult to prove the absolute validity of the greedy solution and so you have to rely on a mix of intuition, sample tests and edge cases you've thought about. However, eventually this process will start to feel more natural as your intuition develops with practice.
118 |
119 |
120 |
121 |
122 | ## Example 0 - [Station Balance](https://onlinejudge.org/index.php?option=onlinejudge&Itemid=8&page=show_problem&problem=351):
123 |
124 | 
125 |
126 | How would you go about this problem? Simulate all the possible options? In the worst case scenario, you have C = 5 and S = 10, which would give you around $45^5 \approxeq 10^9$ possible combinations, which is sure to exceed the time limit for this problem.
127 |
128 | 
129 |
130 | Let's make a few observations:
131 |
132 | - If there exists an empty chamber, it is usually beneficial and **never worse** to move one specimen from a chamber with two specimens to an empty chamber! Otherwise, the empty chamber contributes more to the imbalance (see fig 2 top).
133 |
134 | - If $S \gt C$, then $S - C$ specimens must be paired with a chamber already containing other specimens — the pigeonhole principle! (see fig 2 bottom)
135 |
136 | The key insight is that the solution to this problem can be simplified with sorting: if $S \lt 2C$ , add $2C - S$ dummy specimens with mass 0. For example, C = 3, S = 4, M = {5, 1, 2, 7} $\rightarrow$ C = 3, S = 6, M = {5, 1, 2, 7, 0, 0}.
137 |
138 | Then, sort the specimens on their mass such that $M_1 \leq M_2 \leq .. . \leq M_{2C-1} \leq M_{2C}$.
139 |
140 | In this example, M = {5, 1, 2, 7, 0, 0} $\rightarrow$ {0, 0, 1, 2, 5, 7} . By adding dummy specimens and then sorting them, a greedy strategy becomes ‘apparent’:
141 |
142 | - Pair the specimens with masses M_1 & M_{2C} and put them in chamber 1, then
143 | - Pair the specimens with masses M_2 & M_{2C-1} and put them in chamber 2, and so on .. .
144 |
145 | This greedy algorithm - commonly called 'load balancing' - works for this problem!
146 |
147 | 
148 |
149 | Designing greedy algorithms is an art and it is hard to impart the techniques used to deriving greedy solutions. However, one of the best ways to get started if you think that there exists a greedy solution is to sort the data in some fasion and then compute the required terms to see if some greedy strategy emerges.
150 |
151 | Two common ways to prove greedy algorithms are to prove that "greedy stays ahead" (the greedy strategy is never worse than the optimal strategy at any point) and exchange arguments (exchanging two elements with certain properties always makes the answer better / worse).
152 |
153 | It is also true that greedy strategies often fail to provide complete solutions to a broader testcases. We will explore an example of the same in the next illustration.
154 |
155 |
156 |
157 | ## Example 1 - Coin Change:
158 |
159 | Problem description:
160 |
161 | We are given a target amount $V$ cents and a list of denominations of $n$ coins, i.e., we have $coin_i$ (in cents) for coin types $i \epsilon [0..n-1]$.
162 | What is the minimum number of coins that we must use to represent amount $V$? Assume that we have an unlimited supply of coins of any type.
163 |
164 | Example:
165 |
166 | `If n = 4, coinValue = {25, 10, 5, 1} cents and we want to represent V = 42 cents.`
167 |
168 | We can use this greedy algorithm: repeatedly select the largest coin denomination which is not greater than the remaining amount, i.e., 42 - 25 = 17 $\rightarrow$ 17 - 10 = 7 $\rightarrow$ 7 - 5 = 2 $\rightarrow$ 2 - 1 = 1 $\rightarrow$ 1 - 1 = 0, a total of 5 coins. This is optimal.
169 |
170 | The problem above has the two ingredients required for a successful greedy algorithm:
171 |
172 | - It has optimal sub-structures.
173 | We have seen that in our quest to represent 42 cents, we use 25 + 10 + 5 + 1 + 1 . This is an optimal 5-coin solution to the original problem!
174 | Optimal solutions to sub-problem are contained within the 5-coin solution, i.e.,
175 | a. To represent 17 cents, we use 10 + 5 + 1 + 1 (part of the solution for 42 cents),
176 | b. To represent 7 cents, we use 5 + 1 + 1 (also part of the solution for 42 cents), etc.
177 |
178 | - It has the greedy property:
179 | Given every amount V,we can greedily subtract V with the largest coin denomination which is not greater than this amount V.
180 | It can be proven (not shown here for brevity) that using any other strategies will not lead to an optimal solution for this set of coin denominations.
181 |
182 | However, this greedy algorithm does not work for all sets of coin denominations. Take for example {4, 3, 1} cents. To make 6 cents with that set, a greedy algorithm would choose 3 coins {4, 1, 1} instead of the optimal solution that uses 2 coins {3, 3}.
183 |
184 | The complete solution to this problem will be dealt with in further weeks when we will discuss another more powerful problem solving paradigm - dynamic programming.
185 |
186 |
187 |
188 | ## Example 2 - [Dragons of Loowater](https://open.kattis.com/problems/loowater):
189 |
190 | There are several ways to solve this problem, but we will illustrate one of the easiest. This problem is a bipartite matching problem, in the sense that we are required to match (pair) knights to dragons in a minimal cost way.
191 |
192 | We shall try to develop a greedy algorithm for this: a dragon head with a certain diameter $D$ should be chopped by a knight with the shortest height $H$ such that $D \leq H$.
193 |
194 | However, the input is given in an arbitrary order. This is frequently done by the problem authors to mask the greedy strategy. If we sort both the array of dragon head diameters head and knight heights height in $O(n \log n + m \log m)$, we can use the following $O(max(n,m))$ scan to determine the answer. This is yet another example where sorting the input can help produce the required greedy strategy.
195 |
196 | ```cpp
197 | sort(D.begin(), D.end());
198 | sort(H.begin(), H.end());
199 |
200 | int gold = 0, d = 0, k = 0;
201 |
202 | while ((d < n) && (k < m)) //while not done yet
203 | {
204 | while ((k < m) && (D[d] > H[k]))
205 | ++k; //find required knight
206 | if (k == m) break; //loowater is doomed
207 | gold += H[k]; //pay this amount of gold
208 | ++d; ++k; //next dragon & knight
209 | }
210 |
211 | if (d == n) cout << gold << "\n";
212 | else cout << "loowater is doomed" << "\n";
213 |
214 | ```
215 |
216 |
217 |
218 | # Problems on Greedy and Sorting Algorithms
219 |
220 | 1. Warmup:
221 | - [Cow Tipping](http://www.usaco.org/index.php?page=viewproblem2&cpid=689)
222 | - [Amr and Music](https://codeforces.com/problemset/problem/507/A)
223 | - [Middle Class](https://codeforces.com/problemset/problem/1334/B)
224 | - [Elephants](https://onlinejudge.org/index.php?option=onlinejudge&Itemid=8&page=show_problem&problem=5020)
225 |
226 | 2. Sorting and Greedy:
227 | - [Too Many Segments](https://codeforces.com/contest/1249/problem/D2)
228 | - [Olya and Game with Arrays](https://codeforces.com/problemset/problem/1859/B)
229 | - [Similar Pairs](https://codeforces.com/problemset/problem/1334/B)
230 | - [Moamen and k-subarrays](https://codeforces.com/problemset/problem/1557/B)
231 | - [ICPC Team Selection](https://open.kattis.com/problems/icpcteamselection)
232 |
233 | 3. Classic and Not so Classic Greedy Problems (Core Workout):
234 | - [Carnival Tickets](https://oj.uz/problem/view/IOI20_tickets)
235 | - [Alien DNA](https://onlinejudge.org/index.php?option=onlinejudge&Itemid=8&page=show_problem&problem=2630P)
236 | - [Teacher Evaluation](https://open.kattis.com/problems/teacherevaluation)
237 | - [Hippo Circus](https://onlinejudge.org/index.php?option=onlinejudge&Itemid=8&page=show_problem&problem=4952)
238 | - [Square Pegs in a Circular Hole](https://open.kattis.com/problems/squarepegs)
239 |
240 | 4. [CSES Problemset - Sorting and Searching](https://cses.fi/problemset/list/)
241 |
--------------------------------------------------------------------------------
/Week 5/1. Introduction to DP.md:
--------------------------------------------------------------------------------
1 | # Dynamic Programming
2 |
3 | ## Introduction
4 |
5 | Dynamic programming is a technique of solving problems that involves dividing the larger problem into smaller sub-problems that can be solved independently.
6 | Dynamic programming is generally used in two cases:
7 |
8 |
9 | - Finding the most optimal solution
10 | - Finding the number of solutions
11 |
12 |
13 | Before we look at how dynamic programming works, we first need to look at the underlying trick that makes dynamic programming quick - memoisation.
14 |
15 | ## Memoisation
16 |
17 | ### Regular recursion - is it efficient?
18 |
19 | In dynamic programming, we make use of recursion - for example, we could express the solution for the case when n = k in terms of the solutions to cases when n < k.
20 | As an example, let us consider the problem of computing the nth (0-based indexing) term in the Fibonacci sequence.
21 | fib (n) can be expressed as fib (n - 1) + fib (n - 2).
22 | We define the base cases fib (0) = 1 and fib (1) = 1 separately.
23 | Let us implement this logic using recursion.
24 |
25 |
26 | C++ Implementation
27 |
28 | ```cpp
29 | void fib (int k) {
30 | if (k == 0 || k == 1) return 1;
31 | else return fib (k - 1) + fib (k - 2);
32 | }
33 | ```
34 |
35 |
36 |
37 |
38 | Python Implementation
39 |
40 | ```py
41 | def fib (k):
42 | if k == 0 or k == 1:
43 | return 1
44 | else:
45 | return fib (k - 1) + fib (k - 2)
46 | ```
47 |
48 |
49 |
50 | Every time we call the function fib, we re-call it twice, creating a tree of recursive fib calls until the base cases fib (0) and fib (1) are reached.
51 | In the case of computing fib (4), the tree looks something like this.
52 |
53 | 
54 |
55 | The main thing to notice is that the tree gets exponentially bigger with every increase in $n$, which shows that this algorithm has a time complexity of $O (2 ^ n)$.
56 |
57 | However, we can improve the algorithm to work in $O (n)$ complexity.
58 |
59 | ### Recursion powered by memoisation
60 |
61 | If you look at the tree, you will notice that several function calls are identical.
62 | For example, fib (2) is called twice.
63 | If we could somehow save the values of the function calls, we would end up massively reducing the time taken by the algorithm.
64 | Let us create an array arr where arr [i] stores the value of fib (i).
65 | The values in arr are initialised to -1, indicating that no values have been computed yet.
66 | The function fib (k) is only called when arr [k] = -1, otherwise, the value of arr [k] is directly used.
67 | This prevents us from making redundant function calls when we already know the answer.
68 |
69 |
70 | C++ Implementation
71 |
72 | ```cpp
73 | int arr [n + 1];
74 | for (int i = 0; i <= n; i ++)
75 | arr [i] = -1;
76 |
77 | void fib (int k) {
78 | if (k == 0 || k == 1) return 1;
79 | else {
80 | if (arr[k] == -1)
81 | arr[k] = fib (k - 1) + fib (k - 2);
82 | return arr[k];
83 | }
84 | }
85 | ```
86 |
87 |
88 |
89 |
90 | Python Implementation
91 |
92 | ```py
93 | arr = []
94 | for i in range (n + 1):
95 | arr.append (-1)
96 |
97 | def fib (k):
98 | if k == 0 or k == 1:
99 | return 1
100 | else:
101 | if (arr[k] == -1)
102 | arr[k] = fib (k - 1) + fib (k - 2)
103 | return arr[k]
104 | ```
105 |
106 |
107 |
108 | Let us now examine the time complexity of our new algorithm.
109 | Here is the function call tree in the case of memoisation.
110 |
111 | 
112 |
113 | As you can see, the number of function calls is now the same as the index of the term that we are looking for - making the time complexity $O (n)$, which is much better than the $O (2 ^ n)$ time complexity without memoisation.
114 |
115 | ### Do we really need recursion?
116 |
117 | Now that we are using memoisation, it turns out that we do not need to use recursion.
118 | We can simply build arr iteratively, term-by-term, with each term being constructed from its preceding two terms.
119 | Of course, we need to initialise arr [0] and arr [1] before we begin iterating.
120 |
121 |
122 | C++ Implementation
123 |
124 | ```cpp
125 | int arr [n + 1];
126 | arr [0] = 1;
127 | arr [1] = 1;
128 | for (int i = 2; i <= n; i ++)
129 | arr [i] = arr [i - 1] + arr [i - 2];
130 | ```
131 |
132 |
133 |
134 |
135 | Python Implementation
136 |
137 | ```py
138 | arr = []
139 | arr.append (0)
140 | arr.append (1)
141 | for i in range (2, n + 1):
142 | arr.append (arr [i - 1] + arr [i - 2])
143 | ```
144 |
145 |
146 |
147 | The approach that involves recursion with memoization is usually called top-down dynamic programming (recursive DP) while the iterative solution is usually called bottom-up dynamic programming (iterative DP).
148 |
149 | While the time complexities of both approaches should be the same if implemented correctly, bottom-up is usually more efficient since there is much less function call overhead due to the abssence of recursion.
150 |
151 | However, in more complicated problems, the bottom up solution can be harder to think of since you need to guarantee that all the subproblems a particular state depends on have been computed **before** we compute the answer for the current state.
152 |
153 | ## Minimum number of notes required to reach a certain amount
154 |
155 | The problem is to find what is the minimum number of Indian Rupee notes (and coins) required to reach a certain amount $x$.
156 |
157 | As we know, Indian Rupee notes and coins come in the following denominations - 1, 2, 5, 10, 20, 50, 100 and 500.
158 |
159 | ### The greedy approach - does it really work?
160 |
161 |
It turns out that in this case, the problem can be solved greedily - keep picking the note with the largest possible denomination as long as the total sum in your hand is less than x.
162 | Once the total sum becomes x, you have your answer.
163 |
164 |
165 | C++ Implementation
166 |
167 | ```cpp
168 | void solve () {
169 | int x;
170 | cin >> x;
171 | int result = 0, rupees [8] = {1, 2, 5, 10, 20, 50, 100, 500};
172 | while (x > 0) {
173 | for (int i = 7; i >= 0; i --) {
174 | if (rupees [i] <= x) {
175 | x -= rupees [i];
176 | result ++;
177 | break;
178 | }
179 | }
180 | }
181 | cout << result << '\n';
182 | }
183 | ```
184 |
185 |
186 |
187 |
188 | Python Implementation
189 |
190 | ```py
191 | def solve ():
192 | x = int (input ())
193 | result = 0
194 | rupees = [1, 2, 5, 10, 20, 50, 100, 500]
195 | while x > 0:
196 | for denum in rupees [ : : -1]:
197 | if (denum <= x):
198 | x -= denum
199 | result += 1
200 | break
201 | print (result)
202 | ```
203 |
204 |
205 |
206 | But, will this algorithm work for every set of denominations of money?
207 | It turns out that the greedy algorithm does not always work.
208 | Let us say that a hypothetical country has only three denominations of money - 1, 3, and 4.
209 | If we require a sum x = 6, the greedy algorithm would give us an answer of 4, 1, and 1 - which means that the minimum number of notes required according to our greedy algorithm is 3.
210 | However, this is not the best solution, as by taking two 3 notes we get the required sum using just 2 notes.
211 | Now that we have shown that the greedy approach does not always work, let us solve this problem by dynamic programming.
212 |
213 | ### The correct approach using dynamic programming
214 |
215 | Let us say that the function f (x) returns the minimum number of notes required to obtain a sum x.
216 | The key to solving the problem using DP is to express f (x) recursively.
217 | How do we do this?
218 | We know that a sum x can be reached in only three ways - by adding 1 to x - 1, by adding 3 to x - 3, or by adding 4 to x - 4.
219 | Therefore, we can state that f (x) is equal to 1 added to the minimum among f (x - 1), f (x - 3), and f (x - 4).
220 | We can define an array dp such that dp [x] stores the value of f (x).
221 | First, we will define the base case dp [0] = 0, as 0 notes are required to reach a sum of 0.
222 | We then find dp [i] for further values of i iteratively, using the relation dp [i] = 1 + min (dp [i - a1], dp [i - a2], dp [i - a3]), ... dp [i - an]), where a denotes the set of all available denominations.
223 | Note that dp [i - aj] should only be considered while calculating the minimum when i - aj is non-negative, as a sum can never be obtained from a negative one.
224 |
225 |
226 | C++ Implementation
227 |
228 | ```cpp
229 | void solve () {
230 | int n, x;
231 | cin >> n >> x;
232 | int arr [n];
233 | for (int i = 0; i < n; i ++)
234 | cin >> arr [i];
235 | int dp [x + 1];
236 | dp [0] = 0;
237 | for (int i = 1; i <= x; i ++) {
238 | dp [i] = -1;
239 | for (auto ele : arr) {
240 | if (i - ele >= 0) {
241 | if (dp [i] == -1 || dp [i - ele] + 1 < dp [i])
242 | dp [i] = dp [i - ele] + 1;
243 | }
244 | }
245 | }
246 | cout << dp [x] << '\n';
247 | }
248 | ```
249 |
250 |
251 |
252 |
253 | Python Implementation
254 |
255 | ```py
256 | def solve ():
257 | n, x = tuple (map (int, input ().split (' ')))
258 | arr = tuple (map (int, input ().split (' ')))
259 | dp = []
260 | dp.append (0)
261 | for i in range (1, x + 1):
262 | dp.append (-1)
263 | for ele in arr:
264 | if i - ele >= 0:
265 | if dp [i] == -1 or dp [i - ele] + 1 < dp [i]:
266 | dp [i] = dp [i - ele] + 1
267 | print (dp [x])
268 | ```
269 |
270 |
271 |
272 | ## Multidimensional DP
273 | In many problems, the recurrence depends on more than one variable, giving rise to multidimensional DP.
274 |
275 | As an example, consider this problem: given an $n \times n$ grid with `.` indicating a free square and `*` indicated a blocked square, how many paths from the upper-left square to the bottom-right square do not pass through any blocked squares if you can only move right or down?
276 |
277 | Let us take `dp[x][y]` to be the number of required paths from the upper-left square `(0, 0)` to `n(x, y)` (which means that `dp[n - 1][n - 1]` will be the final answer). Now, there are two ways to reach `(x, y)`: move left from `(x - 1, y)` or move down from `(x, y - 1)`.
278 |
279 | However, if `(x, y)` is a blocked square, `dp[x][y]` should be zero (we cannot move to a blocked square). Combining this, we get:
280 |
281 | $$ \texttt{dp}[x][y] =
282 | \begin{cases}
283 | \texttt{dp}[x-1][y] + \texttt{dp}[x][y-1] & \text{if $(x, y)$ is blocked} \\
284 | 0, & \text{if $(x, y)$ is free}
285 | \end{cases} $$
286 |
287 | ```cpp
288 | int main()
289 | {
290 | ll n;
291 | cin >> n;
292 | vector grid(n);
293 | for (auto &i : grid)
294 | cin >> i;
295 | vector> dp(n, vector(n, 0));
296 | dp[0][0] = 1;
297 | for (int i = 0; i < n; i++)
298 | {
299 | for (int j = 0; j < n; j++)
300 | {
301 | if (grid[i][j] == '*')
302 | {
303 | dp[i][j] = 0;
304 | }
305 | else
306 | {
307 | if (i > 0) dp[i][j] += dp[i-1][j];
308 | if (j > 0) dp[i][j] += dp[i][j-1];
309 | }
310 | }
311 | }
312 | cout << dp[n-1][n-1] << '\n';
313 | return 0;
314 | }
315 | ```
316 |
317 | ## Links to external resources
318 |
319 | 1. [DP explained at different levels by TopCoder](https://www.topcoder.com/thrive/articles/Dynamic%20Programming:%20From%20Novice%20to%20Advanced)
320 | 2. [Multi-dimensional DP](https://itnext.io/introduction-to-multi-dimensional-dynamic-programming-666b095b2e7b)
321 | 3. [DP visualised by Reducible](https://www.youtube.com/watch?v=aPQY__2H3tE)
322 | 4. [MIT lecture on DP](https://www.youtube.com/watch?v=OQ5jsbhAv_M)
323 |
324 | ## Practice problems
325 |
326 | 1. [CSES 1633 - Dice Combinations](https://cses.fi/problemset/task/1633)
327 | 2. [Codeforces 189A - Cut Ribbon](https://codeforces.com/problemset/problem/189/A)
328 | 3. [Codeforces 474D - Flowers](https://codeforces.com/problemset/problem/474/D)
329 | 4. [CSES 1637 - Removing Digits](https://cses.fi/problemset/task/1637)
330 | 5. [Codeforces 545C - Woodcutters](https://codeforces.com/problemset/problem/545/C)
331 | 6. [Codeforces 1195C - Basketball Exercise](https://codeforces.com/problemset/problem/1195/C)
332 | 7. [CSES 1638 - Grid Paths](https://cses.fi/problemset/task/1638)
333 | 8. [Codeforces 698A - Vacations](https://codeforces.com/problemset/problem/698/A)
334 | 9. [CSES 1639 - Edit Distance](https://cses.fi/problemset/task/1639)
335 |
336 |
--------------------------------------------------------------------------------
17 |
18 |
19 | ## Contests on Codeforces
20 |
21 |