SDOI2016 R1做题笔记

SDOI2016 R1做题笔记

　　经过很久很久的时间，shzr终于做完了SDOI2016一轮的题目。

　　其实没想到竟然是2016年的题目先做完，因为14年的六个题很早就做了四个了，但是后两个有点开不动...

　　那么就顺着开始说：

　　储能表：https://lydsy.com/JudgeOnline/problem.php?id=4513

　　题意概述：给定一张大表格，i行j列的数是 $i$ $xor$ $j$,多组询问，求

　　$\sum_{i=0}^{n-1}\sum_{j=0}^{m-1}max((i \bigoplus j)-k,0)$

　　$T=5000，n≤10^{18}，m≤10^{18}，k≤10^{18}，p≤10^9$

　　几个月前第一次看这道题的反应:这能做？弃了弃了。今天早上再看时发现也没那么难。

　　如果想着正面去处理异或值减k这种操作，会非常棘手，因为异或的一个很好的性质就是各位独立，而减法破坏了这样的性质。发现如果异或值小于 $k$ 对答案就没有贡献，所以可以只考虑异或值大于 $k$ 的部分，这样就消除了max操作的影响。把减法拆开，先算前半部分的和，再计算一下需要减掉几个k即可。因为异或的每一位是独立的，可以想到二进制数位dp，状态还是很好设计的：$dp[i][j][k][z]$表示填到第 $i$ 位，是否卡 $n$ 的上界，是否卡 $m$ 的上界，是否卡 $k$ 的下界的方案数，再列一个类似的式子表示和，转移显然。

　　实际写程序的时候要注意：方案数为0（可能是恰好为模数的倍数），方案值的和不一定为0，这时不要直接跳出循环。第一次交的时候没有注意到这一点，只有10分，要是省选遇上这种事可就...

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# define R register int
# define ll long long
 
using namespace std;
 
int T,n[65],m[65],k[65];
ll a,b,d,s[65][2][2][2],c[65][2][2][2],t,su,nj,nl,nz,p;
 
void div (ll x,int *a)
{
    for (R i=0;i<=60;++i)
        a[60-i+1]=(x&(1LL<<i))?1:0;
}
 
ll ad (ll a,ll b,ll p) { a+=b; if(a>=p) a-=p; return a; }
 
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%lld%lld%lld%lld",&a,&b,&d,&p);
        a--,b--;
        div(a,n); div(b,m); div(d,k);
        memset(s,0,sizeof(s)); memset(c,0,sizeof(c));
        c[0][1][1][1]=1;
        for (R i=0;i<=60;++i)
            for (R j=0;j<=1;++j)
                for (R l=0;l<=1;++l)
                    for (R z=0;z<=1;++z)
                    {
                        if(s[i][j][l][z]==0&&c[i][j][l][z]==0) continue;
                        t=c[i][j][l][z]%p; su=s[i][j][l][z]%p;
                        for (R v=0;v<=1;++v)
                            for (R w=0;w<=1;++w)
                            {
                                if(j==1&&v>n[i+1]) continue;
                                if(l==1&&w>m[i+1]) continue;
                                if(z==1&&(v^w)<k[i+1]) continue;
                                if(j==1&&v==n[i+1]) nj=1; else nj=0;
                                if(l==1&&w==m[i+1]) nl=1; else nl=0;
                                if(z==1&&(v^w)==k[i+1]) nz=1; else nz=0;
                                c[i+1][nj][nl][nz]=ad(c[i+1][nj][nl][nz],t,p);
                                s[i+1][nj][nl][nz]=(s[i+1][nj][nl][nz]%p+su*2LL+t*(v^w))%p;
                            }
                    }
        ll ans=0;
        d%=p;
        for (R i=0;i<=1;++i)
            for (R j=0;j<=1;++j)
                for (R l=0;l<=1;++l)
                    ans=(ans+s[61][i][j][l]-d*c[61][i][j][l]%p+p)%p;
        printf("%lld\n",(ans+p)%p);
    }
    return 0;
}

 

　　数字配对：https://lydsy.com/JudgeOnline/problem.php?id=4514

　　直接粘题面.jpg

　　“有 $n$ 种数字，第 $i$ 种数字是 $a_i$、有 $b_i$ 个，权值是 $c_i$。

　　若两个数字 $(a_i,a_j)$ 满足，$a_i$ 是 $a_j$ 的倍数，且 $a_i/a_j$ 是一个质数，

