【贪心/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

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:

我懒得写了