Add problem 2 based on DP

Author: sahilbansal17

Minimum Falling Path Sum/README.md

@@ -0,0 +1,23 @@
+# Minimum Falling Path Sum
+[Try the problem](https://leetcode.com/problems/minimum-falling-path-sum/)
+
+Given a matrix of integers, we want to find the **minimum** sum of *falling path* through it.
+
+A falling path starts at any element in the first row, and chooses one element from each row.
+<br/>
+The next row's choice must be in a column that is different from the previous row's column by atmost one.
+
+### Example
+
+```
+Input: [[1,2,3],[4,5,6],[7,8,9]]
+Output: 12
+Explanation: 
+The possible falling paths are:
+```
+
+- `[1,4,7], [1,4,8], [1,5,7], [1,5,8], [1,5,9]`
+- `[2,4,7], [2,4,8], [2,5,7], [2,5,8], [2,5,9], [2,6,8], [2,6,9]`
+- `[3,5,7], [3,5,8], [3,5,9], [3,6,8], [3,6,9]`
+
+The falling path with the smallest sum is `[1,4,7]`, so the answer is `12`.

Minimum Falling Path Sum/solution.cpp

@@ -0,0 +1,45 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+class Solution {
+public:
+    int minFallingPathSum(vector<vector<int> > &A) {
+        int rows = A.size(); // 3
+        int cols = A[0].size(); // 3
+        vector<vector<int> > minSum(rows, vector<int> (cols, 0)); // 3*3 with all 0's
+        // set for first row
+        for (int curCol = 0; curCol <cols; ++curCol) {
+            minSum[0][curCol] = A[0][curCol]; // {1, 2, 3} is the first row
+        }
+        // solve for all other rows, value depends on top, topleft and topright
+        for (int curRow = 1; curRow < rows; ++curRow) {
+            for (int curCol = 0; curCol < cols; ++curCol) {
+                int curMinSum = INT_MAX;
+                int prevRow = curRow - 1;
+                for (int k = -1; k <= 1; ++k) {
+                    int prevCol = curCol + k;
+                    if (prevCol >= 0 && prevCol < cols) {
+                        curMinSum = min(curMinSum, minSum[prevRow][prevCol]);
+                    }
+                }
+                // curMinSum is 1 for the cell valued 4, i.e. (1, 0)
+                minSum[curRow][curCol] = A[curRow][curCol] + curMinSum;
+                // minSum[1][0] = 4 + 1 = 5
+            }
+        }
+        // minSum at the end = { {1, 2, 3}, {5, 6, 8}, {12, 13, 15} }
+        // result is the minimum value in the last row
+        int res = INT_MAX;
+        for (int curCol = 0; curCol < cols; ++curCol) {
+            res = min(res, minSum[rows - 1][curCol]);
+        }
+        return res; // 12
+    }
+};
+
+int main () {
+    Solution solver;
+    vector<vector<int> > A = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+    cout << solver.minFallingPathSum(A) << endl;
+}

Minimum Falling Path Sum/solution.txt

@@ -0,0 +1,23 @@
+Initially, thinking of trying all possibilities as a naive and brute force solution to start with.
+
+Trying to realize its complexity, thinking it around O(N*3^(N-1)) as can start with any
+element in the first row and then for any element can go to around 3 other elements in the 
+next row. 
+
+Trying to think how to optimize this approach, the observation is once we are at a particular 
+element in a row, the only think that matters now is the element in the next row, the path to
+reach that element doesn't really matter.
+
+So, its kind of an overlapping subproblem since we can reach that point from atmost 3 points above 
+that element, but need to now solve the same problem.
+
+Also, another observation is that we are ultimately going to end at the last row, in some column.
+So, if we can consider minSum[i][j] denoting the minimum sum to reach the element (i, j)
+following the conditions given, then our answer is simply the minimum of all the values
+minSum[i][j] in the last row, i.e. i = Index of last row, j ranging from 0 to last column index.
+
+The recurrence is now kind of obvious.
+We can relate minSum[i][j] to minSum[i - 1][j - 1], minSum[i - 1][j] and minSum[i - 1][j + 1],
+handling the corner/boundary cases and implementing it in a space efficient way, since
+at any point of time we require no longer than 2 row values.
+