　　那么这两个数字可以配对，并获得 $c_i×c_j$ 的价值。

　　一个数字只能参与一次配对，可以不参与配对。

　　在获得的价值总和不小于 $0$ 的前提下，求最多进行多少次配对。”

　　...第一次看到以为是一般图的最大权匹配，这能做？后来又复习网络流的时候才发现并不是一般图。

　　发现两个数如果满足可以匹配的标准，那么它们分解质因数后的指数和必然一奇一偶，所以是二分图，二分图最大匹配就很好做啦。等等，它要求的并不是最大匹配，而是最多能匹配几个。考虑网络流的贪心过程，每次走的增广路都是边权最大的，所以如果某一次发现增广完以后价值和小于0了，那么以后更不可能加回来，这时退出即可。

　　这题第一次交30...因为我自己yy了一个错误的二分图染色算法...

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <queue>
# define inf 1000000009
# define R register int
# define ll long long
 
using namespace std;
 
const int maxn=205;
int n,a[maxn],b[maxn],c[maxn],vis[maxn],h=1,firs[maxn],s,t,Fl[maxn],pre[maxn],col[maxn],f[maxn],tot;
ll max_cos,max_flow,d[maxn];
struct edge { int too,nex,cap; ll co; }g[(maxn+maxn*maxn)<<1],ed[maxn*maxn*2];
queue <int> q;
 
inline int read()
{
    R x=0,f=1;
    char c=getchar();
    while (!isdigit(c)) { if(c=='-') f=-f; c=getchar(); }
    while (isdigit(c)) x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x*f;
}
 
inline void add (int x,int y,int cap,ll co)
{
    g[++h].nex=firs[x];
    g[h].too=y;
    g[h].cap=cap;
    g[h].co=co;
    firs[x]=h;
    g[++h].nex=firs[y];
    g[h].too=x;
    g[h].cap=0;
    g[h].co=-co;
    firs[y]=h;
}
 
inline bool check (int x)
{
    if(x==1) return false;
    for (R i=2;i*i<=x;++i) if(x%i==0) return false;
    return true;
}
 
bool bfs ()
{
    memset(d,128,sizeof(d));
    int minn=d[0];
    d[s]=0,Fl[s]=inf,pre[s]=0;
    q.push(s);
    int j,beg;
    while(q.size())
    {
        beg=q.front();
        q.pop();
        vis[beg]=false;
        for (R i=firs[beg];i;i=g[i].nex)
        {
            if(g[i].cap<=0) continue;
            j=g[i].too;
            if(d[beg]+g[i].co<=d[j]) continue;
            d[j]=d[beg]+g[i].co;
            Fl[j]=min(Fl[beg],g[i].cap);
            pre[j]=i;
            if(!vis[j]) vis[j]=true,q.push(j);
        }
    }
    if(d[t]==minn) return false;
    if(d[t]*Fl[t]+max_cos<0)
    {
        max_flow+=max_cos/(-d[t]);
        return false;
    }
    return true;
}
 
inline void dfs ()
{
    int i=0,x=t;
    while(x!=s)
    {
        i=pre[x];
        g[i].cap-=Fl[t];
        g[i^1].cap+=Fl[t];
        x=g[i^1].too;
    }
    max_flow+=Fl[t];
    max_cos+=Fl[t]*d[t];
}
 
inline void ad (int x,int y)
{
    ed[++tot].nex=f[x];
    ed[tot].too=y;
    f[x]=tot;
}
 
void pt (int x)
{
    int j;
    for (R i=f[x];i;i=ed[i].nex)
    {
        j=ed[i].too;
        if(col[j]!=0) continue;
        col[j]=-col[x];
        pt(j);
    }
}
 
int main()
{
    n=read();
    t=n+1;
    for (R i=1;i<=n;++i) a[i]=read();
    for (R i=1;i<=n;++i) b[i]=read();
    for (R i=1;i<=n;++i) c[i]=read();
    for (R i=1;i<=n;++i)
        for (R j=1;j<=n;++j)
            if(a[i]%a[j]==0&&check(a[i]/a[j])) ad(i,j),ad(j,i);
    for (R i=1;i<=n;++i) if(col[i]==0) col[i]=1,pt(i);
    for (R i=1;i<=n;++i)
        if(col[i]==1) add(s,i,b[i],0);
        else add(i,t,b[i],0);
    for (R i=1;i<=n;++i)
        for (R j=1;j<=n;++j)
        if(a[i]%a[j]==0&&check(a[i]/a[j]))
        {
            if(col[i]==1) add(i,j,inf,1LL*c[i]*c[j]);
            else add(j,i,inf,1LL*c[i]*c[j]);
        }
    while(bfs())
        dfs();
    printf("%lld",max_flow);
    return 0;
}

　　

