【贪心/DP/单调队列】【CF1029B】Creating the Contest
Description
给你一个单调不下降的长度为n的序列，请你找出一个最长的子序列，满足找出的子序列中，\(A_i<=A_{i-1}~\times~2\)，其中i为下标，A为找出的子序列。对于一个长度为\(p\)的子序列，\(i~\in~[1,p-1]\)。
Input
两行，第一行是原序列的长度\(n\)
第二行是\(n\)个数，代表原序列中的\(n\)个数。
Output
一行一个数，代表最长的长度
Sample Input
10
1 2 5 6 7 10 21 23 24 49
Sample Output
4
Hint
$ 1\leqn\leq2\cdot10^5 $
Solution
这题做法有好多好多啊……
(下面\(a_i\)代表原序列中第\(i\)个位置)
先考虑除了我以外大家都在用的做法：贪心。
贪心策略：
对于第\(i\)个位置，如果它满足\(a_i<=a_{i-1}~\times~2\)那么就把他加到当前序列的结尾中去，否则把他作为新开一个序列的首个元素继续往后扫。
证明：
证明上述策略即证明选择是连续的。
考虑选择第\(i\)个位置的元素。如果下一个元素是第\(j\)个位置的元素\(j~\neq~i+1\)，那么一定满足\(a_j<=a_{i}~\times~2\)。
那么对于\(\forall k \in (i,j)\)，因为原序列是单调不下降的，所以满足\(a_k~\leq~a_j\)且\(f_k~\geq~a_i\)。所以一定满足\(a_k<=a_{i}~\times~2\)
由于只选择\(j\)选择\(j\)和\(k\)相比，后者更优，所以选择一定是连续的。证毕。
Code:
注：代码提供感谢@Burnside julao
#include<iostream>
using namespace std;
int n;
int cnt=1;
int maxcnt=-1;
int a[200005];
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>a[i];
}
for(int i=1;i<n;i++)
{
if(2*a[i]>=a[i+1]) cnt++;
else
{
if(cnt>maxcnt) maxcnt=cnt;
cnt=1;
}
}
if(cnt>maxcnt) maxcnt=cnt;
cout<<maxcnt<<endl;
}
再说说像我这么弱的没想到贪心怎么办= =
拿到这个题的题目描述第一印象觉得这很像一个LIS(最长单调子序列)的题目。所以在考虑进行DP。
设\(f_i\)为以\(i\)位置为结尾的最长序列的长度。考虑状态转移方程为
\(f_i=max\){\(f_j\)}\(+1\)，其中\(j\)满足\(a_j~\times~2~\geq~a_i\)。
考虑转移是\(O(n)\)的，难以承受。考虑我们如果知道了最小的\(j\)在哪里，就可以用区间最大值进行转移。发现因为原序列是单调的，所以\(j\)的位置是可以二分的。二分完以后求区间[j.i-1]的最大值加一就是\(f_i\)的答案。
维护区间最大值我们这里选择建一棵十分好写的线段树就解决辣
因为二分\(j\)的复杂度是\(O(logn)\)，线段树的复杂度是\(O(logn)\)，转移是\(O(1)\)的，共有\(n\)个状态，所以时间复杂度为\(O(nlogn)\)，可以通过本题。
Code：
你看这么毒瘤的头文件就知道是我自己写的
#include<cstdio>
#define rg register
#define ci const int
#define cl const long long int
typedef long long int ll;
namespace IO {
char buf[50];
}
template<typename T>
inline void qr(T &x) {
char ch=getchar(),lst=' ';
while(ch>'9'||ch<'0') lst=ch,ch=getchar();
while(ch>='0'&&ch<='9') x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
if (lst=='-') x=-x;
}
template<typename T>
inline void write(T x,const char aft,const bool pt) {
if(x<0) {putchar('-');x=-x;}
int top=0;
do {
IO::buf[++top]=x%10+'0';
x/=10;
} while(x);
while(top) putchar(IO::buf[top--]);
if(pt) putchar(aft);
}
template <typename T>
inline T mmax(const T a,const T b) {if(a>b) return a;return b;}
template <typename T>
inline T mmin(const T a,const T b) {if(a<b) return a;return b;}
template <typename T>
inline T mabs(const T a) {if(a<0) return -a;return a;}
template <typename T>
inline void mswap(T &a,T &b) {T temp=a;a=b;b=temp;}
const int maxn = 200010;
const int maxt = 800010;
int n;
int MU[maxn];
int frog[maxt];
int ask(ci,ci,ci,ci,ci);
void change(ci,ci,ci,ci,ci);
int main() {
qr(n);
for(rg int i=1;i<=n;++i) qr(MU[i]);
for(rg int i=1;i<=n;++i) {
rg int l=0,r=i,mid=0,_ans=0;
while(l<=r) {
mid=(l+r)>>1;
if((MU[mid]<<1)>=MU[i]) _ans=mid,r=mid-1;
else l=mid+1;
}
if((_ans==0)||(_ans==i)) _ans=1;
else _ans=ask(1,n,1,_ans,i-1)+1;
change(1,n,1,i,_ans);
}
write(ask(1,n,1,1,n),'\n',true);
return 0;
}
int ask(ci l,ci r,ci p,ci aiml,ci aimr) {
if(l>r) return 0;
if(l>aimr||r<aiml) return 0;
if(l>=aiml&&r<=aimr) return frog[p];
int mid=(l+r)>>1,dp=p<<1,ddp=dp|1;
return mmax(ask(l,mid,dp,aiml,aimr),ask(mid+1,r,ddp,aiml,aimr));
}
void change(ci l,ci r,ci p,ci aim,ci v) {
if(l>r) return;
if(l>aim||r<aim) return;
if(l==r) {frog[p]=v;return;}
int mid=(l+r)>>1,dp=p<<1,ddp=dp|1;
change(l,mid,dp,aim,v);change(mid+1,r,ddp,aim,v);
frog[p]=mmax(frog[dp],frog[ddp]);
}
考虑优化
毕竟这个复杂度比贪心高了一个log，万一数据出上个1e7就凉了。考虑考虑怎么把它优化到\(O(n)\)。
发现对于每个i，它对应的最小的j的位置是单调不下降的。那么我们可以用单调队列维护[j,i]的区间最大值。这样转移达到时间复杂度被优化到了\(O(n)\)，可以面对更大的数据范围。
Code:
我懒得写了
