（算法题）Day-20230305

最小路径和

思路：动态规划，\(dp[i][j]\) 保存 \((i,\ j)\) 时最小路径值

class Solution {
    public int minPathSum(int[][] grid) {
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[0].length;j++){
                if(i==0 && j==0) continue;
                else if(i==0) grid[i][j] = grid[i][j-1]+grid[i][j];
                else if(j==0) grid[i][j] = grid[i-1][j]+grid[i][j];
                else grid[i][j] = Math.min(grid[i-1][j],grid[i][j-1])+grid[i][j];
            }
        }
        return grid[grid.length-1][grid[0].length-1];
    }
}

不同路径

思路：动态规划，\(dp[i][j]\) 到达 \((i,\ j)\) 最多路径

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        for (int i = 0; i < n; i++) dp[0][i] = 1;
        for (int i = 0; i < m; i++) dp[i][0] = 1;
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];  
    }
}

合并区间

思路：先按起点进行排序，然后合并区间即可

class Solution {
    public int[][] merge(int[][] intervals) {
        Arrays.sort(intervals,(v1,v2)->v1[0]-v2[0]);
        int[][] res = new int[intervals.length][2];
        int idx=-1;
        for(int[] interval:intervals){
            if(idx==-1 || interval[0]>res[idx][1]) res[++idx]=interval;
            else res[idx][1] = Math.max(interval[1],res[idx][1]);
        }
        return Arrays.copyOf(res,idx+1);
    }
}

跳跃游戏

思路：挨着跳就行，只要 跳的步数 能够大于索引值，就能够到达该索引位置，所以一直迭代即可

class Solution {
    public boolean canJump(int[] nums) {
        int k=0; 	// 能够到达的最大索引位置
        for(int i=0;i<nums.length;i++){
            if(i>k) return false;		// 到不了该索引位置，直接返回
            k = Math.max(k,i+nums[i]);		// 更新 k
        }
        return true;
    }
}

最大子数组和

思路：动态规划，利用一个 \(sum\) 来保存之前的和，那么对于下一个数来说，只有当 \(sum>0\) 时，和才会变大

class Solution {
    public int maxSubArray(int[] nums) {
        int ans=nums[0];
        int sum=0;
        for(int num:nums){
            if(sum>0){
                sum=sum+num;
            }else{
                sum=num;
            }
            ans = Math.max(ans,sum);
        }
        return ans;
    }
}