【链接】链接
【题意】
n个人从左到右站在一条直线上。每个人都有一个能力值g[i],然后每个人可以将相邻的一个人打败。
然后它的能力值能够增加相应的能力值(就是打败了的那个人的能力值).
A能够打败B的条件是g[A]+D>=g[B].
n-1次后,只会剩下一个人了。
问你最后的那一个人可能是谁。
输出所有可能的人的编号。
【题解】
设dfs(i),表示要找第i个人能不能成为最后的winner.
暴力做的话,肯定会超时的。
->O(N^2)的算法了。
于是我们寻求更快的方法。
我们维护以下两个东西,
l[i]和r[i].
l[i]表示的是最大的j且j<i,且g[j]>g[i]的下标j.(如果没有就为0)
r[i]表示的是最小的j且j>i,且g[j]>g[i]的下标j.(如果没有就为N)
这两个东西,能用一个单调递减的单调队列弄出来。
O(N)就能得到。
然后考虑某一个位置i;
我们想要获取第i个位置是不是可以成为最后的Winner.
设这个问题为dfs(i);
显然l[i]+1..r[i]-1这一段都是g[i]能够不用增加D就吃到的。
那么。我们把i这个人的能力值tot加上sum[l[i]+1..r[i]-1] (前缀和就能搞出来);
接下来,看看,这个tot+D能不能大于等于g[ l[i] ];
如果可以的话,则这个问题就能转化为,求dfs(l[i])了.
也即,转化为l[i]能不能成为winner了。
因为对于l[i]而言,l[i]+1..r[i]-1这一段,它是肯定能够吃掉的。
(因为g[ l[i]+1..r[i]-1 ]是比g[i]小的,而g[ l[i] ] > g[i])
那么也就说,从i点吃到r[i]-1点,再一直吃到l[i]点..
再想一下,如果我们在做dfs(l[i]),则肯定也会把g[ l[i]+1..r[i]-1 ]全都吃掉.
那不就是等价的了吗?
也就是说,现在问题已经完全转化为l[i]这个点能不能成为最后的winner了。
对于dfs(l[i]),还是一样的,在l[ l[i] ]+1..r[ l[i] ] -1之间的人,都会被吃掉。然后又+D看看能不能再往外扩展。
可以的话,就又能转化为dfs( l[ l[i] ] -1)或dfs(r[ l[i] ] + 1)这两个问题了
直到l[i]==0且r[i]==N,则可以直接返回true.因为这是个最大的数了,肯定能吃掉所有的.
(且可以肯定,dfs(x)中的x是一直在增大的)
当然还可以试一下r[i].(如果tot+D>=g[ r[i] ]就可以再试一下r[i]);
因为同理也能从l[i]+1吃到r[i],然后转化为dfs(r[i])这个问题。
只要l[i]和r[i]中的任意一个可以成为winner.
那么i就能成为winner.
且,因为l[i]的区间l[ l[i] ]..r[ l[i] ]区间肯定覆盖了l[i]..r[i]区间。所以不会出现环。
再考虑到上面的过程是一个递归的过程。
且找过一次答案之后,答案就是确定的了。
有大量重复的子问题。
写一个记忆化搜索就可以了。
这是一个类似DAG的问题。
UPD
l[i]和r[i]是i这个人必须要吃掉的人(因为都比它大),则我们必须要吃掉其中一个人才能继续吃。
(这是必须要做的事情,必须这么贪心,算法的正确性没有问题);
而一旦能够吃l[i]或r[i],会发现,问题能转化成求另外一个位置的问题,(只有那个位置可以,i的位置才可以,否则不行!)
那个问题,还是用相同的方法去做,即新的i,然后又去打败li或ri(必须打败),然后打败之后,有能转化为另外一个位置的问题,且会发现,递归的过程不会出现环,即dfs(x)->dfs(y),然后dfs(y)里面又要调用dfs(x)这样的情况,不会出现。因为
g[y]>g[x]总是成立的,所以我们调用的dfs(x)的g[x]是单调递增的,总会有出口的(l[i]..r[i]这个区间会越来越大,直到变成
[0..N]这个区间,也即x变成了最大的数字)
【错的次数】
0
【反思】
出现了重复的问题->考虑记忆化搜索
考虑动规。
重复的子问题。
【代码】
/*
*/
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
#include <map>
#include <queue>
#include <iomanip>
#include <set>
#include <cstdlib>
#include <cmath>
#include <bitset>
using namespace std;
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define LL long long
#define rep1(i,a,b) for (int i = a;i <= b;i++)
#define rep2(i,a,b) for (int i = a;i >= b;i--)
#define mp make_pair
#define pb emplace_back
#define fi first
#define se second
#define ld long double
#define ms(x,y) memset(x,y,sizeof x)
#define ri(x) scanf("%d",&x)
#define rl(x) scanf("%lld",&x)
#define rs(x) scanf("%s",x)
#define rf(x) scnaf("%lf",&x)
#define oi(x) printf("%d",x)
#define ol(x) printf("%lld",x)
#define oc putchar(' ')
#define os(x) printf(x)
#define all(x) x.begin(),x.end()
#define Open() freopen("F:\rush.txt","r",stdin)
#define Close() ios::sync_with_stdio(0)
#define sz(x) ((int) x.size())
#define ld long double
typedef pair<int,int> pii;
typedef pair<LL,LL> pll;
//mt19937 myrand(time(0));
//int get_rand(int n){return myrand()%n + 1;}
const int dx[9] = {0,1,-1,0,0,-1,-1,1,1};
const int dy[9] = {0,0,0,-1,1,-1,1,-1,1};
const double pi = acos(-1.0);
const int N = 1e6;
int n,d,l[N+10],r[N+10],dp[N+10];
LL sum[N+10];
pll a[N+10];
vector <pll> v;
vector <int> ans;
int dfs(int x){
if (dp[x]!=-1) return dp[x];
if (l[x]==-1 && r[x]==-1){
return dp[x] = true;
}
LL temp = a[x].fi;
if (l[x]==-1)
temp += sum[x-1];
else
temp += sum[x-1] - sum[l[x]];
if (r[x]==-1)
temp += sum[n] - sum[x];
else
temp += sum[r[x]-1] - sum[x];
if (l[x]!=-1 && temp + d >= a[l[x]].fi && dfs(l[x]))
return dp[x] = true;
if (r[x]!=-1 && temp + d >= a[r[x]].fi && dfs(r[x]))
return dp[x] = true;
return dp[x] = false;
}
int main(){
ms(dp,255);
//Open();
//Close();
ri(n),ri(d);
rep1(i,1,n){
LL x;
rl(x);
a[i].fi = x,a[i].se = i;
sum[i] = sum[i-1] + x;
}
rep1(i,1,n){
while (!v.empty() && v.back().fi<=a[i].fi){
v.pop_back();
}
//v.back() > a[i].fi
if (v.empty()){
l[i] = -1;
}else{
l[i] = v.back().se;
}
v.pb(a[i]);
}
v.clear();
rep2(i,n,1){
while (!v.empty() && v.back().fi<=a[i].fi){
v.pop_back();
}
//v.back() > a[i].fi
if (v.empty()){
r[i] = -1;
}else{
r[i] = v.back().se;
}
v.pb(a[i]);
}
rep1(i,1,n)
if (dfs(i)){
ans.pb(i);
}
rep1(i,0,sz(ans)-1){
oi(ans[i]);
if (i==sz(ans)-1)
puts("");
else
oc;
}
return 0;
}