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,要求支持下述两种方法:
- add(int num)
将数字 num 添加到当前数字列表的最后面。 - 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个数字的,这样会出现超时情况