　　游戏：https://lydsy.com/JudgeOnline/problem.php?id=4515

　　题意概述：给定一棵树，支持在一条路径上添加一次函数，以及询问一条路径上的最大值。$n,m<=10^5$

　　关于这道题还有一点故事：我刚看到这道题的时候，就跟asuldb说“SDOI2016好像不难，怎么还出个李超树板子啊”，这句话说出去之后如果再做不出来就不大好了。于是写了几乎整整一下午才做出来，“思考5分钟，写题5小时”。

　　看到这种数据结构题肯定要先写个对拍，然而这道题的暴力挺难写的（当然还是比正解简单得多），写了100多行。

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# define R register int
# define ll long long

using namespace std;

const int maxn=100005;
const ll inf=123456789123456789LL;
int n,m,h,firs[maxn],x,y,w,dep[maxn],f[maxn][20],s,t;
ll l[maxn],v[maxn],a,b,ans;
struct edge { int too,nex,w; }g[maxn<<1];

void add_ed (int x,int y,int w)
{
    g[++h].nex=firs[x];
    firs[x]=h;
    g[h].too=y;
    g[h].w=w;
}

int lca (int x,int y)
{
    if(dep[x]>dep[y]) swap(x,y);
    for (R i=18;i>=0;--i) if(dep[y]-(1<<i)>=dep[x]) y=f[y][i];
    if(x==y) return x;
    for (R i=18;i>=0;--i) if(f[x][i]!=f[y][i]) x=f[x][i],y=f[y][i];
    return f[x][0];
}

void dfs (int x)
{
    int j;
    for (R i=firs[x];i;i=g[i].nex)
    {
        j=g[i].too;
        if(dep[j]) continue;
        l[j]=l[x]+g[i].w; dep[j]=dep[x]+1;
        f[j][0]=x;
        for (R k=1;k<=18;++k) f[j][k]=f[ f[j][k-1] ][k-1];
        dfs(j);
    }
}

ll dis (int x,int y)
{
    int a=lca(x,y);
    return l[x]+l[y]-2*l[a];
}

void ask (int s,int t)
{
    ans=min(ans,v[s]);
    ans=min(ans,v[t]);
    while(s!=t)
    {
        if(dep[s]<dep[t]) t=f[t][0];
        else s=f[s][0];
        ans=min(ans,v[s]);
        ans=min(ans,v[t]);
    }
}

void add (int s,int t,ll a,ll b)
{
    int x=s,y=t;
    v[x]=min(v[x],a*dis(s,x)+b);
    v[y]=min(v[y],a*dis(s,y)+b);
    while(x!=y)
    {
        if(dep[x]<dep[y]) y=f[y][0];
        else x=f[x][0];
        v[x]=min(v[x],a*dis(s,x)+b);
        v[y]=min(v[y],a*dis(s,y)+b);
    }
}

int main()
{
    freopen("data.in","r",stdin);
    freopen("std.out","w",stdout);

    scanf("%d%d",&n,&m);
    for (R i=1;i<n;++i)
    {
        scanf("%d%d%d",&x,&y,&w);
        add_ed(x,y,w); add_ed(y,x,w);
    }
    for (R i=1;i<=n;++i) v[i]=inf;
    memset(l,-1,sizeof(l));
    l[1]=0; dep[1]=1;
    dfs(1);
    int opt=0;
    for (R i=1;i<=m;++i)
    {
        scanf("%d",&opt);
        if(opt==1)
        {
            scanf("%d%d%lld%lld",&s,&t,&a,&b);
            add(s,t,a,b);
        }
        else
        {
            scanf("%d%d",&s,&t);
            ans=inf;
            ask(s,t);
            printf("%lld\n",ans);
        }    
    }
    return 0;
}

　　（恭喜这个程序成为我博客里第一篇暴力）

