leetCode 26-30

53-连续子序列最大值

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4] 输出：6 解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

class Solution {
    public int maxSubArray(int[] nums) {
        int len = nums.length;
        if(len==0 || nums==null) return 0;
        int[] dp = new int[len];
        dp[0] = nums[0];
        int max = dp[0];
        for(int i=1;i<len;i++){
            if(dp[i-1]>0){
                dp[i] = dp[i-1]+nums[i];
            }else{
                dp[i] = nums[i];
            }
            max = Math.max(max,dp[i]);
        }
        return max;
    }
}

55-跳跃游戏

给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标。

示例 1：

输入：nums = [2,3,1,1,4] 输出：true 解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3
步到达最后一个下标。

遍历数组，记录能跳的最远距离即可

class Solution {
    public boolean canJump(int[] nums) {
        if(nums==null) return false;
        //表示前n-1个元素可以跳到的最远距离
        int k = 0;
        //只需要走到可以跳的最远距离即可，不用再往后判断
        //如[0，2，5，3]第一步只能跳0步，就不用再向下执行了
        for(int i=0;i<=k;i++){
            //nums[i]位置上能到的最远距离
            int temp = i+nums[i];
            //更新最远距离
            k = Math.max(k,temp);
            if(k>=nums.length-1) return true;
        }
        //到达k但是依旧没有到末尾
        return false;
    }
}

56-合并区间

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi]
。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。

示例 1：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]] 输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

class Solution {
    public int[][] merge(int[][] intervals) {
        //先对区间进行排序（用区间的左边界）
        //如[[0,1],[4,5],[0,3],[9,12],[6,7]]-->[[0,1],[0,3],[4,5],[6,7],[9,12]]
        Arrays.sort(intervals,new Comparator<>(){
            public int compare(int[] o1,int[] o2){
                return o1[0]-o2[0];
            }
        });
        List<int[]> path = new ArrayList<>();
        //双指针标记位置
        //这里右指针是指每次循环在递进的右边界
        int left= 0,right = 0;
        while(right<intervals.length){
            //以此判断能否合并
            int leftBound = intervals[left][0];
            int rightBound = intervals[right][1];
            //依次找到左边界小于前面区间的右边界的最大值-->找到[4,5] (4<=3不成立)
            //：：这里是先计算的最大值然后right++的，结束时，right在rightBound值的下一个位置
            while(right<intervals.length&&intervals[right][0]<=rightBound){
            //依次更新当前最大右边界
                rightBound = Math.max(intervals[right][1],rightBound);
                right++;
            }
            path.add(new int[]{leftBound,rightBound});
            left = right;
        }
        //把值拷贝进数组
        int[][] res = new int[path.size()][2];
        for(int i=0;i<path.size();i++){
            res[i][0] = path.get(i)[0];
            res[i][1] = path.get(i)[1];
        }
        return res;
    }
}

62-不同路径

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

class Solution {
    public int uniquePaths(int m, int n) {
        //我们用 f(i, j)f(i,j) 表示从左上角走到 (i, j)(i,j) 的路径数量，
        //其中 ii 和 jj 的范围分别是 [0, m)[0,m) 和 [0, n)[0,n)。
        //由于我们每一步只能从向下或者向右移动一步，因此要想走到 (i, j)(i,j)，
        //如果向下走一步，那么会从 (i-1, j)(i−1,j) 走过来；如果向右走一步，
        //那么会从 (i, j-1)(i,j−1) 走过来。
        //因此我们可以写出动态规划转移方程：f(i,j) = f(i-1,j)+f(i,j-1);
        //再注意处理边界问题即可，即i=0时或者j=0时

        //为了方便代码编写，
        //我们可以将所有的 f(0, j)f(0,j) 以及 f(i, 0)，f(i,0) 都设置为边界条件，
        //犹豫只能向右或者向下走，因此它们的值均为 1，即一条路径。
        int[][] f = new int[m][n];
        for(int i=0;i<m;i++) f[i][0] = 1;
        for(int i =0;i<n;i++) f[0][i] = 1;
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                f[i][j] = f[i-1][j]+f[i][j-1];
            }
        }
        return f[m-1][n-1];
    }
}

64-最小路径

给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

class Solution {
    public int minPathSum(int[][] grid) {
        //和上一题，机器人的不同路差不多
        //不同之处是第一行和第一列的值等于从头到对应位置的值的累加
        //其他位置上:   dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1])+grid[i][j]
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return 0;
        }
        int rows = grid.length,cols = grid[0].length;
        int[][] dp = new int[rows][cols];
        dp[0][0] = grid[0][0];
        //数组第0列的值
        for(int i = 1;i<rows;i++){
            dp[i][0] = dp[i-1][0]+grid[i][0];
        }
        //数组第0行的值
        for(int i = 1;i<cols;i++){
            dp[0][i] = dp[0][i-1]+grid[0][i];
        }
        for(int i = 1;i<rows;i++){
            for(int j=1;j<cols;j++){
                dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1])+grid[i][j];
            }
        }
        return dp[rows-1][cols-1];
    }
}