leetcode 第三天

1 多次求和构造目标数组

给你一个整数数组 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

解题思路：逆向思维+大顶堆
① 如果目标数组满足题目要求，那么从目标数组往回推一定能推导出全1数组
② [9,3,5]数组是由[1,3,5]推导出来的，其中1 = 9-8 而 8 = 17 - 9；所有先求出数组元素和sum，用大顶堆存储数组数据，sum-maxN表示除最大元素外，其他元素之和，用left表示，并且 maxN-left表示maxN所在位置上一次的值，当求出的值大于等于1时，替换原位置值，此时数组的状态切换到了上一个状态[1,3,5]，此时问题又转化为求[1,3,5]数组能否由全1数组推出，迭代直到数组是否能到全1，如果遇到某个状态中有小于1的数字出现，则表示推导不出，返回false即可

class Solution {
public:
    bool isPossible(vector<int>& target) {
    	//数组为1时特殊处理
        if(target.size()==1){
            return target[0]==1;
        }
        long long sum = 0;
        long long left = 0;
        int len = target.size();
        priority_queue<int> que;
        //求和，同时将数据放入大顶堆中
        for(int i=0;i<target.size();i++){
            que.push(target[i]);
            sum+=target[i];
        }
        //此处用来判断数组是否全为1
        if(sum==len){
        	return true;
        }
        while(!que.empty()){
            int maxN = que.top();
            que.pop();
            left = sum - maxN;
            //若left不小于maxN，则maxN-left<1，那么maxN所在位置之前的状态小于1，不符合题目要求，返回false
            if(left>=maxN){
                return false;
            }
            //如果maxN与剩余数成倍数关系，要么left=1，返回真，要么left!=1,返回假
            if(maxN%left==0){
                return left==1;
            }
            //只要maxN比left大，每次修改的位置肯定是maxN所在位置，并且每次都是减去left
            maxN = maxN%left;
            //此时sum为left与maxN之和，表示maxN确定后数组之和
            sum = maxN+left;
            //如果sum等于数组长度，提前结束判断，返回真，因为每个元素都大于等于1
            if(sum==len){
                return true;
            }
            //否则，将当前maxN再入队，数组状态变成了上一次的状态
            que.push(maxN);
        }
        return true;
    }
};

【注】 这里在编程的时候加速了确定maxN状态的过程，第一次编写时，每次只改变maxN一次，没有考虑一直修改maxN位置时的加速过程，导致程序超时

最多可以参加的会议数目

给你一个数组 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

解题思路：贪心算法
①在第i天，选择能够在第i天举行的所有会议中结束时间最早的会议
②如何判断会议是否能在第i天举行，并且会议还没有举行呢，这里选取两个二维数组分别记录会议开始时间和结束时间
start[i]表示在第i时开始的所有会议的编号集合
over[i]表示在第i-1时结束的所有会议的编号集合
这样遍历一遍原数组即可将所有会议分类好
③用set存储第i时刻满足条件的所有会议集合，并将他们按照结束时间从小到大排序，每次选取集合头部元素即可

class Solution {
public:
    int maxEvents(vector<vector<int> >& events) {
        const int N = 100005;
        vector<int> start[N],over[N];
        int maxN=1;
        set<pair<int,int> > st;
        for(int i=0;i<events.size();i++){
        	//这里利用start和over数组存储每个会议的开始结束信息
            start[events[i][0]].push_back(i);
            over[events[i][1]+1].push_back(i);
            maxN=max(maxN,events[i][1]);
        }
        int ans = 0;
        for(int i=1;i<=maxN;i++){
        	//插入满足条件的所有会议
            for(int j=0;j<start[i].size();j++){
                int index = start[i][j];
                st.insert({events[index][1],index});
            }
            //删除在i-1时间结束的所有会议
            for(int k=0;k<over[i].size();k++){
                int index = over[i][k];
                set<pair<int,int> >::iterator it = st.find({events[index][1],index});
                if(it!=st.end()){
                    st.erase(it);
                }
            }
            //如果此时集合不为空，删除结束时间最早的会议，即头部元素
            if(!st.empty()){
                st.erase(st.begin());
                ans++;
            }
        }
        return ans;
    }
};

【注】 此题考试时没有解出来，参考官方答案给出解答过程，有两个点比较巧妙，一是利用两个数组start和over将开始和结束时间分开，判断起来比较容易，二是将i时刻结束的会议放在over[i+1]里，这样避免了只能在同一个时间点开的会议，刚加入集合又被删除的情况。还有set容器是按照元素的键值升序排列，set的内部实现是利用map，set里的元素就是map里的键，值为同一个Object

最后K个数的乘积

请你实现一个「数字乘积类」ProductOfNumbers，要求支持下述两种方法：

1. add(int num)
   将数字 num 添加到当前数字列表的最后面。
2. getProduct(int k)
   返回当前数字列表中，最后 k 个数字的乘积。
   你可以假设当前列表中始终 至少 包含 k 个数字。
   题目数据保证：任何时候，任一连续数字序列的乘积都在 32-bit 整数范围内，不会溢出。

示例：
输入：
[“ProductOfNumbers”,“add”,“add”,“add”,“add”,“add”,“getProduct”,“getProduct”,“getProduct”,“add”,“getProduct”]
[[],[3],[0],[2],[5],[4],[2],[3],[4],[8],[2]]
输出：
[null,null,null,null,null,null,20,40,0,null,32]
解释：
ProductOfNumbers productOfNumbers = new ProductOfNumbers();
productOfNumbers.add(3); // [3]
productOfNumbers.add(0); // [3,0]
productOfNumbers.add(2); // [3,0,2]
productOfNumbers.add(5); // [3,0,2,5]
productOfNumbers.add(4); // [3,0,2,5,4]
productOfNumbers.getProduct(2); // 返回 20 。最后 2 个数字的乘积是 5 * 4 = 20
productOfNumbers.getProduct(3); // 返回 40 。最后 3 个数字的乘积是 2 * 5 * 4 = 40
productOfNumbers.getProduct(4); // 返回 0 。最后 4 个数字的乘积是 0 * 2 * 5 * 4 = 0
productOfNumbers.add(8); // [3,0,2,5,4,8]
productOfNumbers.getProduct(2); // 返回 32 。最后 2 个数字的乘积是 4 * 8 = 32

提示：
add 和 getProduct 两种操作加起来总共不会超过 40000 次。
0 <= num <= 100
1 <= k <= 40000

解题思路：用额外数组标记0出现的位置
①用数组counts来记录连续零的数目
②用数组data表示到当前位置所有元素的乘积
③每次getProduct时，判断counts[i]是否大于等于k，如果满足，输出data[i],否则输出0

class ProductOfNumbers {
private:
    int data[40005];
    int counts[40005];
    int size;
public:
    ProductOfNumbers() {
    	//这里初始化所有data为1，counts为0
        fill(data,data+40005,1);
        fill(counts,counts+40005,0);
        size=1;
    }
    
    void add(int num) {
        if(num!=0){
        //如果当前插入数字不为0，则data[i]=data[i-1]*num,否则data[i]=1
            data[size]=data[size-1]*num;
            counts[size]=counts[size-1]+1;
        }
        size++;
    }
    
    int getProduct(int k) {
        int pre = size-k-1;
        int end = size-1;
        //连续不为零的个数大于等于k，输出data[end]/data[pre],否则中间有0，直接输出0
        if(counts[end]>=k){
        //data[i]不会为0
            return data[size-1]/data[pre];
        }
        return 0;
    }
};

[注] 刚开始做此题时，getProduct(k)每次都计算后K个数字的，这样会出现超时情况