　　话说回来，这道题真的就是个模板题，只不过是复杂了很多的模板题。李超树套个树剖，完事。细节问题比较复杂。

　　首先看插入路径：

　　　　路径上的点到指定点的距离这一信息比较麻烦，所以将一条路径从LCA处拆开，将距离全部转化为根路径前缀和。细节就不说了，注意分出来的两条路径的ab和之前不同。

　　　　对于线段树上的一个节点，如果它有“优势线段”，那么由于一次函数是单调的，最小值必然在端点处取到。除此以外，还有可能是两个子节点的最小值。

　　然后看查询：

　　　　代码里把路径拆开了分别查询，现在想想好像没必要。

　　　　一般写的李超树都是单点查询，所以写区间查询时要多注意。首先将区间分为三类：被询问区间包含的，包含了询问区间的，与询问区间有交集但不符合之前两种情况的；

　　　　对于第一种，直接返回区间的最小值；

　　　　对于第二种，肯定还是要往下分询问的，但还有一种情况，就是此区间的“优势线段”在询问区间上的最小值；

　　　　对于第三种，除了上述情况外，还有可能是线段树区间的端点在自己区间的“优势线段”所取到的值（前提是得在询问区间内），也可以是询问区间在这里取到的最小值（当然也得在线段树区间内）；

　　　　是不是非常复杂...一个比较好写的做法是直接无脑讨论四个端点，像这样：

　　　　  

　　做比较复杂的数据结构题，如果想第一次就多得点分，暴力对拍是必不可少的。利用随机生成的小数据，我查出了10+个细节错误和刚刚那些要注意的细节问题（这么多细节哪能一下子全想到还不都是对拍）。最后分析一下复杂度：树剖一个log，李超树两个log，总的来说三个log，但是常数小，跑不满。

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# define R register int
# define LL long long
# define nl (n<<1)
# define nr (n<<1|1)

using namespace std;

const int maxn=100005;
const LL inf=123456789123456789LL;
int n,m,x,y,w,h,firs[maxn],seg_cnt=0,c[maxn<<2],S,T,d[maxn];
int id[maxn],Top[maxn],siz[maxn],son[maxn],f[maxn],cnt;
LL l[maxn],t[maxn<<2],dep[maxn],a,b;
struct edge { int too,nex,w; }g[maxn<<1];
struct seg { LL a,b; }se[maxn<<1];

void add_ed (int x,int y,int w);
int lca (int x,int y);
LL dis (int x,int y);
void dfs1 (int x);
void dfs2 (int x,int Tp);
void add_p (int x,int y,int v);
void add_t (int n,int l,int r,int v);
void add (int n,int l,int r,int ll,int rr,int v);
LL ask_p (int x,int y);
LL ask (int n,int l,int r,int ll,int rr);
void build (int n,int l,int r);
void update (int n);
LL read();

int main()
{
    n=read(),m=read();
    for (R i=1;i<n;++i)
    {
        x=read(),y=read(),w=read();
        add_ed(x,y,w); add_ed(y,x,w);
    }
    l[1]=0; d[1]=1;
    dfs1(1); dfs2(1,1); build(1,1,n);
    int opt=0;
    for (R i=1;i<=m;++i)
    {
        opt=read();
        if(opt==1)
        {
            S=read(),T=read(),a=read(),b=read();
            int LA=lca(S,T);
            se[++seg_cnt].b=b+l[S]*a; se[seg_cnt].a=-a; 
            add_p(S,LA,seg_cnt);
            se[++seg_cnt].a=a; se[seg_cnt].b=a*l[S]-2*l[LA]*a+b;
            add_p(LA,T,seg_cnt);
        }
        else
        {
            S=read(),T=read();
            int LA=lca(S,T);
            LL ans=min(ask_p(S,LA),ask_p(LA,T));
            printf("%lld\n",ans);
        }
    }
    return 0;
}

LL read()
{
    LL x=0,f=1;
    char c=getchar();
    while (!isdigit(c)) { if(c=='-') f=-f; c=getchar(); }
    while (isdigit(c)) x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x*f;
}

void update (int n)
{
    t[n]=min(t[n],t[nl]);
    t[n]=min(t[n],t[nr]);
}

void build (int n,int l,int r)
{
    t[n]=inf;
    if(l==r) return;
    int mid=(l+r)>>1;
    build(nl,l,mid); build(nr,mid+1,r);
}

