坐标&接龙型动态规划 - 20181026

109. Triangle

此题还可以用DFS,记忆化搜索去做，二刷实现

 public class Solution {
     /**
      * @param triangle: a list of lists of integers
      * @return: An integer, minimum path sum
      */
     public int minimumTotal(int[][] triangle) {
         // write your code here
         if (triangle == null || triangle.length == 0 || triangle[0] == null || triangle[0].length == 0) {
             return -1;
         }

         int r = triangle.length;

         //定义f[][]为0,0到x，y的最小路径
         int[][] f = new int[r][r];
         f[0][0] = triangle[0][0];
         //初始化两条边
         for (int i = 1; i < r; i++) {
             f[i][0] = f[i - 1][0] + triangle[i][0];
             f[i][i] = f[i - 1][i - 1] + triangle[i][i];
         }

         for (int i = 1; i < r; i++)
             for (int j = 1; j < i; j++) {
                 f[i][j] = triangle[i][j] + Math.min(f[i - 1][j], f[i - 1][j - 1]);
             }

         int minTotal = f[r-1][0];
         for (int i = 0; i < r; i++) {
             minTotal = f[r - 1][i] < minTotal ? f[r - 1][i] : minTotal;
         }
         return minTotal;
     }
 }

110. Minimum Path Sum

 public class Solution {
     /**
      * @param grid: a list of lists of integers
      * @return: An integer, minimizes the sum of all numbers along its path
      */
     public int minPathSum(int[][] grid) {
         // write your code here
         if (grid == null || grid.length == 0 || grid[0] == null || grid[0].length == 0) {
             return -1;
         }

         //定义f为0,0到x,y的最小路径和
         int r = grid.length;
         int c = grid[0].length;
         int[][] f = new int[r][c];

         f[0][0] = grid[0][0];
         //初始化两条边
         for (int i = 1; i < c; i++) {
             f[0][i] = grid[0][i] + f[0][i - 1];
         }
         for (int i = 1; i < r; i++) {
             f[i][0] = grid[i][0] + f[i - 1][0];
         }

         for (int i = 1; i < r; i++)
             for (int j = 1; j < c; j++) {
                 f[i][j] = grid[i][j] + Math.min(f[i - 1][j], f[i][j - 1]);
             }
         return f[r - 1][c - 1];
     }
 }

114. Unique Paths

 public class Solution {
     /**
      * @param m: positive integer (1 <= m <= 100)
      * @param n: positive integer (1 <= n <= 100)
      * @return: An integer
      */
     public int uniquePaths(int m, int n) {
         // write your code here
         if (m <= 0 || n <= 0) {
             return -1;
         }

         int[][] sum = new int[m][n];

         for (int i = 0; i < m; i++) {
             sum[i][0] = 1;
         }
         for (int i = 0; i < n; i++) {
             sum[0][i] = 1;
         }

         for (int i = 1; i < m; i++)
             for (int j = 1; j < n; j++) {
                 sum[i][j] = sum[i - 1][j] + sum[i][j - 1];
             }

         return sum[m - 1][n - 1];
     }
 }

111. Climbing Stairs

 public class Solution {
     /**
      * @param n: An integer
      * @return: An integer
      */
     public int climbStairs(int n) {
         // write your code here
         if (n <= 0) {
             return 0;
         }
         if(n==1){
             return 1;
         }
         int[] f = new int[n+1];
         f[1] = 1;
         f[2] = 2;

         for (int i = 3; i <= n; i++) {
             f[i] = f[i - 1] + f[i - 2];
         }
         return f[n];
     }
 }

Method1: DP

116. Jump Game

 public class Solution {
     /**
      * @param A: A list of integers
      * @return: A boolean
      */
     public boolean canJump(int[] A) {
         // write your code here
         if (A == null || A.length == 0) {
             return false;
         }

         boolean[] can = new boolean[A.length];
         can[0] = true;
         for (int i = 0; i < A.length; i++) {
             int canJumpLen = A[i];
             for (int j = 0; j <= canJumpLen; j++) {
                 if (i + j > A.length - 1) {
                     break;
                 }
                 can[i + j] = true & can[i];
             }
         }
         return can[A.length - 1];

     }

 }

117. Jump Game II

 public class Solution {
     /**
      * @param A: A list of integers
      * @return: An integer
      */
     public int jump(int[] A) {
         // write your code here
         if(A==null || A.length==0){
             return 0;
         }

         int[] f = new int[A.length];
         f[0] = 0;
         for(int i=1;i<A.length;i++){
             f[i] = Integer.MAX_VALUE;
             for(int j=0;j<i;j++){
                 if(j+A[j]>=i){
                     f[i] = Math.min(f[i],f[j]+1);
                 }
             }
         }
         return f[A.length-1];
     }
 }

Method2:Greedy(二刷)

76. Longest Increasing Subsequence

 public class Solution {
     /**
      * @param nums: An integer array
      * @return: The length of LIS (longest increasing subsequence)
      */
     public int longestIncreasingSubsequence(int[] nums) {
         // write your code here
         if (nums == null || nums.length == 0) {
             return 0;
         }

         int[] f = new int[nums.length];
         f[0] = 1;
         for (int i = 0; i < nums.length; i++) {
             f[i] = 1;
             for (int j = 0; j < i; j++) {
                 if (nums[j] < nums[i]) {
                     f[i] = Math.max(f[i], f[j] + 1);
                 }
             }
         }
         int maxLen = 1;
         for (int i = 0; i < f.length; i++) {
             maxLen = Math.max(f[i], maxLen);
         }
         return maxLen;
     }
 }

