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~\leq~n~\leq~2~\cdot~10^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\)

由於只選擇\(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:

我懶得寫了

【貪心/DP/單調隊列】【CF1029B】Creating the Contest