63 70 climb stairs minimum path sum

Author: Lei Cao

README.md

@@ -166,14 +166,14 @@ LeetCode
 |73|[Set Matrix Zeroes](https://oj.leetcode.com/problems/set-matrix-zeroes/)| [C++](./algorithms/setMatrixZeroes/setMatrixZeroes.cpp)|Medium|
 |72|[Edit Distance](https://oj.leetcode.com/problems/edit-distance/)| [C++](./algorithms/editDistance/editDistance.cpp)|Hard|
 |71|[Simplify Path](https://oj.leetcode.com/problems/simplify-path/)| [C++](./algorithms/simplifyPath/simplifyPath.cpp)|Medium|
-|70|[Climbing Stairs](https://oj.leetcode.com/problems/climbing-stairs/)| [C++](./algorithms/climbStairs/climbStairs.cpp)|Easy|
+|70|[Climbing Stairs](https://oj.leetcode.com/problems/climbing-stairs/)| [C++](./algorithms/climbStairs/climbStairs.cpp), [Java](./algorithms-java/src/dynamicProgramming/climbStairs/climbStairs.java)|Easy|
 |69|[Sqrt(x)](https://oj.leetcode.com/problems/sqrtx/)| [C++](./algorithms/sqrt/sqrt.cpp)|Medium|
 |68|[Text Justification](https://oj.leetcode.com/problems/text-justification/)| [C++](./algorithms/textJustification/textJustification.cpp)|Hard|
 |67|[Plus One](https://oj.leetcode.com/problems/plus-one/)| [C++](./algorithms/plusOne/plusOne.cpp)|Easy|
 |66|[Valid Number](https://oj.leetcode.com/problems/valid-number/)| [C++](./algorithms/validNumber/validNumber.cpp)|Easy|
 |65|[Add Binary](https://oj.leetcode.com/problems/add-binary/)| [C++](./algorithms/addBinary/addBinary.cpp)|Easy|
 |64|[Merge Two Sorted Lists](https://oj.leetcode.com/problems/merge-two-sorted-lists/)| [C++](./algorithms/mergeTwoSortedList/mergeTwoSortedList.cpp)|Easy|
-|63|[Minimum Path Sum](https://oj.leetcode.com/problems/minimum-path-sum/)| [C++](./algorithms/minimumPathSum/minimumPathSum.cpp)|Medium|
+|63|[Minimum Path Sum](https://oj.leetcode.com/problems/minimum-path-sum/)| [C++](./algorithms/minimumPathSum/minimumPathSum.cpp), [Java](./algorithms-java/src/dynamicProgramming/minimumPathSum/minimumPathSum.java)|Medium|
 |62|[Unique Paths II](https://oj.leetcode.com/problems/unique-paths-ii/)| [C++](./algorithms/uniquePaths/uniquePaths.II.cpp), [Java](./algorithms-java/src/dynamicProgramming/uniquePaths/uniquePathsII.java)|Medium|
 |61|[Unique Paths](https://oj.leetcode.com/problems/unique-paths/)| [C++](./algorithms/uniquePaths/uniquePaths.cpp), [Java](./algorithms-java/src/dynamicProgramming/uniquePaths/uniquePaths.java)|Medium|
 |60|[Rotate List](https://oj.leetcode.com/problems/rotate-list/)| [C++](./algorithms/rotateList/rotateList.cpp)|Medium|

algorithms-java/src/dynamicProgramming/climbStairs/climbStairs.java

@@ -0,0 +1,35 @@
+// Source : https://oj.leetcode.com/problems/climbing-stairs/
+// Inspired by : http://www.jiuzhang.com/solutions/climbing-stairs/
+// Author : Lei Cao
+// Date   : 2015-10-12
+
+/**********************************************************************************
+ *
+ * You are climbing a stair case. It takes n steps to reach to the top.
+ *
+ * Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
+ *
+ *
+ **********************************************************************************/
+
+package dynamicProgramming.climbStairs;
+
+public class climbStairs {
+    /**
+     * @param n: An integer
+     * @return: An integer
+     */
+    public int climbStairs(int n) {
+        int[] matrix = new int[n];
+        if (n < 3) {
+            return n;
+        }
+        matrix[0] = 1;
+        matrix[1] = 2;
+        // write your code here
+        for (int i = 2; i < matrix.length; i++) {
+            matrix[i] = matrix[i-1] + matrix[i-2];
+        }
+        return matrix[n-1];
+    }
+}

algorithms-java/src/dynamicProgramming/climbStairs/climbStairsTest.java

@@ -0,0 +1,25 @@
+package dynamicProgramming.climbStairs;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * Created by leicao on 12/10/15.
+ */
+public class climbStairsTest {
+
+    @Test
+    public void testClimbStairs() throws Exception {
+        int[] inputs = {1,2,3,4};
+
+        int[] results = {1,2,3,5};
+
+        for (int i = 0; i < results.length; i++) {
+            climbStairs c = new climbStairs();
+            int r = c.climbStairs(inputs[i]);
+            System.out.println(r);
+            assertEquals(results[i], r);
+        }
+    }
+}

algorithms-java/src/dynamicProgramming/minimumPathSum/minimumPathSum.java

@@ -0,0 +1,47 @@
+// Source : https://oj.leetcode.com/problems/minimum-path-sum/
+// Inspired by : http://www.jiuzhang.com/solutions/minimum-path-sum/
+// Author : Lei Cao
+// Date   : 2015-10-12
+
+/**********************************************************************************
+ *
+ * Given a m x n grid filled with non-negative numbers, find a path from top left to
+ * bottom right which minimizes the sum of all numbers along its path.
+ *
+ * Note: You can only move either down or right at any point in time.
+ *
+ **********************************************************************************/
+
+package dynamicProgramming.minimumPathSum;
+
+public class minimumPathSum {
+    /**
+     * @param grid: a list of lists of integers.
+     * @return: An integer, minimizes the sum of all numbers along its path
+     */
+    public int minPathSum(int[][] grid) {
+        if (grid.length == 0 || grid[0].length == 0) {
+            return 0;
+        }
+        int m = grid.length;
+        int n = grid[0].length;
+        int[][] matrix = new int[m][n];
+
+        matrix[0][0] = grid[0][0];
+        for (int i = 1; i < m; i++) {
+            matrix[i][0] = grid[i][0] + matrix[i-1][0];
+        }
+
+        for (int i = 1; i < n; i++) {
+            matrix[0][i] = grid[0][i] + matrix[0][i-1];
+        }
+
+        for (int i = 1; i < m; i++) {
+            for (int j = 1; j < n; j++) {
+                matrix[i][j] = grid[i][j] + Math.min(matrix[i-1][j], matrix[i][j-1]);
+            }
+        }
+
+        return matrix[m-1][n-1];
+    }
+}

algorithms-java/src/dynamicProgramming/minimumPathSum/minimumPathSumTest.java

@@ -0,0 +1,30 @@
+package dynamicProgramming.minimumPathSum;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * Created by leicao on 12/10/15.
+ */
+public class minimumPathSumTest {
+
+    @Test
+    public void testMinPathSum() throws Exception {
+        int[][][] inputs = {
+            {
+                {1,2},
+                {1,2},
+            }
+        };
+
+        int [] results = {4};
+
+        for (int i = 0; i < results.length; i++) {
+            minimumPathSum m = new minimumPathSum();
+            int r = m.minPathSum(inputs[i]);
+            System.out.println(r);
+            assertEquals(results[i], r);
+        }
+    }
+}