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)