二分法：AC的答案是错误的，二分时重复情况应踢掉，见602题解答

 public class Solution {
     /**
      * @param nums: An integer array
      * @return: The length of LIS (longest increasing subsequence)
      */
     public int longestIncreasingSubsequence(int[] nums) {
         // write your code here
         if (nums == null || nums.length == 0) {
             return 0;
         }

         int[] tails = new int[nums.length];
         tails[0] = nums[0];
         int len = 1;
         for (int i = 1; i < nums.length; i++) {
             if (nums[i] == tails[0] || nums[i] == tails[len - 1]) {
                 continue;
             }
             if (nums[i] < tails[0]) {
                 tails[0] = nums[i];
                 continue;
             }
             if (nums[i] > tails[len - 1]) {
                 tails[len] = nums[i];
                 len++;
                 continue;
             }

             if (nums[i] > tails[0] && nums[i] < tails[len - 1]) {
                 //第一个大于nums[i]的位置
                 int index = binarySearch(tails, nums[i],len);
                 if (index >= 0 && index <= len - 1) {
                     tails[index] = nums[i];
                 }
             }
         }
         return len;
     }

     public int binarySearch(int[] nums, int target,int len) {
         if (nums == null || nums.length == 0) {
             return -1;
         }

         int start = 0;
         int end = len - 1;
         while (start + 1 < end) {
             int mid = start + (end - start) / 2;
             if (nums[mid] == target) {
                 start = mid;
             }
             if (nums[mid] > target) {
                 end = mid;
             }
             if (nums[mid] < target) {
                 start = mid;
             }
         }
         if (nums[start] > target) {
             return start;
         }
         if (nums[end] > target) {
             return end;
         }
         return -1;
     }
 }

602. Russian Doll Envelopes

DP会TLE，考虑用二分优化时间复杂度

method1：DP(时间复杂度o（n^2）)

 public class Solution {
     /*
      * @param envelopes: a number of envelopes with widths and heights
      * @return: the maximum number of envelopes
      */
     public int maxEnvelopes(int[][] envelopes) {
         // write your code here
         if (envelopes == null || envelopes.length == 0 || envelopes[0] == null || envelopes[0].length == 0) {
             return 0;
         }

         Comparator<int[]> comparator = new Comparator<int[]>() {
             @Override
             public int compare(int[] o1, int[] o2) {
                 return o1[0] == o2[0] ? o1[1] - o2[1] : o1[0] - o2[0];
             }
         };

         Arrays.sort(envelopes, comparator);
         int[] f = new int[envelopes.length];
         f[0] = 1;

         int maxLen = 1;
         for (int i = 1; i < f.length; i++) {
             f[i] = 1;
             for (int j = 0; j < i; j++) {
                 if (envelopes[i][0] > envelopes[j][0] && envelopes[i][1] > envelopes[j][1])
                     f[i] = Math.max(f[i], f[j] + 1);
             }
             maxLen = Math.max(f[i], maxLen);
         }

         return maxLen;
     }
 }

method2:　二分（o（NlogN））注意初次排序时按宽度递增排序，宽度相同时高度递减，将问题简化为求最长子序列（递减可以易于去除宽度相同的序列）

 public class Solution {
     /*
      * @param envelopes: a number of envelopes with widths and heights
      * @return: the maximum number of envelopes
      */
     public int maxEnvelopes(int[][] envelopes) {
         // write your code here
         if (envelopes == null || envelopes.length == 0 || envelopes[0] == null || envelopes[0].length == 0) {
             return 0;
         }

         //按宽度递增排序，宽度相同时高度递减 求最长子序列（递减可以易于去除宽度相同的序列）
         Comparator<int[]> comparator = new Comparator<int[]>() {
             @Override
             public int compare(int[] o1, int[] o2) {
                 return o1[0] == o2[0] ? o2[1] - o1[1] : o1[0] - o2[0];
             }
         };

         Arrays.sort(envelopes, comparator);
         return longestIncreasingSubsequence(envelopes);
     }

     public int longestIncreasingSubsequence(int[][] envelopes) {
         // write your code here
         if (envelopes == null || envelopes.length == 0) {
             return 0;
         }

         int[] tails = new int[envelopes.length];
         tails[0] = envelopes[0][1];
         int len = 1;
         for (int i = 1; i < envelopes.length; i++) {
             if (envelopes[i][1] == tails[0] || envelopes[i][1] == tails[len - 1]) {
                 continue;
             }
             if (envelopes[i][1] < tails[0]) {
                 tails[0] = envelopes[i][1];
                 continue;
             }
             if (envelopes[i][1] > tails[len - 1]) {
                 tails[len] = envelopes[i][1];
                 len++;
                 continue;
             }

             if (envelopes[i][1] > tails[0] && envelopes[i][1] < tails[len - 1]) {
                 //第一个大于nums[i]的位置
                 int index = binarySearch(tails, envelopes[i][1],len);
                 if (index >= 0 && index <= len - 1) {
                     tails[index] = envelopes[i][1];
                 }
             }
         }
         return len;
     }

     public int binarySearch(int[] nums, int target,int len) {
         if (nums == null || nums.length == 0) {
             return -1;
         }

         int start = 0;
         int end = len - 1;
         while (start + 1 < end) {
             int mid = start + (end - start) / 2;
             if (nums[mid] == target) {
                 //重复情况要踢掉，以免替换了后面的大数，会造成wrong answer
                 return -1;
             }
             if (nums[mid] > target) {
                 end = mid;
             }
             if (nums[mid] < target) {
                 start = mid;
             }
         }
         if (nums[start] > target) {
             return start;
         }
         if (nums[end] > target) {
             return end;
         }
         return -1;
     }

 }