0x57 倍增优化DP

真的是下定了巨大的决心来搞这一讲，果不其然耗了一晚上

开车旅行（真的是NOIP的题吗怎么这么恐怖）

首先，先用set把小A和小B从城市i出发，到达的下一个城市预处理出来。

f[i][j][k]表示走了2^i天，j城市出发，k表示谁开车，到达那个城市。

转移就是f[i][j][k]=f[i-1][f[i-1][j][k]][k] 相信很好理解

特别的i-1==0时，因为k是奇数，开车的人是变化的，所以f[i][j][k]=f[i-1][f[i-1][j][k]][k^1]

令da[i][j][k],db[i][j][k]，分别表示小A和小B这个状态下走的路程

对于询问1，枚举所有的城市作为起点，然后基于二进制划分的思想，倒着for一步步在满足走的总路程<=x0的情况下前进，这样可以计算出小A走的路程和小B走的路程。找最大比值即可。

询问二就直接询问小A走的路程和小B走的路程了。同理可求。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<set>
using namespace std;
typedef long long LL;

int h[];
struct snode
{
    int id,h;
    snode(){}
    snode(int ID,int H){id=ID;h=H;}
    friend bool operator <(snode s1,snode s2){return s1.h<s2.h;}
};
set<snode>S;
set<snode>::iterator it,lt,rt;
int g[],I;
bool cmp(int g1,int g2){return (abs(h[g1]-h[I])<abs(h[g2]-h[I]))||(abs(h[g1]-h[I])==abs(h[g2]-h[I])&&h[g1]<h[g2]);}

int Ago[],Bgo[];
int f[][][]; LL da[][][],db[][][];

LL A,B;
void solve(int now,int x0)
{
    A=B=; int k=;
    for(int i=;i>=;i--)
      if(f[i][now][k]!=&&da[i][now][k]+db[i][now][k]<=x0)
      {
            x0-=da[i][now][k]+db[i][now][k];
            A+=da[i][now][k],B+=db[i][now][k];
            if(i==)k^=;
            now=f[i][now][k];
        }
}

int main()
{
    int n;
    scanf("%d",&n);
    for(int i=;i<=n;i++)scanf("%d",&h[i]);
    memset(Ago,,sizeof(Ago));
    memset(Bgo,,sizeof(Bgo));
    for(int i=n;i>=;i--)
    {
        S.insert(snode(i,h[i]));
        it=lt=rt=S.find(snode(i,h[i]));
        int m=;
        if(lt!=S.begin())
        {
            lt--,g[++m]=(*lt).id;
            if(lt!=S.begin())lt--,g[++m]=(*lt).id;
        }
        rt++;
        if(rt!=S.end())
        {
            g[++m]=(*rt).id;
            rt++;if(rt!=S.end())g[++m]=(*rt).id;
        }
        I=i;sort(g+,g+m+,cmp);
        if(m>)Ago[i]=g[];
        if(m>)Bgo[i]=g[];
    }

    memset(f,,sizeof(f));
    for(int i=;i<=n;i++)
    {
        if(Ago[i]!=) f[][i][]=Ago[i], da[][i][]=abs(h[Ago[i]]-h[i]), db[][i][]=;
        if(Bgo[i]!=) f[][i][]=Bgo[i], da[][i][]=, db[][i][]=abs(h[Bgo[i]]-h[i]);
    }
    for(int i=;i<=;i++)
      for(int j=;j<=n;j++)
        for(int k=;k<=;k++)
            {
                int l=k;if(i==)l=k^;

                if(f[i-][j][k]>)f[i][j][k]=f[i-][f[i-][j][k]][l];
                if(f[i][j][k]>)
                {
                    da[i][j][k]=da[i-][j][k]+da[i-][f[i-][j][k]][l];
                    db[i][j][k]=db[i-][j][k]+db[i-][f[i-][j][k]][l];
                }
            }

    int x0,ans;LL ansA=,ansB=;
    scanf("%d",&x0);
    for(int i=;i<=n;i++)
    {
        solve(i,x0); if(B==)A=;
        if(A*ansB<ansA*B||(A*ansB==ansA*B&&h[i]>h[ans]))ansA=A,ansB=B,ans=i;
    }
    printf("%d\n",ans);

    int Q,x,y;
    scanf("%d",&Q);
    while(Q--)
    {
        scanf("%d%d",&x,&y);
        solve(x,y);
        printf("%lld %lld\n",A,B);
    }

    return ;
}

开车旅行

Count The Repetitions

f[j][i]表示从s1第i个字符开始，能够表示出s2 2^j最少需要多少字符。

就有f[j][i]=f[j-1][i]+f[j-1][((i+f[j-1][i])-1)%s1len+1]

最后就枚举匹配的起始点，同样在不超过s1len*n1的情况下用二进制一步步跳，记录当前起始点的最优解更新答案就好了。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long LL; 

char s1[],s2[];
LL f[][];
int main()
{
    freopen("2.in","r",stdin);
    freopen("2.out","w",stdout);
    while()
    {
        int n2,n1;
        scanf("%s",s2+);if(s2[]=='}')break;
        scanf("%d%s%d",&n2,s1+,&n1);
        int s2len=strlen(s2+),s1len=strlen(s1+);

        bool bk=false;
        for(int i=;i<=s1len;i++)
        {
            int p=i;f[][i]=;
            for(int j=;j<=s2len;j++)
            {
                int cc=;
                while(s1[p]!=s2[j])
                {
                    p=p%s1len+;
                    cc++;if(cc>=s1len){printf("0\n");bk=true;break;}
                }
                p=p%s1len+;
                f[][i]+=cc+;
                if(bk==true)break;
            }
            if(bk==true)break;
        }
        if(bk==true)continue;

        for(int j=;j<=;j++)
            for(int i=;i<=s1len;i++)
                f[j][i]=f[j-][i]+f[j-][((i+f[j-][i])-)%s1len+];

        LL m=;
        for(int i=;i<=s1len;i++)
        {
            int x=i;LL ans=;
            for(int j=;j>=;j--)
                if(x+f[j][(x-)%s1len+]-<=s1len*n1)
                    x+=f[j][(x-)%s1len+], ans+=(<<j);
            m=max(m,ans);
        }
        printf("%lld\n",m/n2);
    }
    return ;
}

Count The Repetitions

好像都是先预处理出下一步的状态，然后二进制划分啊