Day33算法记录|贪心算法05

Leecode题目

435. 无重叠区间

题目描述：
这道题和452.打气球很像，气球是找出没有重叠的区域，有几个没有重叠的区域就增加几只箭。这道题是，需要去除的 = 总的个数-完全没有重叠的区域。（因为两道题有一点点差异，所以在判断的时候一个是<，另一个是<=。

讲解清晰：

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
    Arrays.sort(intervals,(a,b)->Integer.compare(a[1],b[1]));

    int count =1;
    int len = intervals.length;
    int right = intervals[0][1];
    for(int i=0;i<len;i++){
        if(right<=intervals[i][0]){
            count++;
            right = intervals[i][1];
        }
    }
    return len-count;
    }
}

763.划分字母区间

方法一：
1.利用map记录每个字母最后出现的位置
2. 当索引值和当前最大的end相等的时候就可以截断为一个区间

class Solution {
    public List<Integer> partitionLabels(String s) {
     //1.先记录每个字母最后出现的位置
     Map<Character,Integer> map = new HashMap<>();
     for(int i=0;i<s.length();i++){
         map.put(s.charAt(i),i);
     }

     //2.开始找区间
      List<Integer> res = new ArrayList<>();
     int start =0;
     int end =0;

     for(int i=0;i<s.length();i++){
      end = Math.max(end,map.get(s.charAt(i)));
      if(end == i){
          res.add(end-start+1);
          start =end+1;
      }
     }
     return res;
    }
}

将map用数组代替

class Solution {
    public List<Integer> partitionLabels(String s) {
    List<Integer> res = new ArrayList<>();
    //26个英文字母，比如edge[0]表示字母a最后出现的位置
    int [] edge = new int[26];
    char[] chars = s.toCharArray();
     //1.先记录每个字母最后出现的位置
    for(int i=0;i<chars.length;i++){
        edge[chars[i]-'a'] =i;  
    }

     //2.开始找区间
     
     int start =0;
     int end =0;

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

56. 合并区间

判断重叠区间问题：
方法一：对左右两个边界分别排序
对每个区间的起点和终点分别排序。

不重叠了，放入结果集:

1. 下一个起点大于上一个终点
2. 当前到了最后一个终点了，直接放入

class Solution {
    public int[][] merge(int[][] intervals) {
 
 int len = intervals.length;
 int[] startArr = new int[len];
 int[] endArr = new int[len];

for(int i=0;i<len;i++){
    startArr[i] = intervals[i][0];
    endArr[i] = intervals[i][1];
}

Arrays.sort(startArr);
Arrays.sort(endArr);

List<int[]> list = new ArrayList<>();
int start =0;
for(int i=0;i<len;i++){
    if(i==len-1||startArr[i+1]>endArr[i]){
        list.add(new int[]{startArr[start],endArr[i]});
        start =i+1;
    }
}
return list.toArray(new int[list.size()][2]);
    }
}

方法二：只对左边界排序
对左边界排序
遍历每一个区间，

class Solution {
    public int[][] merge(int[][] intervals) {
    if(intervals == null||intervals.length==0){
        return new int[][]{};
    }

    //1.对左边界排序
    Arrays.sort(intervals,(o1,o2)->o1[0]-o2[0]);
    List<int[]> list = new ArrayList<>();

    int start = intervals[0][0];;
    int end = intervals[0][1];
    for(int[] interval:intervals){
      if(interval[0]<=end){
          end = Math.max(interval[1],end);
      }else{
         list.add(new int[]{start,end});
          start = interval[0];
          end = interval[1];
      }
    }
   list.add(new int[]{start,end});
    return list.toArray(new int[list.size()][2]);
    }
}