53.最大数组| 55.跳跃游戏|62.不同路径|64.最小路径和| 581.最短无序连续数组 | 581.最短无序连续子数组

class Solution {
    public int maxSubArray(int[] nums) {
        int sum = nums[0];
        int cur = nums[0];

        for(int i = 1;i<nums.length;i++){
            cur = Math.max(nums[i],nums[i]+cur);
            sum = Math.max(cur,sum);
        }
        return sum;
    }
}

class Solution {
    public boolean canJump(int[] nums) {
        int len = nums.length;
        int end = len -1;
        for(int i= len-2;i>=0;i--){
            if(end-i <=nums[i]){end = i;} 
        }
        return end == 0;
    }
}


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

class Solution {
    public int minPathSum(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int[][] dp = new int[m][n];
        dp[0][0] = grid[0][0];
        for(int i=1;i<n;i++){
            dp[0][i] = dp[0][i-1] + grid[0][i];
        }
        for(int i=1;i<m;i++){
            dp[i][0] = dp[i-1][0] + grid[i][0];
        }
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1]) + grid[i][j];
            }
        }
        return dp[m-1][n-1];
    }
}


class Solution {
    public int findUnsortedSubarray(int[] nums) {
        int n = nums.length;
        int left=0 ,right = n-1;
        //找到最左最右
        while(left<n-1 && nums[left] <= nums[left+1]){
            left++;
        }
        if(left == n-1){
            return 0;
        }
        while(right >0 && nums[right]>= nums[right-1]){
            right--;
        }
        //找到数组最小最大
        int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
        for(int i = left;i<=right;i++){
            min = Math.min(nums[i],min);
            max = Math.max(nums[i],max);
        }
        while(left>0 && nums[left-1]>min){
            left--;
        }
        while(right<n-1 && nums[right+1]<max){
            right++;
        }
        return right-left+1;
    }
}