452. Minimum Number of Arrows to Burst Balloons
There are some spherical balloons taped onto a flat wall that represents the XY-plane. The balloons are represented as a 2D integer array points where points[i] = [xstart, xend] denotes a balloon whose horizontal diameter stretches between xstart and xend. You do not know the exact y-coordinates of the balloons.
Arrows can be shot up directly vertically (in the positive y-direction) from different points along the x-axis. A balloon with xstart and xend is burst by an arrow shot at x if xstart <= x <= xend. There is no limit to the number of arrows that can be shot. A shot arrow keeps traveling up infinitely, bursting any balloons in its path.
Given the array points, return the minimum number of arrows that must be shot to burst all balloons.
Example 1:
Input: points = [[10,16],[2,8],[1,6],[7,12]]
Output: 2
Explanation: The balloons can be burst by 2 arrows:
- Shoot an arrow at x = 6, bursting the balloons [2,8] and [1,6].
- Shoot an arrow at x = 11, bursting the balloons [10,16] and [7,12]. Example 2:
Input: points = [[1,2],[3,4],[5,6],[7,8]]
Output: 4
Explanation: One arrow needs to be shot for each balloon for a total of 4 arrows.
Example 3:
Input: points = [[1,2],[2,3],[3,4],[4,5]]
Output: 2
Explanation: The balloons can be burst by 2 arrows:
- Shoot an arrow at x = 2, bursting the balloons [1,2] and [2,3].
- Shoot an arrow at x = 4, bursting the balloons [3,4] and [4,5].
Constraints:
1 <= points.length <= 105
points[i].length == 2
-2^31 <= xstart < xend <= 2^31 - 1
Original Page
public int findMinArrowShots(int[][] points) {
if(points.length == 0){
return 0;
}
Arrays.sort(points, (a,b) ->{
if(a[0] == b[0]){
return a[1] - b[1];
}
return a[0] - b[0];
});
int arrow = 1;
int start = points[0][0];
int end = points[0][1];
for(int i=0; i<points.length; i++){
if((points[i][0] >= start && points[i][0]<= end) ||
(end >=points[i][0] && end <= points[i][1])){
//Narrow the arrow point down
if(points[i][0] > start && points[i][0] <= end){
start = points[i][0];
}
if(points[i][1]>start && points[i][1] < end){
end = points[i][1];
}
continue;
}else{
// current arrow point is not satisfied with balloons
start = points[i][0];
end = points[i][1];
arrow ++;
}
}
return arrow;
}
435. Non-overlapping Intervals
Given an array of intervals intervals where intervals[i] = [starti, endi], return the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping.
Example 1:
Input: intervals = [[1,2],[2,3],[3,4],[1,3]]
Output: 1
Explanation: [1,3] can be removed and the rest of the intervals are non-overlapping.
Example 2:
Input: intervals = [[1,2],[1,2],[1,2]]
Output: 2
Explanation: You need to remove two [1,2] to make the rest of the intervals non-overlapping.
Example 3:
Input: intervals = [[1,2],[2,3]]
Output: 0
Explanation: You don't need to remove any of the intervals since they're already non-overlapping.
Constraints:
1 <= intervals.length <= 10^5
intervals[i].length == 2
-5 * 10^4 <= starti < endi <= 5 * 10^4
Original Page
Wrong Code
public int eraseOverlapIntervals(int[][] intervals) {
if(intervals.length == 0){
return 0;
}
Arrays.sort(intervals, (a,b) ->{
if(a[0] == b[0]){
return a[1] - b[1];
}
return a[0] - b[0];
});
Arrays.stream(intervals)
.map(Arrays::toString)
.forEach(System.out::println);
int count = 0;
// List<int[]> list = new LinkedList<>();
int start = intervals[0][0];
int end = intervals[0][1];
for(int i=1; i<intervals.length; i++){
//if the left edge is not included in the previous interval the right will definitely not be in it.
if(intervals[i][0] >=start && intervals[i][0] <end){
count++;
continue;
}
start = intervals[i][0];
end = intervals[i][1];
// list.add(intervals[i]);
}
return count;
}
Fix it
public int eraseOverlapIntervals(int[][] intervals) {
if(intervals.length == 0){
return 0;
}
Arrays.sort(intervals, (a,b) ->{
return a[0] - b[0];
});
int count = 0;
int start = intervals[0][0];
int end = intervals[0][1];
for(int i=1; i<intervals.length; i++){
if(intervals[i][0] < intervals[i-1][1]){
count++;
// here we need to find the maximum overlap, the means whether the next element overlap to above groups of overlaps
// if only find overlap from the previous interval, it may cause miss calculation over-add 1 count
intervals[i][1] = Math.min(intervals[i][1], intervals[i-1][1]);
}
}
return count;
}
763. Partition Labels
You are given a string s. We want to partition the string into as many parts as possible so that each letter appears in at most one part.
Note that the partition is done so that after concatenating all the parts in order, the resultant string should be s.
Return a list of integers representing the size of these parts.
Example 1:
Input: s = "ababcbacadefegdehijhklij"
Output: [9,7,8]
Explanation:
The partition is "ababcbaca", "defegde", "hijhklij".
This is a partition so that each letter appears in at most one part.
A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits s into less parts.
Example 2:
Input: s = "eccbbbbdec"
Output: [10]
Constraints:
1 <= s.length <= 500
s consists of lowercase English letters.
Original Page
public List<Integer> partitionLabels(String s) {
List<Integer> list = new ArrayList<>();
Set<Character> set = new HashSet<>();
if(s.length() == 0){
return list;
}
int start = 0;
int end = 0;
for(int i=0; i<s.length(); i++){
Character target = s.charAt(i);
if(!set.contains(target)){
set.add(target);
int j = s.length()-1;
for(;j>i;j--){
if(s.charAt(j) == target){
break;
}
}
end = Math.max(end, j);
}
if(i == end){
list.add(end-start+1);
start = i+1;
set.clear();
}
}
return list;
}
public List<Integer> partitionLabels(String s) {
List<Integer> list = new ArrayList<>();
Set<Character> set = new HashSet<>();
int[] pos = new int[27];
for(int i=s.length()-1; i>0;i--){
if(pos[s.charAt(i)-'a'] == 0){
pos[s.charAt(i)-'a'] = i;
}
}
if(s.length() == 0){
return list;
}
int start = 0;
int end = 0;
for(int i=0; i<s.length(); i++){
Character target = s.charAt(i);
if(!set.contains(target)){
set.add(target);
end = Math.max(end, pos[target-'a']);
}
if(i == end){
list.add(end-start+1);
start = i+1;
set.clear();
}
}
return list;
}
public List<Integer> partitionLabels(String s) {
List<Integer> list = new ArrayList<>();
int[] pos = new int[27];
for(int i=s.length()-1; i>0;i--){
if(pos[s.charAt(i)-'a'] == 0){
pos[s.charAt(i)-'a'] = i;
}
}
if(s.length() == 0){
return list;
}
int start = 0;
int end = 0;
for(int i=0; i<s.length(); i++){
Character target = s.charAt(i);
end = Math.max(end, pos[target-'a']);
if(i == end){
list.add(end-start+1);
start = i+1;
}
}
return list;
}
Because it is not important for evaluating whether the element has been in the set, we only focus on whether the end is reached or not, and if the same elements happen, the end will not change and if the different elements merge, it seems like end may change but all of them will not impact the if evaluation so we can remove them.
Top comments (0)