void add_ed (int x,int y,int w)
{
    g[++h].nex=firs[x];
    firs[x]=h;
    g[h].too=y;
    g[h].w=w;
}

int lca (int x,int y)
{
    while(Top[x]!=Top[y])
    {
        if(d[ Top[x] ]>d[ Top[y] ]) swap(x,y);
        y=f[ Top[y] ]; 
    }
    return (d[x]<d[y])?x:y;
}

LL dis (int x,int y)
{
    int a=lca(x,y);
    return l[x]+l[y]-2*l[a];
}

void dfs1 (int x)
{
    int j,maxs=-1; siz[x]=1;
    for (R i=firs[x];i;i=g[i].nex)
    {
        j=g[i].too;
        if(f[x]==j) continue;
        l[j]=l[x]+g[i].w;
        f[j]=x; d[j]=d[x]+1;
        dfs1(j);
        siz[x]+=siz[j];
        if(siz[j]>=maxs) maxs=siz[j],son[x]=j;
    }
}

void dfs2 (int x,int Tp)
{
    id[x]=++cnt; Top[x]=Tp; dep[ cnt ]=l[x];
    if(!son[x]) return;
    dfs2(son[x],Tp);
    int j;
    for (R i=firs[x];i;i=g[i].nex)
    {
        j=g[i].too;
        if(son[x]==j||f[x]==j) continue;
        dfs2(j,j);
    }
}

void add_p (int x,int y,int v)
{
    while(Top[x]!=Top[y])
    {
        if(d[ Top[x] ]>d[ Top[y] ]) swap(x,y);
        add(1,1,n,id[ Top[y] ],id[y],v);
        y=f[ Top[y] ];
    }
    if(d[x]>d[y]) swap(x,y);
    add(1,1,n,id[x],id[y],v);
}

void add_t (int n,int l,int r,int v)
{
    if(!c[n]) { t[n]=min(t[n],min(dep[l]*se[v].a+se[v].b,dep[r]*se[v].a+se[v].b)); c[n]=v; return; }
    int x=c[n],mid=(l+r)>>1;
       if(l!=r) update(n);
    t[n]=min(t[n],min(dep[l]*se[v].a+se[v].b,dep[r]*se[v].a+se[v].b));
    if(dep[l]*se[v].a+se[v].b>=dep[l]*se[x].a+se[x].b&&dep[r]*se[v].a+se[v].b>=dep[r]*se[x].a+se[x].b) return;
    if(dep[l]*se[v].a+se[v].b<=dep[l]*se[x].a+se[x].b&&dep[r]*se[v].a+se[v].b<=dep[r]*se[x].a+se[x].b) { c[n]=v; return; }
    if(se[x].a>=se[v].a)
    {
        if(se[x].a*dep[mid]+se[x].b>=se[v].a*dep[mid]+se[v].b) c[n]=v,add_t(nl,l,mid,x);
        else add_t(nr,mid+1,r,v);
    }
    else
    {
        if(se[x].a*dep[mid]+se[x].b>=se[v].a*dep[mid]+se[v].b) c[n]=v,add_t(nr,mid+1,r,x);
        else add_t(nl,l,mid,v);
    }
    if(l!=r) update(n);
}

void add (int n,int l,int r,int ll,int rr,int v)
{
    if(ll<=l&&r<=rr) add_t(n,l,r,v);
    else
    {
        int mid=(l+r)>>1;
        if(ll<=mid) add(nl,l,mid,ll,rr,v);
        if(rr>mid) add(nr,mid+1,r,ll,rr,v);
        update(n);
    }
}

LL ask_p (int x,int y)
{
    LL ans=inf;
    while(Top[x]!=Top[y])
    {
        if(d[ Top[x] ]>d[ Top[y] ]) swap(x,y);
        ans=min(ans,ask(1,1,n,id[ Top[y] ],id[y]));
        y=f[ Top[y] ];
    }
    if(d[x]>d[y]) swap(x,y);
    ans=min(ans,ask(1,1,n,id[x],id[y]));
    return ans;
}

