20181227

code/lc42.java

@@ -4,7 +4,7 @@ package code;
  * 题意：能盛多少水
  * 难度：Hard
  * 分类：Array, Two Pointers, Stack
- * 思路：三种方法，DP先求出来每个位置的maxleft,maxright，再遍历一遍;两个指针，类似lc11题的思路;用栈数据结构;
+ * 思路：三种方法:1.DP先求出来每个位置的maxleft,maxright，再遍历一遍;2.两个指针，类似lc11题的思路;3.用栈数据结构;
  * Tips：
  */
 public class lc42 {

code/lc55.java

+package code;
+/*
+ * 55. Jump Game
+ * 题意：数组中存储能走的最大步数，问是否能从数组开始走到数组结尾
+ * 难度：Medium
+ * 分类：Array, Greedy
+ * 思路：因为只要有一条路径走到就可以，不需要计算所有的路径，所以用贪心的方法.
+ * Tips：很经典的题目，记忆一下
+ */
+public class lc55 {
+    public static void main(String[] args) {
+        int[] arr = {3,2,1,0,4};
+        System.out.println(canJump(arr));
+    }
+    public static boolean canJump(int[] nums) {
+        int des = nums.length-1;
+        for (int i = nums.length-1 ; i >=0 ; i--) {
+            if(i + nums[i] >= des)
+                des = i;
+        }
+        return des == 0;
+    }
+}

code/lc56.java

+package code;
+/*
+ * 56. Merge Intervals
+ * 题意：区间合并
+ * 难度：Medium
+ * 分类：Array, Sort
+ * 思路：排序以后，遍历一遍就可以了
+ * Tips：对象的排序问题，转化为了数组，再把数组排序; java8可以用类似lambda表达式的方式排序; Collection实现Comparator排序
+ */
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class lc56 {
+
+//    Collection.sort
+/*    Collections.sort(intervals, new Comparator<Interval>(){
+        @Override
+        public int compare(Interval obj0, Interval obj1) {
+            return obj0.start - obj1.start;
+        }
+    });*/
+
+//    lambda 表达式
+//    intervals.sort((i1, i2) -> Integer.compare(i1.start, i2.start));
+
+    public class Interval {
+        int start;
+        int end;
+        Interval() { start = 0; end = 0; }
+        Interval(int s, int e) { start = s; end = e; }
+    }
+
+    public List<Interval> merge(List<Interval> intervals) {
+        List<Interval> res = new ArrayList();
+        if(intervals.size()==0)
+            return res;
+        int[] starts = new int[intervals.size()];
+        int[] ends = new int[intervals.size()];
+        for (int i = 0; i < intervals.size() ; i++) {
+            starts[i] = intervals.get(i).start;
+            ends[i] = intervals.get(i).end;
+        }
+        Arrays.sort(starts);
+        Arrays.sort(ends);
+        for (int i = 1; i < starts.length ; i++) {
+            if(starts[i]<=ends[i-1]){
+                starts[i] = starts[i-1];
+            }else{
+                res.add(new Interval(starts[i-1],ends[i-1]));
+            }
+        }
+        res.add(new Interval(starts[starts.length-1],ends[starts.length-1]));   //把最后一个区间也加上
+        return res;
+    }
+}

code/lc62.java

+package code;
+/*
+ * 62. Unique Paths
+ * 题意：求从数组[0,0]走到[m,n]的不同路径数
+ * 难度：Medium
+ * 分类：Array, Dynamic Programming
+ * 思路：和lc63, lc64思路一样, arr存储的内容由路径数换成了和
+ */
+public class lc62 {
+    public static void main(String[] args) {
+        System.out.println(uniquePaths(7,3));
+    }
+
+    public static int uniquePaths(int m, int n) {
+        int[][] arr = new int[m][n];
+        for (int i = 0; i < m ; i++) {
+            for (int j = 0; j < n ; j++) {
+                if(i==0 && j==0)
+                    arr[i][j] = 1;
+                else if(i==0)
+                    arr[i][j] = arr[i][j-1];
+                else if(j==0)
+                    arr[i][j] = arr[i-1][j];
+                else
+                    arr[i][j] = arr[i-1][j]+arr[i][j-1];
+            }
+        }
+        return arr[m-1][n-1];
+    }
+}

code/lc63.java

@@ -5,6 +5,7 @@ package code;
  * 题意：路径数
  * 难度：Medium
  * 分类：Array, Dynamic Programming
+ * 思路：和lc64, lc62思路一样, arr存储的内容由路径数换成了和
  * Tips：可以用一位数组减小空间复杂度
  */
 public class lc63 {

code/lc64.java

+package code;
+/*
+ * 64. Minimum Path Sum
+ * 题意：求矩阵和最小的路径
+ * 难度：Medium
+ * 分类：Array, Dynamic Programming
+ * 思路：和lc63, lc62思路一样, arr存储的内容由路径数换成了和
+ */
+public class lc64 {
+    public static void main(String[] args) {
+        int[][] grid = {{1,3,1},{1,5,1},{4,2,1}};
+        System.out.println(minPathSum(grid));
+    }
+    public static int minPathSum(int[][] grid) {
+        int m = grid.length;
+        int n = grid[0].length;
+        int[][] arr = new int[m][n];
+        for (int i = 0; i < m ; i++) {
+            for (int j = 0; j < n ; j++) {
+                if(i==0 && j==0)
+                    arr[i][j] = grid[i][j];
+                else if(i==0)
+                    arr[i][j] = arr[i][j-1] + grid[i][j];
+                else if(j==0)
+                    arr[i][j] = arr[i-1][j] + grid[i][j];
+                else
+                    arr[i][j] = Math.min(arr[i-1][j],arr[i][j-1]) + grid[i][j];
+            }
+        }
+        return arr[m-1][n-1];
+    }
+}

code/lc72.java

+package code;
+/*
+ * 72. Edit Distance
+ * 题意：编辑距离
+ * 难度：Hard
+ * 分类：String, Dynamic Programming
+ * 思路：dp[i][j] 可以由 dp[i-1][j], dp[i][j-1], dp[i-1][j-1] 变过来
+ * Tips：很经典的题，注意如何初始化dp[0][i]和dp[i][0]，以及dp更新规则。空间复杂度还可以优化。
+ */
+public class lc72 {
+    public static void main(String[] args) {
+        System.out.println(minDistance("intention","execution"));
+    }
+    public static int minDistance(String word1, String word2) {
+        int[][] dp = new int[word1.length()+1][word2.length()+1];
+        for (int i = 0; i < word2.length()+1 ; i++)
+            dp[0][i] = i;
+        for (int i = 0; i < word1.length()+1 ; i++)
+            dp[i][0] = i;
+        for (int i = 1; i < word1.length()+1 ; i++) {
+            for (int j = 1; j < word2.length()+1 ; j++) {
+                int temp = Math.min(dp[i][j-1]+1,dp[i-1][j]+1);
+                if(word1.charAt(i-1)==word2.charAt(j-1))
+                    dp[i][j] = Math.min(dp[i-1][j-1],temp);
+                else
+                    dp[i][j] = Math.min(dp[i-1][j-1]+1,temp);
+            }
+        }
+        return dp[word1.length()][word2.length()];
+    }
+}

code/lc75.java

+package code;
+/*
+ * 75. Sort Colors
+ * 题意：重排序，数组中只有0,1,2
+ * 难度：Medium
+ * 分类：Array, Two Pointers, Sort
+ * 思路：两个指针，尾指针放2，头指针放1
+ * Tips：一个for循环就可以了，注意避免自己与自己交换，造成l>i
+ */
+public class lc75 {
+    public static void main(String[] args) {
+        int[] nums = {1,0,2};
+        sortColors(nums);
+        for (int i = 0; i < nums.length ; i++) {
+            System.out.println(nums[i]);
+        }
+    }
+    public static void sortColors(int[] nums) {
+        int l = 0;
+        int r = nums.length-1;
+        for (int i = 0; i <= r ; i++) {  // i<r而不是length, 否则又换回来了
+            if(nums[i]==0 && i!=l ){    //避免自己与自己交换
+                int temp = nums[l];
+                nums[l] = nums[i];
+                nums[i] = temp;
+                l++;
+                i--;
+            }else if(nums[i]==2){
+                int temp = nums[r];
+                nums[r] = nums[i];
+                nums[i] = temp;
+                r--;
+                i--;
+            }
+        }
+    }
+}