20191215

Author: mJackie

code/lc145.java

@@ -20,8 +20,7 @@ public class TreeNode {
     }
     public List<Integer> postorderTraversal(TreeNode root) {
         ArrayList<Integer> res = new ArrayList();
-        if(root==null)
-            return res;
+        if(root==null) return res;
         Stack<TreeNode> st = new Stack();
         while(!st.isEmpty()||root!=null){
             while(root!=null) {

code/lc152.java

@@ -19,7 +19,7 @@ public static int maxProduct(int[] nums) {
                 max = Math.max(nums[i],nums[i]*max);
                 min = Math.min(nums[i],nums[i]*min);
             }else{
-                int temp = max; //注意maxh会被替换，先保存下
+                int temp = max; //注意max会被替换，先保存下
                 max = Math.max(nums[i],nums[i]*min);
                 min = Math.min(nums[i],nums[i]*temp);
             }

code/lc221.java

@@ -13,8 +13,7 @@ public static void main(String[] args) {
         System.out.println(maximalSquare(matrix));
     }
     public static int maximalSquare(char[][] matrix) {
-        if(matrix.length==0)
-            return 0;
+        if(matrix.length==0) return 0;
         int[][] dp = new int[matrix.length][matrix[0].length];
         int max = 0;
         for (int i = 0; i < matrix.length ; i++) {

code/lc239.java

@@ -7,8 +7,8 @@
  * 思路：用双向队列，保证队列里是递减的。单调队列，好好学习一下。
  * Tips：与lc84做比较，84是递增栈
  */
-import java.util.ArrayDeque;
 import java.util.Deque;
+import java.util.LinkedList;
 
 public class lc239 {
     public static void main(String[] args) {
@@ -25,7 +25,7 @@ public static int[] maxSlidingWindow(int[] nums, int k) {
             return new int[]{};
         int[] res = new int[nums.length-k+1];
         int cur = 0;
-        Deque<Integer> dq = new ArrayDeque();   //队列里是递减的，存的仍然是下标
+        Deque<Integer> dq = new LinkedList();   //队列里是递减的，存的仍然是下标
         for (int i = 0; i < nums.length ; i++) {
             if( !dq.isEmpty() && dq.peekFirst()<=i-k)   //窗口长度过长了，删掉头
                 dq.removeFirst();

code/lc31.java

@@ -6,10 +6,14 @@
  * 分类：Array
  * 思路：从后往前找第一个变小的数x，从后往前找出比第一个x大的数，交换，再把之后的数逆序即可
  * Tips：很典型的排列组合题，思路方法记忆一下。注意比较时是否有=。
+ *  https://leetcode.com/problems/next-permutation/solution/
+ *
+ *  1584 76531
+ *  1585 13467
  */
 public class lc31 {
     public static void main(String[] args) {
-        int[] nums = {1,2,3};
+        int[] nums = {1,5,8,4,7,6,5,3,1};
         nextPermutation(nums);
         for (int i:nums){
             System.out.println(i);
@@ -25,7 +29,7 @@ public static void nextPermutation(int[] nums) {
         }
         ptr--;
         if(ptr!=-1){
-            //从后往前，找比
+            //从后往前找出比第一个x大的数
             int val = nums[ptr];
             int ptr2 = nums.length-1;
             while(ptr2>ptr){

code/lc322.java

@@ -6,6 +6,7 @@
  * 分类：Dynamic Programming
  * 思路：和lc279一样的思路，注意下没解的情况
  * Tips：不用Set, 加一个dp[0]=0，可以直接递归出结果
+ *      dp[i] 表示组合成总值i的最少零钱数
  */
 import java.util.Arrays;
 import java.util.HashSet;

code/lc324.java

@@ -39,7 +39,6 @@ private void swap(int[] nums, int i, int j) {
     }
 
     public int findMedium(int[] nums, int left, int right, int k){
-        int cur = nums[left];
         int l = left;
         int r = right;
         while(left<right){

code/lc39.java

@@ -20,8 +20,7 @@ public static void main(String[] args) {
     }
     public static List<List<Integer>> combinationSum(int[] candidates, int target) {
         List<List<Integer>> res = new ArrayList<List<Integer>>();
-        if(candidates.length==0||target==0)
-            return res;
+        if(candidates.length==0||target==0) return res;
         List<Integer> l = new ArrayList<Integer>();
         backtracking(res,candidates,target,l,0,0);
         return res;

code/lc542.java

@@ -0,0 +1,38 @@
+package code;
+/*
+ * 542. 01 Matrix
+ * 题意：0,1矩阵，每个点找离自己最近的0的距离
+ * 难度：Medium
+ * 分类：Depth-first Search, Breadth-first Search
+ * 思路：广度优先搜索
+ * Tips：
+ */
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class lc542 {
+    public int[][] updateMatrix(int[][] matrix) {
+        Queue<int[]> qu = new LinkedList();
+        for(int i=0; i<matrix.length; i++){
+            for(int j=0; j<matrix[0].length; j++){
+                if(matrix[i][j]==0){
+                    qu.add(new int[]{i,j});
+                }
+                else matrix[i][j]=Integer.MAX_VALUE;
+            }
+        }
+
+        int[][] dirs = {{-1,0},{1,0},{0,-1},{0,1}};
+        while(!qu.isEmpty()){
+            int[] cell = qu.remove();
+            for(int i=0; i<4; i++){
+                int cur_row = cell[0]+dirs[i][0];
+                int cur_col = cell[1]+dirs[i][1];
+                if(cur_row<0||cur_row>=matrix.length||cur_col<0||cur_col>=matrix[0].length||matrix[cur_row][cur_col]<=matrix[cell[0]][cell[1]]+1) continue;
+                matrix[cur_row][cur_col] = matrix[cell[0]][cell[1]]+1;
+                qu.add(new int[]{cur_row,cur_col});
+            }
+        }
+        return matrix;
+    }
+}

code/lc685.java

@@ -7,7 +7,7 @@
  * 思路：要把问题想清楚
  *      判断是否有某个节点父节点有两个, 记为e1, e2
  *      再判断是否有环
- *      4中情况，分别想清楚返回什么
+ *      4种情况，分别想清楚返回什么
  *      自己没想清楚两种情况的交叉，以为判断完第一步就可直接返回
  *      如何判断有环，可以利用并查集的思想
  * Tips：https://leetcode.com/problems/redundant-connection-ii/discuss/108045/C%2B%2BJava-Union-Find-with-explanation-O(n)

code/lc87.java

@@ -0,0 +1,26 @@
+package code;
+/*
+ * 87. Scramble String
+ * 题意：把字符串写成二叉树的形式，问是否可以交换非叶子节点的左右孩子，生成新的字符串
+ * 难度：Hard
+ * 分类：String, Dynamic Programming
+ * 思路：递归的方法，判断交换两段是否满足
+ * Tips：注意先判断两个字符串是否字符一样，用map的方法，否则长的字符串会超时
+ */
+public class lc87 {
+    public boolean isScramble(String s1, String s2) {
+        if(s1.equals(s2)) return true;
+        if(s1.length()!=s2.length()) return false;
+        int[] cur_map = new int[26];
+        for(int i=0; i<s1.length(); i++){
+            cur_map[s1.charAt(i)-'a']++;
+            cur_map[s2.charAt(i)-'a']--;
+        }
+        for(int i=0; i<26; i++) if(cur_map[i]!=0) return false;
+        for(int i=1; i<s1.length(); i++){
+            if( isScramble(s1.substring(0,i), s2.substring(0,i)) && isScramble(s1.substring(i), s2.substring(i))) return true;
+            if( isScramble(s1.substring(0,i), s2.substring(s1.length()-i)) && isScramble(s1.substring(i), s2.substring(0,s1.length()-i))) return true;
+        }
+        return false;
+    }
+}

code/lc912.java

@@ -10,7 +10,7 @@
  */
 public class lc912 {
     public static void main(String[] args) {
-        int[] arr = sortArray2(new int[]{5,2,3,1});
+        int[] arr = sortArray3(new int[]{5,2,3,1});
         for(int i: arr){
             System.out.println(i);
         }
@@ -80,7 +80,7 @@ public static void merge(int[] nums, int left, int mid, int right){
     }
 
     //堆排
-    public int[] sortArray3(int[] nums) {
+    public static int[] sortArray3(int[] nums) {
         //建堆
         int pos = nums.length/2;
         while(pos>=0){
@@ -100,7 +100,7 @@ public int[] sortArray3(int[] nums) {
         return nums;
     }
 
-    public void AdjustTree(int[] nums, int len, int pos){   //调整堆
+    public static void AdjustTree(int[] nums, int len, int pos){   //调整堆
         int pos_exchange = pos*2+1;
         while(pos_exchange<=len){   //left
             if(pos_exchange+1<=len&&nums[pos_exchange+1]>nums[pos_exchange]){   //比较左右节点，挑出来大的

code/lc94.java

@@ -20,8 +20,7 @@ public class TreeNode {
     }
     public List<Integer> inorderTraversal(TreeNode root) {
         List<Integer> res = new ArrayList<>();
-        if(root==null)
-            return res;
+        if(root==null) return res;
         Stack<TreeNode> st = new Stack();
         while( !st.isEmpty() || root!=null ) {      //注意停止条件
             while (root != null) {

code/lc95.java

@@ -9,7 +9,7 @@
  * 难度：Medium
  * 分类：Dynamic Programming, Tree
  * 思路：96只要求计算数量，dp就行，当要把所有情况都输出的时候，往往递归更方便一些
- *      返回的的是跟的List，不用把整颗数的节点都复制了，所以下层的叶子节点是被多个父节点指向
+ *      返回的的是根的List，不用把整颗数的节点都复制了，所以下层的叶子节点是被多个父节点指向
  *      暴力，子情况被计算了多遍，为什么不用mem呢？？？
  * Tips：lc96
  */

code/lc97.java

@@ -0,0 +1,25 @@
+package code;
+/*
+ * 97. Interleaving String
+ * 题意：两个字符串，穿插成第三个字符串
+ * 难度：Hard
+ * 分类：String, Dynamic Programming
+ * 思路：递归+记忆；动态规划
+ * Tips：dp空间还可以压缩
+ *       注意字符串下标index
+ */
+public class lc97 {
+    public boolean isInterleave(String s1, String s2, String s3) {
+        if(s1.length()+s2.length()!=s3.length()) return false;
+        boolean[][] dp = new boolean[s1.length()+1][s2.length()+1];
+        for(int i=0; i<=s1.length(); i++){  //从0到<=
+            for(int j=0; j<=s2.length(); j++){
+                if(i==0&&j==0) dp[i][j]=true;
+                else if(i==0) dp[i][j] = (s3.charAt(i+j-1)==s2.charAt(j-1)&&dp[i][j-1]);    //注意减一
+                else if(j==0) dp[i][j] = (s3.charAt(i+j-1)==s1.charAt(i-1)&&dp[i-1][j]);
+                else dp[i][j] = s3.charAt(i+j-1)==s2.charAt(j-1)&&dp[i][j-1] || s3.charAt(i+j-1)==s1.charAt(i-1)&&dp[i-1][j];
+            }
+        }
+        return dp[s1.length()][s2.length()];
+    }
+}

code/lc983.java

@@ -7,7 +7,7 @@
  * 思路：猛一看题，感觉很难
  *      想了以后，会发现就是典型的数组dp，难的地方主要在于数组不代表每天，如何把days中的天全部覆盖到
  *      方法是将days转换为一个365长的arr，代表每一天
- *      如果这一天不在days中，则 dp[i] = dp[i-1]， 否则 dp[i] = min(d p[i-1]+cost , dp[i-2]+cost ,dp[i-7]+cost )
+ *      如果这一天不在days中，则 dp[i] = dp[i-1]， 否则 dp[i] = min(dp[i-1]+cost , dp[i-2]+cost ,dp[i-7]+cost )
  * Tips：
  */
 public class lc983 {

readme.md

@@ -86,11 +86,13 @@ LeetCode 指南
 | 079 [Java](./code/lc79.java)
 | 084 [Java](./code/lc84.java)
 | 085 [Java](./code/lc85.java)
+| 087 [Java](./code/lc87.java)
 | 088 [Java](./code/lc88.java)
 | 091 [Java](./code/lc91.java)
 | 094 [Java](./code/lc94.java)
 | 095 [Java](./code/lc95.java)
 | 096 [Java](./code/lc96.java)
+| 097 [Java](./code/lc97.java)
 | 098 [Java](./code/lc98.java)
 | 100 [Java](./code/lc100.java)
 | 101 [Java](./code/lc101.java)