LL ask (int n,int l,int r,int ll,int rr)
{
    if(ll<=l&&r<=rr) return t[n];
    int mid=(l+r)>>1; LL ans=inf;
    if(ll<=mid) ans=min(ans,ask(nl,l,mid,ll,rr));
    if(rr>mid) ans=min(ans,ask(nr,mid+1,r,ll,rr));
    if(c[n])
    {
        if(l<=ll&&ll<=r) ans=min(ans,dep[ll]*se[ c[n] ].a+se[ c[n] ].b);
        if(l<=rr&&rr<=r) ans=min(ans,dep[rr]*se[ c[n] ].a+se[ c[n] ].b);
        if(ll<=l&&l<=rr) ans=min(ans,dep[l]*se[ c[n] ].a+se[ c[n] ].b);
        if(ll<=r&&r<=rr) ans=min(ans,dep[r]*se[ c[n] ].a+se[ c[n] ].b);
    }
    return ans;
}

 

　　生成魔咒：https://lydsy.com/JudgeOnline/problem.php?id=4516

　　题意概述：每次在一个字符串后插入字符，并求出每次操作后本质不同的子串数量。$n<=10^5$

　　这题挺妙的。SAM应该很好做，因为它本来就是个在线算法。不过还是考虑用SA.（不是模拟退火）

　　SA计算本质不同子串数量的时候有这么一个公式：

　　$\sum_{i=1}^nn-sa_i+1-height_i$

　　理解一下：先求出每个后缀的前缀数量（也就是子串数量），然后减掉相同的。其实为什么大家都用这个公式我并不是很明白，因为完全可以简化很多，不就是所有子串数量减掉ht的和吗？

　　好的，那我们化简一下，只考虑ht的和。

　　再说的直白一点，就是每个后缀与排名在它之前一名的后缀的LCP的和。

　　动态的插入字符，如果反过来看，也就是每次加入一个新的后缀，它的排名在之前已经处理好了，现在需要的就是动态的维护刚刚所说的那个值了。

　　随便找一个能维护前驱后继的数据结构，插入一个点时，找到它的前驱后继（这两个本来相当于是挨着的），把这一对对答案的贡献消除，再加入新串和前驱后继对答案的贡献。

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <map>
# define R register int
# define nl (n<<1)
# define nr (n<<1|1)
 
using namespace std;
 
const int maxn=100005;
const int inf=1e7;
int n;
int a[maxn],cnt,ta[maxn],tb[maxn],A[maxn],B[maxn],sa[maxn],rk[maxn],ht[maxn];
int st[maxn][20],lg[maxn],tl[maxn<<2],tr[maxn<<2];
map <int,int> M;
 
void build_SA ()
{
    for (R i=1;i<=n;++i) ta[ a[i] ]++;
    for (R i=1;i<=1000;++i) ta[i]+=ta[i-1];
    for (R i=n;i>=1;--i) sa[ ta[ a[i] ]-- ]=i;
    rk[ sa[1] ]=1;
    for (R i=2;i<=n;++i)
    {
        rk[ sa[i] ]=rk[ sa[i-1] ];
        if(a[ sa[i] ]!=a[ sa[i-1] ]) rk[ sa[i] ]++;
    }
    for (R l=1;rk[ sa[n] ]!=n;l<<=1)
    {
        for (R i=0;i<=n;++i) ta[i]=tb[i]=0;
        for (R i=1;i<=n;++i) ta[ A[i]=rk[i] ]++,tb[ B[i]=(i+l<=n)?rk[i+l]:0 ]++;
        for (R i=1;i<=n;++i) ta[i]+=ta[i-1],tb[i]+=tb[i-1];
        for (R i=n;i>=1;--i) rk[ tb[ B[i] ]-- ]=i;
        for (R i=n;i>=1;--i) sa[ ta[ A[ rk[i] ] ]-- ]=rk[i];
        rk[ sa[1] ]=1;
        for (R i=2;i<=n;++i)
        {
            rk[ sa[i] ]=rk[ sa[i-1] ];
            if(A[ sa[i] ]!=A[ sa[i-1] ]||B[ sa[i] ]!=B[ sa[i-1] ]) rk[ sa[i] ]++;
        }
    }
    int j=0;
    for (R i=1;i<=n;++i)
    {
        if(j) j--;
        while(a[i+j]==a[ sa[ rk[i]-1 ]+j ]) j++;
        ht[ rk[i] ]=j;
    }
}
 
void build_ST()
{
    for (R i=2;i<=n;++i) lg[i]=lg[i>>1]+1;
    for (R i=1;i<=n;++i) st[i][0]=ht[i];
    for (R k=1;k<=17;++k)
        for (R i=1;i+(1<<k)-1<=n;++i) st[i][k]=min(st[i][k-1],st[i+(1<<(k-1))][k-1]);
}
 
