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;
}
}
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;
}
}
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;
}
}
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;
}
}
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;
}
}
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;
}
}