20190715

Author: mJackie

code/lc102.java

@@ -23,7 +23,7 @@ public List<List<Integer>> levelOrder(TreeNode root) {
         if(root==null)
             return res;
         qu.add(root);
-        while(!qu.isEmpty()){
+        while(!qu.isEmpty()){   //两个while
             int size = qu.size();
             List<Integer> temp = new ArrayList<>();
             while(size>0){

code/lc113.java

@@ -20,20 +20,20 @@ public class TreeNode {
         }
     }
     public List<List<Integer>> pathSum(TreeNode root, int sum) {
-        List<List<Integer>> res = new ArrayList<>();
-        helper(res, root, sum, 0, new ArrayList<>());
+        List<List<Integer>> res = new ArrayList();
+        helper(res, new ArrayList(), root, sum);
         return res;
     }
-    public void helper(List<List<Integer>> res, TreeNode root, int sum, int curr, List<Integer> curr_ls) {
+    public void helper(List<List<Integer>> res, List<Integer> cur, TreeNode root, int sum){
         if(root==null) return;
-        curr_ls.add(root.val);
-        if(curr+root.val==sum && root.left==null && root.right==null) { //到叶子节点
-            res.add(new ArrayList<>(curr_ls));
-            curr_ls.remove(curr_ls.size()-1);
-            return;
+        cur.add(root.val);
+        if(root.left==null&&root.right==null&&root.val==sum){   //到叶子节点
+            res.add(new ArrayList(cur));
+        }else{
+            helper(res, cur, root.left, sum-root.val);
+            helper(res, cur, root.right, sum-root.val);
         }
-        helper(res, root.left, sum, curr+root.val, curr_ls);
-        helper(res, root.right, sum, curr+root.val, curr_ls);
-        curr_ls.remove(curr_ls.size()-1);
+        cur.remove(cur.size()-1);
+        return;
     }
 }

code/lc123.java

@@ -1,6 +1,6 @@
 package code;
 /*
- * 122. Best Time to Buy and Sell Stock III
+ * 123. Best Time to Buy and Sell Stock III
  * 题意：买卖股票最大利润，只能买卖2次
  * 难度：Hard
  * 分类：Array, Dynamic Programming

code/lc131.java

@@ -10,6 +10,7 @@
  * 思路：典型回溯法，注意向res添加内容时要重新new一下
  * Tips： lc5, lc9, lc125, lc131, lc234, lc647
  *       lc39
+ *       lc132
  *       判断是否为回文的方法：
  *       1. 从中心往两边扩充，中心可能是一个字符，也可能是两个字符
  *       2. dp，利用之前计算的结果，只判断边缘两个字符是否相等，从后往前dp

code/lc132.java

@@ -0,0 +1,52 @@
+package code;
+import java.util.Arrays;
+
+/*
+ * 132. Palindrome Partitioning II
+ * 题意：最少切几刀，回文串
+ * 难度：Hard
+ * 分类：Dynamic Programming
+ * 思路：和lc300思路很像，只是多了判断。dp[i]表示从0到i这一段切法的最小值，每次遍历前边的结果，看能否接上。
+ *      可以把判断回文和dp两个合并，因为用dp的形式判断回文
+ * Tips：lc300
+ *      bingo!
+ */
+
+public class lc132 {
+    public int minCut(String s) {
+        int[] dp = new int[s.length()+1];
+        Arrays.fill(dp, s.length());    //fill最大值
+        dp[0] = 0;
+        for(int i=1; i<dp.length; i++){
+            for(int j=0; j<=i; j++){    //注意<=
+                if(dp[j]!=s.length() && isPalindrome(s.substring(j,i)))
+                    dp[i] = Math.min(dp[i], dp[j]+1);
+            }
+        }
+        return dp[s.length()]-1; //要-1 最后一刀是在末尾
+    }
+
+    public Boolean isPalindrome(String str){
+        if(new StringBuilder(str).reverse().toString().equals(str)) return true;   //reverse一下
+        else return false;
+    }
+
+    public int minCut2(String s) {
+        char[] c = s.toCharArray();
+        int n = c.length;
+        int[] cut = new int[n];
+        boolean[][] pal = new boolean[n][n];
+
+        for(int i = 0; i < n; i++) {
+            int min = i;
+            for(int j = 0; j <= i; j++) {
+                if(c[j] == c[i] && (j + 1 > i - 1 || pal[j + 1][i - 1])) {
+                    pal[j][i] = true;
+                    min = j == 0 ? 0 : Math.min(min, cut[j - 1] + 1);
+                }
+            }
+            cut[i] = min;
+        }
+        return cut[n - 1];
+    }
+}

code/lc139.java

@@ -6,8 +6,10 @@
  * 分类：Dynamic Programming
  * 思路：动态规划
  * Tips：巧妙的方法，防止了复杂的操作，通过遍历之前计算出来的结果
+ *       递归的方法本质和dp是一样的，记住用备忘录算法，把之前的结果记下来
  *       lc140
  */
+import java.util.HashMap;
 import java.util.List;
 
 public class lc139 {
@@ -22,4 +24,16 @@ public boolean wordBreak(String s, List<String> wordDict) {
         }
         return dp[s.length()];
     }
+
+    HashMap<String, Boolean> hm = new HashMap();
+    public boolean wordBreak2(String s, List<String> wordDict) {
+        if(hm.containsKey(s)) return hm.get(s);
+        if(s.length() == 0) return true;
+        Boolean flag = false;
+        for(String word:wordDict){
+            if(s.startsWith(word)) flag = flag||wordBreak(s.substring(word.length()), wordDict);    //注意函数 startsWith
+        }
+        hm.put(s, flag);
+        return flag;
+    }
 }

code/lc141.java

@@ -14,15 +14,13 @@ public class ListNode {
         ListNode(int x) { val = x; }
     }
     public boolean hasCycle(ListNode head) {
-        if(head==null)
-            return false;
-        ListNode faster = head;
+        if(head==null||head.next==null) return false;
         ListNode slow = head;
-        while( faster.next!=null && faster.next.next!=null){    //注意判断条件，slow一定不等于null，不用判断了
+        ListNode fast = head.next;
+        while(fast!=null&&fast.next!=null){  //注意判断条件，slow一定不等于null，不用判断了
             slow = slow.next;
-            faster = faster.next.next;
-            if(slow==faster)
-                return true;
+            fast = fast.next.next;
+            if(fast==slow) return true;
         }
         return false;
     }

code/lc142.java

@@ -32,4 +32,23 @@ public ListNode detectCycle(ListNode head) {
         }
         return null;
     }
+
+    public ListNode detectCycle2(ListNode head) {
+        if(head==null||head.next==null) return null;
+        ListNode slow = head;
+        ListNode fast = head.next;
+        while(fast!=null&&fast.next!=null){
+            slow = slow.next;
+            fast = fast.next.next;
+            if(slow==fast){
+                slow = slow.next;
+                while(head!=slow){
+                    head = head.next;
+                    slow = slow.next;
+                }
+                return slow;
+            }
+        }
+        return null;
+    }
 }

code/lc148.java

@@ -25,7 +25,7 @@ public ListNode sortList(ListNode head) {
         if( head==null || head.next == null ){
             return head;
         }
-        ListNode slow = head;
+        ListNode slow = head;   //记一下
         ListNode fast = head.next;
         while( fast!=null && fast.next!=null ){   //把链表分成两半
             slow = slow.next;

code/lc207.java

@@ -23,7 +23,7 @@ public static boolean canFinish(int numCourses, int[][] prerequisites) {
         for (int i = 0; i < prerequisites.length ; i++) {
             int node1 = prerequisites[i][0];
             int node2 = prerequisites[i][1];
-            graph[node2][node1] = 1;
+            graph[node2][node1] = 1;    //存下邻接矩阵，方便后续查找是否有边
             indegree[node1]++;  //存下入度，入度为0时，表示该课程可以修
         }
         Stack<Integer> st = new Stack();