int lcp (int i,int j)
{
    int k=lg[j-i+1];
    return min(st[i][k],st[j-(1<<k)+1][k]);
}
 
void build (int n,int l,int r)
{
    tr[n]=inf;
    if(l==r) return;
    int mid=(l+r)>>1;
    build(nl,l,mid); build(nr,mid+1,r);
}
 
int askl (int n,int l,int r,int ll,int rr)
{
    if(ll<=l&&r<=rr) return tl[n];
    int mid=(l+r)>>1,ans=-inf;
    if(ll<=mid) ans=max(ans,askl(nl,l,mid,ll,rr));
    if(rr>mid) ans=max(ans,askl(nr,mid+1,r,ll,rr));
    return ans;
}
 
int askr (int n,int l,int r,int ll,int rr)
{
    if(ll<=l&&r<=rr) return tr[n];
    int mid=(l+r)>>1,ans=inf;
    if(ll<=mid) ans=min(ans,askr(nl,l,mid,ll,rr));
    if(rr>mid) ans=min(ans,askr(nr,mid+1,r,ll,rr));
    return ans;
}
 
void ins (int n,int l,int r,int pos)
{
    if(l==r) { tl[n]=l,tr[n]=l; return; }
    int mid=(l+r)>>1;
    if(pos<=mid) ins(nl,l,mid,pos);
    else ins(nr,mid+1,r,pos);
    tl[n]=max(tl[nl],tl[nr]);
    tr[n]=min(tr[nl],tr[nr]);
}
 
int main()
{
    scanf("%d",&n);
    for (R i=1;i<=n;++i)
    {
        scanf("%d",&a[i]);
        if(M[ a[i] ]) a[i]=M[ a[i] ];
        else M[ a[i] ]=++cnt,a[i]=cnt;
    }
    for (R i=1;i<=n/2;++i) swap(a[i],a[n-i+1]);
    build_SA();
    build_ST();
    long long ans=0;
    build(1,1,n);
    for (R i=n;i>=1;--i)
    {
        int lef=0,rig=0;
        if(rk[i]!=1) lef=askl(1,1,n,1,rk[i]-1);
        if(rk[i]!=n) rig=askr(1,1,n,rk[i]+1,n);
        if(lef==-inf) lef=0; if(rig==inf) rig=0;
        if(lef&&rig) ans-=lcp(lef+1,rig);
        if(lef) ans+=lcp(lef+1,rk[i]);
        if(rig) ans+=lcp(rk[i]+1,rig);
        ins(1,1,n,rk[i]);
        printf("%lld\n",1LL*(n-i+1)*(n-i+2)/2-ans);
    }
    return 0;
}

 

　　排列计数：https://lydsy.com/JudgeOnline/problem.php?id=4517

　　直接粘题面.jpg

　　“ 有多少种长度为 n 的序列 A，满足以下条件：

　　1 ~ n 这 n 个数在序列中各出现了一次

　　若第 i 个数 A[i] 的值为 i，则称 i 是稳定的。序列恰好有 m 个数是稳定的

　　满足条件的序列可能很多，序列数对 10^9+7 取模。”

　　$T=500000，n≤1000000，m≤1000000$ 

　　这题十分诡异,因为它的难度和其它几题真的不搭。

　　那么这题怎么做？$C_n^m$ 表示选出哪些数是稳定的,$\times d_{n-m}$表示其它元素进行错排。没了？没了。

　　

# include <cstdio>
# include <iostream>
# include <queue>
# include <cstring>
# include <string>
# define R register int
# define ll long long
# define mod 1000000007
 
using namespace std;
 
const int maxn=1000000;
int T;
int n,m; 
long long d[maxn+3],f[maxn+3],inv[maxn+3];
 
ll qui (ll a)
{
    ll b=mod-2,s=1;
    while (b)
    {
        if(b&1LL) s=s*a%mod;
        a=a*a%mod;
        b>>=1LL;
    }
    return s;
}
 
ll C (int n,int m)
{
    return f[n]*inv[m]%mod*inv[n-m]%mod;
}
 
inline int read ()
{
    int x=0;
    char c=getchar();
    while (!isdigit(c)) c=getchar();
    while (isdigit(c)) { x=(x<<3)+(x<<1)+(c^48); c=getchar(); }
    return x;
}
 
