basic

Author: idf

src/MergeTwoSortedLists/Solution.java

@@ -0,0 +1,49 @@
+package MergeTwoSortedLists;
+
+import commons.datastructures.ListNode;
+
+/**
+ * User: Danyang
+ * Date: 1/20/2015
+ * Time: 10:40
+ *
+ * Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.
+ */
+public class Solution {
+    /**
+     * Notice:
+     * 1. importance of using pre
+     * @param l1
+     * @param l2
+     * @return
+     */
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+        ListNode c1 = l1;
+        ListNode c2 = l2;
+        ListNode dummy = new ListNode(0);
+        ListNode pre = dummy;
+        while(c1!=null && c2!=null) {
+            pre.next = new ListNode(0);
+            ListNode c = pre.next;
+            if(c1.val<c2.val) {
+                c.val = c1.val;
+                c1 = c1.next;
+            }
+            else {
+                c.val = c2.val;
+                c2 = c2.next;
+            }
+            pre = pre.next;
+        }
+        if(c1==null)
+            pre.next = c2;
+        else
+            pre.next = c1;
+
+        return dummy.next;
+    }
+
+    public static void main(String[] args) {
+        ListNode ret = new Solution().mergeTwoLists(null, null);
+    }
+}

src/MinimumPathSum/Solution.java

@@ -0,0 +1,41 @@
+package MinimumPathSum;
+
+/**
+ * User: Danyang
+ * Date: 1/20/2015
+ * Time: 10:51
+ *
+ * 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.
+ */
+public class Solution {
+    /**
+     * f[i][j] represents the min path to i, j
+     * f[i][j] = min(f[i-1][j], f[i][j-1])+grid[i][j]
+     * @param grid
+     * @return
+     */
+    public int minPathSum(int[][] grid) {
+        int m = grid.length;
+        if(m==0)
+            return 0;
+        int n = grid[0].length;
+        if(n==0)
+            return 0;
+
+        int[][] f = new int[m+1][n+1];
+        // initialize
+        for(int i=0; i<m+1; i++)
+            for(int j=0; j<n+1; j++)
+                f[i][j] = Integer.MAX_VALUE;
+        f[0][1] = 0;  // entry
+
+
+        for(int i=1; i<m+1; i++)
+            for(int j=1; j<n+1; j++)
+                f[i][j] = Math.min(f[i-1][j], f[i][j-1])+grid[i-1][j-1];
+        return f[m][n];
+    }
+}

src/commons/datastructures/ListNode.java

@@ -12,4 +12,11 @@ public ListNode(int x) {
         val = x;
         next = null;
     }
+
+    @Override
+    public String toString() {
+        return "ListNode{" +
+                "val=" + val +
+                '}';
+    }
 }

src/commons/datastructures/TreeNode.java

@@ -12,4 +12,11 @@ public class TreeNode {
     public TreeNode(int x) {
         val = x;
     }
+
+    @Override
+    public String toString() {
+        return "TreeNode{" +
+                "val=" + val +
+                '}';
+    }
 }