力扣技巧-贪心算法

11. 盛最多水的容器

class Solution {
    public int maxArea(int[] height) {

        final int n = height.length;
        int left = 0;
        int right = n - 1;
        int res = 0;
        while (left < right) {
            res = Math.max((Math.min(height[left], height[right]) * (right - left)), res);
            if (height[left] < height[right]) {
                left ++;
            } else {
                right --;
            }
        }

        return res;
    }
}

42. 接雨水

class Solution {
    public int trap(int[] height) {

        final int n = height.length;
        Stack<Integer> stack = new Stack<>();
        int ans = 0;

        for (int i = 0; i < n; i ++) {

            while (!stack.isEmpty() && height[i] > height[stack.peek()]) {
                int top = stack.pop();
                if (stack.isEmpty()) {
                    break;
                }
                int left = stack.peek();
                int curWidth = i - left - 1;
                int curHeigth = Math.min(height[i], height[left]) - height[top];
                ans += curHeigth * curWidth;
            }

            stack.push(i);
        }

        return ans;
    }
}

435. 无重叠区间

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {

        final int n = intervals.length;
        Arrays.sort(intervals, new Comparator<int[]>(){
            public int compare(int[] a, int[] b) {
                return a[1] - b[1];
            }
        });

        int ans = 0;
        int preEnd = Integer.MIN_VALUE;
        for (int i = 0; i < n; i ++) {
            int start = intervals[i][0];
            if (start >= preEnd) {
                ans ++;
                preEnd = intervals[i][1];
            }
        }

        return n - ans;
    }
}

763. 划分字母区间

class Solution {
    public List<Integer> partitionLabels(String s) {
        final int n = s.length();
        int[] last = new int[26];

        for (int i = 0; i < n; i ++) {
            last[s.charAt(i) - 'a'] = i;
        }

        int end = 0;
        int start = 0;
        List<Integer> res = new ArrayList<>();

        for (int i = 0; i < n; i ++) {
            end = Math.max(end, last[s.charAt(i) - 'a']);
            if (i == end) {
                res.add(end - start + 1);
                start = end + 1;
            }
        }

        return res;
    }
}  

56. 合并区间

class Solution {
    public int[][] merge(int[][] intervals) {
        final int n = intervals.length;

        // 易错：根据start排序
        Arrays.sort(intervals, new Comparator<int[]>(){
            public int compare(int[] a, int[] b) {
                return a[0] - b[0];
            }
        });

        List<int[]> res = new ArrayList<>();
        int preStart = intervals[0][0];
        int preEnd = intervals[0][1];

        for (int i = 1; i < n; i ++) {
            if (intervals[i][0] > preEnd) {
                res.add(new int[]{preStart, preEnd});
                preStart = intervals[i][0];
                preEnd = intervals[i][1];
            } else {
                preEnd = Math.max(intervals[i][1], preEnd);
            }
        }

        res.add(new int[]{preStart, preEnd});

        final int m = res.size();
        int[][] ans = new int[m][2];
        for (int i = 0; i < m; i ++) {
            ans[i] = res.get(i);
        }

        return ans;
    }
} 

918. 环形子数组的最大和

class Solution {
    public int maxSubarraySumCircular(int[] nums) {
        final int n = nums.length;
        int sum = 0;
        for (int i = 0; i < n; i ++) {
            sum += nums[i];
        }

        int maxValue = getMaxValue(nums);
        int minValue = getMinValue(nums);

        return sum == minValue ? maxValue : Math.max(maxValue, sum - minValue);
    }

    private int getMaxValue(int[] nums) {
        final int n = nums.length;
        int left = -1;
        int ans = Integer.MIN_VALUE;
        int sum = 0;

        for (int i = 0; i < n; i ++) {
            if (sum < 0) {
                left = i;
                sum = nums[i];
            } else {
                sum += nums[i];
            }
            ans = Math.max(ans, sum);
        }

        return ans;
    }

    private int getMinValue(int[] nums) {
        final int n = nums.length;
        int left = -1;
        int ans = Integer.MAX_VALUE;
        int sum = 0;

        for (int i = 0; i < n; i ++) {
            if (sum > 0) {
                left = i;
                sum = nums[i];
            } else {
                sum += nums[i];
            }
            ans = Math.min(ans, sum);
        }

        return ans;
    }
}