176 竞赛

最多可以参加的会议数目

给你一个数组 events，其中 events[i] = [startDayi, endDayi] ，表示会议 i 开始于 startDayi ，结束于 endDayi 。

你可以在满足 startDayi <= d <= endDayi 中的任意一天 d 参加会议 i 。注意，一天只能参加一个会议。

请你返回你可以参加的最大会议数目。

示例 1：

输入：events = [[1,2],[2,3],[3,4]]
输出：3
解释：你可以参加所有的三个会议。
安排会议的一种方案如上图。
第 1 天参加第一个会议。
第 2 天参加第二个会议。
第 3 天参加第三个会议。

示例 2：

输入：events= [[1,2],[2,3],[3,4],[1,2]]
输出：4

示例 3：

输入：events = [[1,4],[4,4],[2,2],[3,4],[1,1]]
输出：4

示例 4：

输入：events = [[1,100000]]
输出：1

示例 5：

输入：events = [[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7]]
输出：7

提示：

1 <= events.length <= 10^5
events[i].length == 2
1 <= events[i][0] <= events[i][1] <= 10^5

// 超出时间限制

/**
 * @param {number[][]} events
 * @return {number}
 */
var maxEvents = function(events) {
    let len = 0;
    events.forEach(e=>{
        if(e[1]>len){
            len = e[1]
        }
    })
   
    let res= 0;
//     let arr = [];
//     for(let i=1; i<=len; i++){
//         let sub = [];
//         events.forEach(e=>{
//             if(e[0]===i){
//               sub.push(e)  
//             }
//         })
//          sub.sort((a, b)=> a[1]-b[1]);
//         arr.push(...sub)
     
//     }
   events.sort((a, b)=>a[1]-b[1]);
    let set = new Set();
    // len 最多参加的会议
    for(let i=1; i<=len; i++){
        for(let j=0; j<events.length; j++){
            let [s, e] = events[j];
            if(!set.has([j, s, e].join(''))&& i>=s && i<=e){
               res++;
                // events.splice(j, 1);
                set.add([j, s, e].join(''))
                break;
             }
        }
    }
    return res;
};

/**
 * @param {number[][]} events
 * @return {number}
 */
var maxEvents = function(events) {
    const se = events.sort((a,b) => a[0] !== b[0] ? a[0] - b[0] : a[1] - b[1]);
    let r = 0;
    let c = se[0][0];
    let w = [];
    let sum = 0;
    while (r < se.length || w.length > 0) {
        while (w.length > 0 && w[0] < c) {
            w.splice(0, 1);
        }
        while (r < se.length && se[r][0] <= c) {
            let ll = 0;
            let rr = w.length - 1;
            while (ll <= rr) {
                let m = Math.round((ll+rr) / 2);
                if (w[m] < se[r][1]) {
                    ll = m + 1;
                } else {
                    rr = m - 1;
                }
            }
            w.splice(rr + 1, 0, se[r][1]);
            r++;
        }
        if (w.length > 0) {
            w.splice(0, 1);
            sum++;
        }
        c++;
    }
    return sum;
};

var maxEvents = function(events) {
    let states = new Array(100001);
    events.sort((a, b)=>a[1]-b[1])
    for(let i=0;i<events.length;i++){
            for(let j=events[i][0];j<=events[i][1];j++){
                if(!states[j]){
                    states[j] = true;
                    break;
                }
            }
        }
    let ans = 0;
     for(let i=1;i<100001;i++){
            if(states[i]) ans++;
        }
    return ans
}

var maxEvents = function(events) {
    events.sort((a,b) => {
        if(a[1] - b[1] == 0) return a[0] - b[0]
        return a[1] - b[1]
    })
    let hashset = new Set()
    events.forEach(ele => {
        for (let i = ele[0]; i <= ele[1]; i++) {
           if(!hashset.has(i)){ 
               hashset.add(i)
               break
            }
        }
    })
    return hashset.size
};

多次求和构造目标数组

给你一个整数数组 target 。一开始，你有一个数组 A ，它的所有元素均为 1 ，你可以执行以下操作：

令 x 为你数组里所有元素的和
选择满足 0 <= i < target.size 的任意下标 i ，并让 A 数组里下标为 i 处的值为 x 。
你可以重复该过程任意次

如果能从 A 开始构造出目标数组 target ，请你返回 True ，否则返回 False 。

示例 1：

输入：target = [9,3,5]
输出：true
解释：从 [1, 1, 1] 开始
[1, 1, 1], 和为 3 ，选择下标 1
[1, 3, 1], 和为 5， 选择下标 2
[1, 3, 5], 和为 9， 选择下标 0
[9, 3, 5] 完成

示例 2：

输入：target = [1,1,1,2]
输出：false
解释：不可能从 [1,1,1,1] 出发构造目标数组。

示例 3：

输入：target = [8,5]
输出：true

提示：

N == target.length
1 <= target.length <= 5 * 10^4
1 <= target[i] <= 10^9

// 本质还是逆向思维，只不过操作的是一个提前排好序的数组
/**
 * @param {number[]} target
 * @return {boolean}
 */
var isPossible = function(target) {
     let sum = 0;
    for (let i = 0; i < target.length; i++) {
        sum += target[i];
    }
    const st = target.sort((a, b) => b - a);
    while (sum > target.length) {
        if (st[0] * 2  - sum < 1) return false;
        sum -= st[0];
        let t = st[0] - sum;
        sum += t;
        st.splice(0, 1);
        let l = 0;
        let r = st.length - 1;
        while (l <= r) {
            let m = Math.round((l+r) / 2);
            if (st[m] > t) {
                l = m + 1;
            } else {
                r = m - 1;
            }
        }
        st.splice(r + 1, 0, t);
    }
    return true;
    /*
只是觉得可能性太多，求出来的和，是和任意的某个元素再求和，因为任意所以可能性多
    let max = target.reduce((a, b)=>a+b)
    let len = target.length;
    let init = new Array(len).fill(1);
    let arr = [];
    let sum = 0;
    while(sum>max){
       sum = init.reduce((a, b)=>a+b)
        
   }
   */
};

// 逆向思维
var isPossible = function(target) {
    while(true){
        let sum = target.reduce((a, b)=>a+b);
        let max = 0;
        let index = 0;
        for(let i=0, len = target.length; i<len; i++){
            let item = target[i];
            if(item > max){
                max = item;
                index = i;
            }
        }
        if(max === 1){
            if(target.length === sum) {
                 return true;
            } else {
                return false;
            }
        } 

        let n = max- (sum-max);
        // 初始1 加上来的，不可能是负数; 测试用例 [9,9,9]
        if(n<0){
            return false
        }
        target[index] = n;
    }
};