70：子数组最大和与拓展

 

在此基础上得出左右边界

    public int maxSubArray(int[] nums) {
        int len = nums.length;
        int[] record = new int[len];
        int ans = nums[0];
        record[0] = nums[0];
        for (int i = 1; i < len; i++) {
            record[i] = Math.max(nums[i], nums[i] + record[i - 1]);
            ans = Math.max(ans, record[i]);
        }
        return ans;
    }
    public int maxSubArray1(int[] nums) {
        int len = nums.length;
        int pre = nums[0];
        int ans = pre;
        for (int i = 1; i < len; i++) {
            pre = Math.max(nums[i], nums[i] + pre);
            ans = Math.max(pre, ans);
        }
        return ans;
    }
    public static int left;
    public static int right;
    public static int sum;
    public static void extra(int[] nums) {
        sum = Integer.MIN_VALUE;
        for (int l = 0, r = 0, pre = Integer.MIN_VALUE; r < nums.length; r++) {
            if (pre >= 0) {
                pre += nums[r];
            } else {
                pre = nums[r];
                l = r;
            }
            if (pre > sum) {
                sum = pre;
                left = l;
                right = r;
            }
        }
    }

 

 

    public int rob(int[] nums) {
        int len = nums.length;
        if (len == 1) {
            return nums[0];
        }
        if (len == 2) {
            return Math.max(nums[0], nums[1]);
        }
        int[] dp = new int[len];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        int ans = Math.max(dp[0], dp[1]);
        for (int i = 2; i < len; i++) {
            dp[i] = Math.max(dp[i - 1], Math.max(nums[i] + dp[i - 2], nums[i]));
            ans = Math.max(dp[i], ans);
        }
        return ans;
    }
    public int rob1(int[] nums) {
        int len = nums.length;
        if (len == 1) {
            return nums[0];
        }
        if (len == 2) {
            return Math.max(nums[0], nums[1]);
        }
        int prepre = nums[0];
        int pre = Math.max(nums[0], nums[1]);
        int ans = Math.max(pre, prepre);
        for (int i = 2; i < len; i++) {
            int cur = Math.max(pre, Math.max(nums[i] + prepre, nums[i]));
            ans = Math.max(ans, cur);
            prepre = pre;
            pre = cur;
        }
        return ans;
    }

 

    public int maxSubarraySumCircular(int[] nums) {
        int len = nums.length;
        int maxsum = nums[0];
        int minsum = nums[0];
        int premin = nums[0];
        int premax = nums[0];
        int total = nums[0];
        for (int i = 1; i < len; i++) {
            premax = Math.max(premax + nums[i], nums[i]);
            maxsum = Math.max(maxsum, premax);
            total += nums[i];
            premin = Math.min(premin + nums[i], nums[i]);
            minsum = Math.min(minsum, premin);
        }
        return minsum == total ? maxsum:Math.max(total - minsum, maxsum);
    }

 

    public int rob(int[] nums) {
        int len = nums.length;
        if (len == 1) {
            return nums[0];
        }
        if (len == 2) {
            return Math.max(nums[0], nums[1]);
        }
        if (len == 3) {
            return Math.max(nums[0], Math.max(nums[1], nums[2]));
        }
        return Math.max(nums[0] + rob1(nums, 2, len - 2), rob1(nums, 1, len - 1));
    }
    public int rob1(int[] nums, int l, int r) {
        if (l == r) {
            return nums[l];
        }
        if (r - l == 1) {
            return Math.max(nums[l], nums[r]);
        }
        int prepre = nums[l];
        int pre = Math.max(nums[l], nums[l + 1]);
        for (int i = l + 2; i <= r; i++) {
            int cur = Math.max(pre, nums[i] + prepre);
            prepre = pre;
            pre = cur;
        }
        return pre;
    }

 

    public int minCapability(int[] nums, int k) {
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < nums.length; i++) {
            min = Math.min(nums[i], min);
            max= Math.max(nums[i], max);
        }
        int ans = 0;
        while(min <= max) {
            int mid = (min + max) / 2;
            if (rob1(nums, mid) >= k) {
                ans = mid;
                max = mid - 1;
            } else {
                min = mid + 1;
            }
        }
        return ans;
    }
    public int rob1(int[] nums, int cap) {
        int len = nums.length;
        if (len == 1) {
            return nums[0] <= cap ? 1:0;
        }
        if (len == 2) {
            return (nums[0] <= cap || nums[1] <= cap) ? 1 : 0;
        }
        int prepre = nums[0] <= cap ? 1 : 0;
        int pre = (nums[0] <= cap || nums[1] <= cap) ? 1 : 0;
        for (int i = 2; i < len; i++) {
            int cur = Math.max(pre, (nums[i] <= cap ? 1 : 0) + prepre);
            prepre = pre;
            pre = cur;
        }
        return pre;
    }
    public int rob2(int[] nums, int cap) {
        int len = nums.length;
        int ans = 0;
        for (int i = 0; i < len; i++) {
            if (cap >= nums[i]) {
                ans += 1;
                i++;
            }
        }
        return ans;
    }

 

    public int[] getMaxMatrix(int[][] matrix) {
        int n = matrix.length;
        int m = matrix[0].length;
        int max = Integer.MIN_VALUE;
        int a = 0, b = 0, c= 0, d = 0;
        int[] nums = new int[m];
        for (int up = 0; up < n; up++) {
            Arrays.fill(nums, 0);
            for (int down = up; down < n; down++) {
                int pre = Integer.MIN_VALUE;
                for (int l = 0, r = 0; r < m; r++) {
                    nums[r] += matrix[down][r];
                    if (pre >= 0) {
                        pre += nums[r];
                    } else {
                        pre = nums[r];
                        l = r;
                    }
                    if (pre > max) {
                        max = pre;
                        a = up;
                        b = l;
                        c = down;
                        d = r;
                    }
                }
            }
        }
        return new int[]{a, b, c, d};
    }