int main()
{
    scanf("%d",&T);
    d[0]=1;
    d[1]=0;
    for (R i=2;i<=maxn;++i)
        d[i]=(i-1)*(d[i-1]+d[i-2])%mod;
    f[0]=1;
    for (R i=1;i<=maxn;++i)
        f[i]=f[i-1]*i%mod;
    inv[maxn]=qui(f[maxn]);
    for (R i=maxn-1;i>=0;--i)
        inv[i]=inv[i+1]*(i+1)%mod;
    while(T--)
    {
        n=read();
        m=read();
        printf("%lld\n",C(n,m)*d[n-m]%mod);
    }
    return 0;
}

　　

　　征途:https://lydsy.com/JudgeOnline/problem.php?id=4518

　　题意概述：将一个长度为 $n$ 的序列分成 $m$ 段，使得每一段的方差和最小。$n,m<=3000$

　　这题做的比较早，也写过blog，在这里；

　　但是后来有学了一种方法：带权二分；

　　显然如果不限制分段数量，最优解就是每个数分成一段，这样的答案是0，如果要求必须分成1段，那么答案就是整个序列的方差。

　　可以发现随着段数的增加，最优解也在变优，所以就有了一种很有趣的做法：给“分段”这件事带上一个权值，每多分一段，就要在最终答案里加上一个常数；

　　加的数越大，分的段数就会越少，如果某次最优解的段数恰好为所要求的的值，把这个值减掉段数*常数即为答案。需要注意的是有可能一直分不到段数为k，即：二分的常数为c，段数是k+1，常数为c-1，段数就直接跳到了k-1。这里不用实数二分，因为这道题涉及的所有量都是整数，如果出现上述情况，说明k-1段和k段的最优解是相等的，这时的答案就可以作为k段的答案。

　　不限制段数的dp很好做，利用斜率优化可以做到 $O(N)$，再加上二分的复杂度，还是比之前的那种 $O(NM)$快到不知道哪里去了，有图为证：

　　

# include <cstdio>
# include <iostream>
# define R register int
# define ll long long
 
using namespace std;
 
const int maxn=3005;
int n,m,s[maxn],c,f[maxn];
ll ans,dp[maxn];
 
double X (int x) { return s[x]; }
double Y (int x) { return dp[x]+1LL*s[x]*s[x]; }
double K (int x,int y) { return (Y(x)-Y(y))/(X(x)-X(y)); }
 
struct que
{
    int q[maxn],h,t;
    void init() { h=1,t=1; }
    void ins (int x)
    {
        int a=q[t-1],b=q[t],c=x;
        while(h<t&&K(a,b)>K(b,c))
        {
            t--;
            a=q[t-1],b=q[t],c=x;
        }
        q[++t]=x;
    }
    void del (int x)
    {
        double k=2*s[x];
        int a=q[h],b=q[h+1];
        while(h<t&&K(a,b)<k)
        {
            h++;
            a=q[h],b=q[h+1];
        }
    }
}q;
 
int check (int c)
{
    q.init(); int x;
    for (R i=1;i<=n;++i)
    {
        q.del(i);
        x=q.q[ q.h ];
        dp[i]=Y(x)-2*s[i]*s[x]+c+s[i]*s[i];
        f[i]=f[x]+1;
        q.ins(i);
    }
    return f[n];
}
 
int main()
{
    scanf("%d%d",&n,&m);
    for (R i=1;i<=n;++i) scanf("%d",&s[i]),s[i]+=s[i-1];
    int l=0,r=2000000000;
    while(l<=r)
    {
        c=r-(r-l)/2; int t=check(c);
        if(t==m) break;
        if(t<m) r=c-1; else l=c+1;
    }
    printf("%lld",(dp[n]-1LL*c*m)*m-s[n]*s[n]);
    return 0;
}

　　

　　总的来说这套题的排题让人挺迷惑的。明明是最简单的“排列计数”却放到D2T2这样的位置，复杂难调的“游戏”放到D1，但题目的质量还是很不错的。

　　下次再发类似的做题笔记可能就要很久了，因为14年的“向量集”，15年的“道路修建”，17年的“树点涂色”...哪个都不是好做的题。想再做完整一套还是要花一些时间的。

　　SDOI 2019 rp++;　　

---shzr