2022-05-17

1. 给你区间的 空 集，请你设计并实现满足要求的数据结构
   新增：添加一个区间到这个区间集合中。
   统计：计算出现在 至少一个 区间中的整数个数。
   实现 CountIntervals 类：
   CountIntervals() 使用区间的空集初始化对象
   void add(int left, int right) 添加区间 [left, right] 到区间集合之中。
   int count() 返回出现在 至少一个 区间中的整数个数。
   注意：区间 [left, right] 表示满足 left <= x <= right 的所有整数 x 。
   来源：力扣（LeetCode）
   链接：https://leetcode.cn/problems/count-integers-in-intervals
   著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class CountIntervals{
        //预测 会有个列表   有个map
        //预测 主要内容是在add方法内
        //预测 会有个计数器
        //预测

        //保存区间左右端点
        TreeMap<Integer, Integer> map = new TreeMap<>();
        int ans =0;
        public CountIntervals(){

        }
        public void add(int left,int right){
            //返回小于等于给点区间right的最接近的左区间端点
            Integer L = map.floorKey(right);
            //记录左右俩个参数
            int l = left,r = right;
            //循环右区间端点 并预测这个左端点对应的右区间端点是否大于给左区间端点
            //判断俩个区间是否重叠
            while (L != null && map.get(L) >= l){
                //比较左区间端点俩个哪个更小
                l = Math.min(l,L);
                //比较右区间端点哪个更大
                r = Math.max(r,map.get(L));
                //map去掉这个L的值
                map.remove(L);
                //预测是否还有重叠的区间
                L = map.floorKey(right);
            }
            //没有重叠的 下标相减+1
            ans+=(r-l+1);
            //放入新设置的左右区间端点
            map.put(l,r);
        }
        public int count(){
           return ans;
        }

    }

2. 给你一个二维整数数组 tiles ，其中 tiles[i] = [li, ri] ，表示所有在 li <= j <= ri 之间的每个瓷砖位置 j 都被涂成了白色。
   同时给你一个整数 carpetLen ，表示可以放在 任何位置 的一块毯子。
   请你返回使用这块毯子，最多 可以盖住多少块瓷砖。
   来源：力扣（LeetCode）
   链接：https://leetcode.cn/problems/maximum-white-tiles-covered-by-a-carpet
   著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

public int maximumWhiteTiles(int[][] tiles,int carpetLen){
        //预测 有个map（记录各个的开始和结束）
        //预测 循环比较多个map里面的区间大小值                                  √
        //预测 会有最大值和最小值
        //预测 会判断是否相邻
        //预测 会有空白区间的记录
        //预测 地毯的长度可能会大于瓷砖的最大值-最小值
        //预测

        //将数组进行排序
        Arrays.sort(tiles);
        //新建一个数组
        int[] preSum = new int[tiles.length+1];
        //循环记录各个起点到终点的和+前面的和
        for (int i=1;i<=tiles.length;i++){preSum[i] = preSum[i-1]+tiles[i-1][1] - tiles[i-1][0]+1;}
        //定义中间量
        int ans =0;
        //循环遍历各个瓷砖
        for (int i=0;i<tiles.length;i++){
            //预测 瓷砖的左端点是否大于右边的最大值
            //瓷砖数量不够
            if (tiles[i][0]+carpetLen>tiles[tiles.length-1][1]){
                //计算当前所能占用的最多瓷砖
                ans = Math.max(ans,preSum[tiles.length]- preSum[i]);
                //停止循环
                break;
            }
            else {
                //找出地毯的右端点
                //记录当前右端点，左端点
                int l =i,r = tiles.length-1;
                //循环比较左右端点
                while (l<r){
                    //找出中间点
                    int mid = (l+r)>>1;
                    //预测 当前点的左端点是否小于中间的的右端点
                    //找出最近不超过的瓷砖的右端点
                    if (tiles[i][0]+carpetLen-1<=tiles[mid][1]){r = mid;}
                    else {l = mid+1;}
                    //预测俩个端点重合
                    if (l == r-1){
                        //预测左端点+地毯小于右端点
                        if (tiles[i][0]+carpetLen-1<=tiles[l][1]){l=r;}
                        //找到最近的点
                        break;
                    }
                }
                //预测地毯是否包含了右区间的瓷砖
                if (tiles[i][0]+carpetLen-1<tiles[l][1]){ans = Math.max(ans,preSum[r] - preSum[i]);}
                else {ans = Math.max(ans,preSum[r] - preSum[i]+tiles[i][0]+carpetLen - tiles[r][0]);}
            }
        }
        return ans;
    }

标签：map,tiles,right,2022,17,05,int,端点,区间
来源： https://www.cnblogs.com/xyf-study/p/16282901.html