CSP-J/S2019试题选做

Posted dysyn1314

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了CSP-J/S2019试题选做相关的知识，希望对你有一定的参考价值。

小蒟蒻duyi CSP爆炸之后一直在颓，所以直到最近才陆续订正完CSP的题/kel 以后不能这么颓了(flag)

S D1T2 括号树

设(f[u])表示根到(u)的路径上有多少子串是合法括号串。（即题目里的(k_u)，此变量名缺乏个性，故换之）

从根向每个节点dfs，容易求出(c[u])：表示从根到(u)的路径上，我们能匹配则匹配，最后剩下多少个待匹配的左括号。 例如如下(s_u)对应的(c[u])：

  • ((() (c[u]=2)。

  • (())( (c[u]=1)。

  • (()() (c[u]=1)。

  • ()))( (c[u]=1)。

  • (()()) (c[u]=0)。

如果(u)节点上括号为)且(c[u]geq 0)，说明可以以(u)节点为结尾，形成一个新的合法子序列。我们大胆猜想，满足上述两个条件时，(f[u]=f[fa(u)]+1)，否则(f[u]=f[fa(u)])。 可惜过不了大样例。 仔细分析一下发现我们漏算了很多子串。

如：对于(s_u=)(()()，因为(f[4]=1)，所以我们会认为(f[5]=2)，但其实(f[5])应该等于(3)，我们漏算了([2,5])这个合法子串。 事实上，我们这样做只计算出了以(u)结尾的最短合法子串。问题就出在，当序列结尾形成一个新的合法子串时，它可能和前面原本已经闭合的的子串拼在一起，结合形成“并列式”子串。 极端的例子如(()()()()中([8,9])这个子串，可以和([6,7])拼，也可以和([4,7])拼，甚至可以和([2,7])拼在一起，分别构成新的并列式子串。

我们称：在同一个括号中的、并列出现的、合法的子串为同一层里的子串。如：(()()( () )) ()中，([2,3],[4,5],[6,9])在同一层，([1,10],[11,12])在同一层。

发现两个合法子串在同一层的条件是：结尾位置的(c[i])相同，且两个子串中间没有经过过一个(c[x]<c[i])的部分。如：(()()) (())里的([2,3])和([8,9])就不在同一层，因为它们是(c[i]=1)，但中间经过了一个(c[6]=0<1)。

如果子串结尾位置为(i)，我们称(c[i]=k)的子串位于第(k)层。

那么对每个(u)，我们要求出，从根到(u)的路径上，每一层有多少个并列的合法子串。这样，我们就能知道(c[u])这一层有多少合法子串能和“以(u)结尾的最短合法子串”拼接。

看起来这需要一个二维的数组来记录。但我们发现，从“以(fa(u))结尾的串里每一层有多少并列的合法子串”，到“以(u)结尾的串里每一层有多少并列的合法子串”，这当中的修改是很小且很特殊的：当(u)上是)时，(c[u])这一层会多一个并列的合法子串，而(c[i]>c[u])的这些层，它们的并列合法子串数将清零，这是根据我们前面分析出的“两个合法子串在同一层的条件”中要求它们之间不能存在一个(c[x]<c[i])，现在(u)就是这个(x)了。

先从父亲处继承，然后单点(+1)，并把这个点的后缀清零。主席树可以实现。

时间、空间复杂度：(O(nlog n))。

参考代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN=5e5+5;
struct EDGE{int nxt,to;}edge[MAXN];
int head[MAXN],tot;
inline void add_edge(int u,int v){edge[++tot].nxt=head[u];edge[tot].to=v;head[u]=tot;}
int n,rt[MAXN],ls[MAXN*30],rs[MAXN*30],val[MAXN*30],cnt;
void modify(int &x,int y,int l,int r,int pos){
    x=++cnt;val[x]=val[y];ls[x]=ls[y];rs[x]=rs[y];
    val[x]++;
    if(l==r)return;
    int mid=(l+r)>>1;
    if(pos<=mid)modify(ls[x],ls[y],l,mid,pos),rs[x]=0;
    else modify(rs[x],rs[y],mid+1,r,pos);
}
int query(int x,int l,int r,int pos){
    if(!x)return 0;
    if(l==r)return val[x];
    int mid=(l+r)>>1;
    if(pos<=mid)return query(ls[x],l,mid,pos);
    else return query(rs[x],mid+1,r,pos);
}
ll f[MAXN],c[MAXN];
char s[MAXN];
void dfs(int u){
    for(int i=head[u];i;i=edge[i].nxt){
        int v=edge[i].to;
        f[v]=f[u];c[v]=c[u];rt[v]=rt[u];
        if(s[v]=='('){
            if(c[v]<0)c[v]=0,rt[v]=0;
            c[v]++;
        }
        else {
            c[v]--;
            if(c[v]>=0){
                f[v]++;
                f[v]+=query(rt[v],0,n,c[v]);
                modify(rt[v],rt[v],0,n,c[v]);
            }
        }
        dfs(v);
    }
}
int main(){
//  freopen("brackets.in","r",stdin);
//  freopen("brackets.out","w",stdout);
    scanf("%d%s",&n,s+1);
    for(int i=2,fa;i<=n;++i)scanf("%d",&fa),add_edge(fa,i);
    if(s[1]=='(')c[1]=1;else c[1]=-1;
    dfs(1);
    ll ans=0;
    for(int i=1;i<=n;++i)ans^=((ll)i*f[i]);
    //cout<<f[i]<<" ";cout<<endl;
    //
    cout<<ans<<endl;
    return 0;
}

S D1T3 树上的数

我看了wqy大佬的题解并决定盗用他的图（雾

首先考虑一条链的情况。

我们观察链上某个节点(u)上的数字变动情况。可以发现无论我们先删左边还是先删右边，原来它上面的数字一定会被搬运到了其中一个方向，同时另一个方向一定又过来了一个数，此外还有一个数字反向经过了(u)。

也就是下面这种情况（这里是先删除右边那条边）：

技术图片

再考虑菊花，即围绕着节点(u)有多条出边的情况。如果把这些边排成一圈依次拆掉，我们先会把(u)上的数挪到某个与它相邻的节点上。然后从这个节点开始，按顺时针顺序，这一圈上每个数依次从(u)的某条边进入，然后从顺时针的下一条边出去。最后某个数会进入(u)然后不再出去，这就是最终留在(u)上的数了。

如果画出来会很优美：

技术图片

因为是求字典序最小，显然应该按数字(1)到(n)贪心，每个数字都挪到它能挪到的编号最小的节点上。

不妨以当前数字所在的节点为根。我们做一遍dfs，判断每个点是否能被挪到。节点(u)能被挪到，其实分为两个部分的条件：

  1. 根到(u)的路径上（不包括根和(u)）每个节点都能够作为“中转节点”（图中一进一出的那种）；

  2. (u)自己能够作为终点节点（图中只进不出的那种）。

考虑条件1，对于每个(v)，我们要判断的其实是能否从根一路通畅地走入(v)的子树。我们称满足这样条件的(v)为“合法”。

  • 如果(v)的父亲(fa(v))不合法，则(v)肯定也不合法。

  • 如果(fa(v))到(v)的这条边已经被以相同的方向使用过，则(v)不合法。（根据上图，显然每条边最终都会被以两个方向各走一遍，此处我们只要判断(fa(v))走向(v)的方向是否被走过）

  • 如果(fa(v))不为根，我们从(fa(fa(v)))走到(fa(v))，再走向(v)，相当于在(fa(v))这个节点上一进一出。我们加入这一进一出的路径后，如果恰好把(fa(v))周围所有经过它的路径串成了一圈（首尾相接），但是(fa(v))周围仍然存在还没走过的边，则我们现在还不能走这一进一出。即(v)不合法。【注：这部分比较复杂，请结合图和代码仔细理解，具体的实现方式下面会讲。】

考虑条件2，我们判断一个点(u)能否作为终点，方法和判(v)类似。

  • 如果(u)已经存在一条只进不出的边了，则(u)不能作为终点。（根据图来看显然每个点只能有一次只进不出的机会。根据实际含义来说就是，之前已经有别的数以(u)作为终点了，所以(u)不能作为当前数的终点）

  • 如果(fa(u))到(u)的这条边已经被以相同的方向使用过，则(u)不能作为终点。

  • 如果加入(fa(u))到(u)的路径后，(u)周围的路径会被串成一圈，但(u)周围仍然存在还没走过的边，则(u)现在还不能作为终点。

这样，对于每个数我们贪心地选编号最小的、能作为终点的点即可。选出后我们暴力更新这个点到根路径上的信息。

下面讲一些具体实现的问题：

判断一条边以哪个方向走过是比较容易的。需要注意的是：我们的根在不断变化，所以不能以“是从父亲走向儿子”还是“从儿子走向父亲”来判断。我是直接建了个二维的邻接表，state[u][v]=u表示(u,v)间的边从(u)到(v)走过，state[u][v]=v表示(u,v)间的边从(v)到(u)走过，state[u][v]=0表示两个方向都走过，state[u][v]=-1表示两个方向都没走过。

如何判断加入一条路径后，(u)周围的所有路径是否会被串成一圈？由于路径是有方向的，若干路径会串成一条链，我们记一条链的开头为(st)，结尾为(ed)。新加入的路径如果是一进一出，那么我们要判断，如果：进入的那头的链的(st)是(u)上数字移出的边，走出的那头的链的(ed)是(u)上数字移入的边，加入这一进一出后，就会把所有边串成一条链了。

所谓(u)上数字移入、移出的边是指：对于每个节点(u)，都会有唯一的一条移出的边，也会有唯一的一条移入的边。如上图中(x ightarrow 1)就是移出，(5 ightarrow x)就是移入。【这部分请结合图和代码重点理解】

最开始时，(u)周围的每条边都是一条单独的链。当我们加入一进一出的路径，我们实际上是连起了两条链。这个“连起”的过程，我们可以用并查集维护：对每个(u)都开一个并查集，维护它周围的每条链的(st)和(ed)。一进一出时，进的那条链提供合并后的(st)，出的那条链提供合并后的(ed)。

最后，请注意特判(n=1)时的情况，因为我们的程序中默认每个点都会移出去一次、移进来一次，而(n=1)时这种情况根本不会发生。

时间复杂度(O(n^2alpha))，空间复杂度(O(n^2))。

参考代码：

//problem:P5659
#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define mk make_pair
#define lob lower_bound
#define upb upper_bound
#define fst first
#define scd second

typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<int,ll> pil;
typedef pair<ll,int> pli;

namespace Fread{
    const int MAXN=1<<20;
    char buffer[MAXN],*S,*T;
    inline char getchar(){
        if(S==T){
            T=(S=buffer)+fread(buffer,1,MAXN,stdin);
            if(S==T)return EOF;
        }
        return *S++;
    }
}
#ifdef ONLINE_JUDGE
    #define getchar Fread::getchar
#endif
inline int read(){
    int f=1,x=0;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
inline ll readll(){
    ll f=1,x=0;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

const int MAXN=2005;
struct EDGE{int nxt,to;}edge[MAXN<<1];
int head[MAXN],tot;
inline void add_edge(int u,int v){edge[++tot].nxt=head[u],edge[tot].to=v,head[u]=tot;}
int n,p[MAXN],d_nu[MAXN],d_in[MAXN],d_out[MAXN],frm[MAXN],to[MAXN],state[MAXN][MAXN];
struct DSU{
    int fa[MAXN],st[MAXN],ed[MAXN],sz[MAXN];
    int get_fa(int x){
        return x==fa[x]?x:(fa[x]=get_fa(fa[x]));
    }
    void union_s(int frm,int to){
        int x=get_fa(frm),y=get_fa(to);
        if(x==y)return;
        if(sz[x]<sz[y])fa[x]=y,st[y]=st[x],sz[y]+=sz[x];
        else fa[y]=x,ed[x]=ed[y],sz[x]+=sz[y];
    }
    int get_st(int x){
        return st[get_fa(x)];
    }
    int get_ed(int x){
        return ed[get_fa(x)];
    }
    void Init(int x){
        fa[x]=st[x]=ed[x]=x;sz[x]=1;
    }
}b[MAXN];
/*
tips:
p[num] -> node
d_nu[u]: edge(from u) not used
stata[u][v]:
 - -1 not used
 - u u->v
 - v v->u
 - 0 u->v & v->u
*/
int Root,fa[MAXN];
bool flag[MAXN];
void dfs(int u){
    for(int i=head[u];i;i=edge[i].nxt){
        int v=edge[i].to;
        if(v==fa[u])continue;
        fa[v]=u;
        flag[v]=1;
        //能否经过u,到达v
        if(!flag[u])flag[v]=0;
        else if(u!=Root){
            if(state[u][fa[u]]==0||state[u][fa[u]]==fa[u]||state[u][v]==0||state[u][v]==u)flag[v]=0;
            else if(flag[v]&&b[u].get_st(fa[u])==to[u]&&b[u].get_ed(v)==frm[u]&&d_in[u]+d_out[u]+d_nu[u]*2-2!=0)flag[v]=0;
            else if(flag[v]&&b[u].get_ed(v)==fa[u])flag[v]=0;
        }
        else{
            //assert(!to[u]);
            if(state[u][v]==0||state[u][v]==u)flag[v]=0;
            else if(flag[v]&&b[u].get_ed(v)==frm[u]&&d_in[u]+d_out[u]+d_nu[u]*2-1!=0)flag[v]=0;
        }
        dfs(v);
    }
    //能否以u为终点
    if(u==Root)flag[u]=0;
    else{
        if(frm[u])flag[u]=0;
        else if(flag[u]&&b[u].get_st(fa[u])==to[u]&&d_in[u]+d_out[u]+d_nu[u]*2-1!=0)flag[u]=0;
    }
}
void Init(){
    tot=0;
    for(int i=1;i<=n;++i){
        head[i]=0;
        d_nu[i]=d_in[i]=d_out[i]=frm[i]=to[i]=0;
    }
}
int main() {
    int Testcases=read();while(Testcases--){
        Init();
        n=read();
        for(int i=1;i<=n;++i)p[i]=read();
        if(n==1){
            puts("1");
            continue;
        }
        for(int i=1,u,v;i<n;++i){
            u=read(),v=read(),add_edge(u,v),add_edge(v,u);
            d_nu[u]++,d_nu[v]++;
            b[u].Init(v),b[v].Init(u);
            state[u][v]=state[v][u]=-1;
        }
        for(int i=1;i<=n;++i){
            Root=p[i];
            fa[Root]=0,flag[Root]=1;
            dfs(Root);
            int res=0;
            for(int j=1;j<=n;++j)if(flag[j]){res=j;break;}
            //assert(res!=0&&res!=Root);
            printf("%d ",res);
            int u=res;
            frm[u]=fa[u];
            while(fa[u]!=Root){
                //assert(state[u][fa[u]]==state[fa[u]][u]);
                if(state[u][fa[u]]==-1){
                    state[u][fa[u]]=state[fa[u]][u]=fa[u];
                    d_nu[u]--,d_nu[fa[u]]--;
                    d_in[u]++,d_out[fa[u]]++;
                }else{
                    //assert(state[u][fa[u]]==u);
                    state[u][fa[u]]=state[fa[u]][u]=0;
                    d_in[fa[u]]--,d_out[u]--;
                }
                int v=u;
                u=fa[u];
                b[u].union_s(fa[u],v);
            }
            to[Root]=u;
            if(state[u][fa[u]]==-1){
                state[u][fa[u]]=state[fa[u]][u]=fa[u];
                d_nu[u]--,d_nu[fa[u]]--;
                d_in[u]++,d_out[fa[u]]++;
            }else{
                //assert(state[u][fa[u]]==u);
                state[u][fa[u]]=state[fa[u]][u]=0;
                d_in[fa[u]]--,d_out[u]--;
            }
        }
        puts("");
    }
    return 0;
}

S D2T1 Emiya 家今天的饭

总结一下要求：

  • 总共要选至少一个位置（不能不选）。

  • 每行至多选一个位置。

  • 每列选的位置数量不超过所选总数的(frac{1}{2})。

部分分：(m=2)或(3)时，以(m=3)为例，我们可以设(dp[i][a][b][c])表示考虑了(i)行，第(1)列选了(a)个，第(2)列选了(b)个，第(3)列选了(c)个的方案数。统计答案时要求(a,b,cleqlfloorfrac{a+b+c}{2} floor)即可。复杂度(O(n^{m+1}))。我考场上就写的这个，得到了64分的好成绩。

发现每列不超过(frac{1}{2})这个限制很特殊。如果我们枚举哪些列不合法，那么容易发现，不合法的列至多只有(1)列。所以我们枚举那一个不合法的列，然后求出：在强制这一列不合法的前提下的方案数。

设(dp[i][j][k])表示考虑了前(i)行，共选了(j)个数，强制不合法的列选了(k)个数，时的方案数。复杂度(O(n^3m))，可以得到(84)分的高分(Orz pmt!)。

考虑优化，其实我们关系的只是(j)和(k)之间的关系。具体地，最后我们要求(k>lfloorfrac{j}{2} floor)，即(2k-j>0)。所以我们可以把([j][k])两维压成一维：令(dp[i][x])表示考虑了前(i)行，(2k-j=x)时的方案数即可。由于(x)可能(<0)，所以在具体实现时我们把第二维的值统一加(n)。

时间复杂度(O(n^2m))。

//problem:P5664
#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define mk make_pair
#define lob lower_bound
#define upb upper_bound
#define fst first
#define scd second

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

inline int read(){
    int f=1,x=0;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
inline ll readll(){
    ll f=1,x=0;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

const int MOD=998244353;
inline int mod(int x){return x<MOD?(x<0?x+MOD:x):x-MOD;}
int n,m,a[105][2005],s[105],dp[105][205];
int main() {
    n=read();m=read();int ans=1;
    for(int i=1;i<=n;++i){for(int j=1;j<=m;++j)a[i][j]=read(),s[i]=mod(s[i]+a[i][j]);ans=(ll)ans*(s[i]+1)%MOD;}
    ans=mod(ans-1);
    for(int l=1;l<=m;++l){
        memset(dp,0,sizeof(dp));
        dp[0][n]=1;
        for(int i=0;i<n;++i){
            for(int j=n-i;j<=n+i;++j){
                if(!dp[i][j])continue;
                dp[i+1][j+1]=mod(dp[i+1][j+1]+(ll)dp[i][j]*a[i+1][l]%MOD);
                dp[i+1][j-1]=mod(dp[i+1][j-1]+(ll)dp[i][j]*mod(s[i+1]-a[i+1][l])%MOD);
                dp[i+1][j]=mod(dp[i+1][j]+dp[i][j]);
            }
        }
        for(int j=n+1;j<=n+n;++j)ans=mod(ans-dp[n][j]);
    }
    cout<<ans<<endl;
    return 0;
}

S D2T2 划分

部分分：设(dp[i][j])表示考虑了前(i)个数，当前段的结束位置为(i)，上一段的结束位置为(j)时的最小代价。转移时枚举上上段的结束位置(k)，从(dp[j][k])转移。对于每个(i,j)，合法的(k)一定是一段后缀（位置可以二分出来），所以记录(dp)第二维的后缀最小值即可转移，复杂度(O(n^2log n))。

我们为什么要用dp的第二维记录一个(j)呢？我们把一个东西记录在dp的一维里，必然是因为这个东西“有得有失”。比如做背包时，加入一个物品，增加了价值，但同时也增加了重量。我们不知道如何去平衡这个得失，或者说不知道在此时最优的情况所带来的的“失”是否会使全局更劣，于是我们单开一维，把每一种情况都记录下来，从而保证不错过全局最优解。

回到本题，我们之所以不设(dp[i])，是因为这样我们不知道上一段的和是什么，缺少条件，不好转移。但是如果用一个数组记录下每一个(i)是从哪里转移过来的呢？这样我们能否保证，对(j)最有利的转移点，也同时最有利于(j)后面所有需要从(j)转移的点？也就是说，如果这个问题的答案是肯定的，那么不存在“有的有失”的情况，当前最优即全局最优，我们直接贪心、直接钦定，不用经过第二维DP的权衡。

考虑每次转移时，选择满足条件的（上一段的和(leq)当前段和的）点中最靠后的转移。

可以证明，这样做一定是最优的。

备注：我在网上找到了两篇证明，但是证明并不优美且没啥扩展价值，所以就不展开了。附两个链接供读者参考。

证明from cjy

证明from myy

感性理解一下结论好像又很显然（雾）

在此结论的基础上，每个位置(i)的上一段的结束位置就是确定的了，我们记为(pre(i))。对(a)做前缀和，我们记(s_i=sum_{j=1}^{i}a_j)。

则最优的转移点(pre(i))一定是所有满足(s_i-s_jgeq s_j-s_{pre(j)})的(j)中最大的。把这个条件转化一下就是(2s_j-s_{pre(j)}leq s_i)。

我们维护一个单调队列。在这个队列中，从队首到队尾，元素的下标单调递增，队内元素(j)的(2s_j-s_{pre(j)})也单调递增。因为如果存在一个(k<j)使得(2s_k-s_{pre(k)}geq2s_j-s_{pre(j)})，则(k)在任何时候都不会有用。

当需要从(i)转移时，我们检查队首。如果队首的下一个元素满足转移条件，则可以把队首弹掉。因为我们总是取满足条件的元素中下标最大的。而(s_i)是单调递增的，这个队首如果现在没有用，以后就再也不会有用了。

复杂度(O(n))。

为了避免空间爆炸，我们只开一个长度为(n)的数组，即前缀和数组。其他的信息都用结构体或pair装在单调队列里，这样使用的内存大小为任意时刻的最大队列长度，显然是(leq n)的。

参考代码：

//problem:P5665
#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define mk make_pair
#define lob lower_bound
#define upb upper_bound
#define fst first
#define scd second

typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<int,ll> pil;
typedef pair<ll,int> pli;

namespace Fread{
    const int MAXN=1<<20;
    char buffer[MAXN],*S,*T;
    inline char getchar(){
        if(S==T){
            T=(S=buffer)+fread(buffer,1,MAXN,stdin);
            if(S==T) return EOF;
        }
        return *S++;
    }
}
#ifdef ONLINE_JUDGE
    #define getchar Fread::getchar
#endif
inline int read(){
    int f=1,x=0;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
inline ll readll(){
    ll f=1,x=0;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

const int MAXN=4e7+5;
int n;
ll s[MAXN];
__int128 dp[MAXN];
void big_input(){
    int x,y,z,b[2],pj,lj,rj;
    x=read(),y=read(),z=read(),b[1]=read(),b[0]=read(),read();
    const int moood=(1<<30);
    pj=0;
    for(int i=1,j=0;i<=n;++i){
        if(i>pj){
            ++j;
            pj=read();lj=read();rj=read();
        }
        if(i>2)b[i&1]=((ll)b[(i&1)^1]*x+(ll)b[i&1]*y+z)%moood;
        s[i]=s[i-1]+(b[i&1]%(rj-lj+1))+lj;
    }
}
void print(__int128 ans){
    const ll base=1e18;
    if(ans<base)cout<<(ull)ans<<endl;
    else{
        cout<<(ll)(ans/base);
        ll t=ans%base;int len=0;
        while(t)len++,t/=10;
        for(int i=1;i<=18-len;++i)cout<<"0";
        if(ans%base)cout<<(ll)(ans%base)<<endl;
    }
}
int main() {
    n=read();int ty=read();
    if(!ty)for(int i=1;i<=n;++i)s[i]=s[i-1]+read();
    else big_input();
    dp[0]=0;
    deque<pli>dq;dq.push_back(mk(0,0));
    for(int i=1;i<=n;++i){
        while(dq.size()>1&&s[i]>=dq[1].fst)dq.pop_front();
        __int128 d=s[i]-s[dq.front().scd];dp[i]=dp[dq.front().scd]+d*d;
        while(!dq.empty()&&dq.back().fst>=s[i]+d)dq.pop_back();
        dq.push_back(mk(s[i]+d,i));
    }
    print(dp[n]);
    return 0;
}

S D2T3 树的重心

不妨先令(1)为根。考虑以根作为重心的贡献。

设根最大的子树大小为(mx)。

  • 如果割掉的边不在最大的子树内，则割去的子树大小(t)要满足(mx imes 2leq n-t)，即(tleq n-mx imes 2)；

  • 否则，割掉的边在最大的子树内，设次大子树大小为(smx)，则割去子树大小(t)要满足：(smx imes 2leq n-t,(mx-t) imes 2leq n-t)，即(mx imes2-nleq tleq n-smx imes2)。

我们用线段树合并求出每个节点子树内每种大小的子树分别有多少。枚举根的每个儿子，分别在根的线段树上做区间查询，就得到了根作为重心的出现次数。

如果暴力枚举根，每次重新做线段树合并，则复杂度(O(n^2log n))。

考虑换根。发现如果以(u)为根，则相比于以(fa(u))为根，在线段树上的变化：只会增加一个(n-size_u)，减少一个(size_u)。在dfs时用一个树状数组维护根到当前节点的路径上，哪些(size)值被增加了，哪些(size)值被减少了，回溯时在树状数组上消除贡献即可。

需要注意的是，线段树合并后，原线段树上的信息就会被覆盖，所以我们不能在换根时再到(u)的线段树上进行查询，而要在第一遍dfs到(u)时就把换根需要的查询信息预处理好。

参考代码：

//problem:P5666
#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define mk make_pair
#define lob lower_bound
#define upb upper_bound
#define fst first
#define scd second

typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<int,ll> pil;
typedef pair<ll,int> pli;

namespace Fread{
    const int MAXN=1<<20;
    char buffer[MAXN],*S,*T;
    inline char getchar(){
        if(S==T){
            T=(S=buffer)+fread(buffer,1,MAXN,stdin);
            if(S==T)return EOF;
        }
        return *S++;
    }
}
#ifdef ONLINE_JUDGE
    #define getchar Fread::getchar
#endif
inline int read(){
    int t;cin>>t;return t;
    int f=1,x=0;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
inline ll readll(){
    ll f=1,x=0;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

const int MAXN=3e5;
struct EDGE{int nxt,to;}edge[MAXN<<1];
int n,head[MAXN],tot;
inline void add_edge(int u,int v){edge[++tot].nxt=head[u],edge[tot].to=v,head[u]=tot;}
int rt[MAXN];
struct SegmentTree{
    int cnt,ls[MAXN*40],rs[MAXN*40],sum[MAXN*40];
    void modify(int &p,int l,int r,int pos,int x){
        if(!p)p=++cnt;assert(cnt<MAXN*40);
        sum[p]+=x;
        if(l==r)return;
        int mid=(l+r)>>1;
        if(pos<=mid)modify(ls[p],l,mid,pos,x);
        else modify(rs[p],mid+1,r,pos,x);
    }
    int merge(int x,int y){
        if(!x||!y)return x+y;
        int z=++cnt;assert(cnt<MAXN*40);
        sum[z]=sum[x]+sum[y];
        ls[z]=merge(ls[x],ls[y]);
        rs[z]=merge(rs[x],rs[y]);
        return z;
    }
    int query(int p,int l,int r,int ql,int qr){
        if(ql>qr||!p)return 0;
        if(ql<=l&&qr>=r)return sum[p];
        int mid=(l+r)>>1,res=0;
        if(ql<=mid)res=query(ls[p],l,mid,ql,qr);
        if(qr>mid)res+=query(rs[p],mid+1,r,ql,qr);
        return res;
    }
    void Init(){
        for(int i=1;i<=cnt;++i)ls[i]=rs[i]=sum[i]=0;cnt=0;
    }
    SegmentTree(){}
}T1;
int sz[MAXN],f[MAXN],L[MAXN],R[MAXN];
void dfs1(int u,int fa){
    sz[u]=1;
    for(int i=head[u];i;i=edge[i].nxt){
        int v=edge[i].to;
        if(v==fa)continue;
        dfs1(v,u);
        sz[u]+=sz[v];
    }
    int mx=n-sz[u],smx=0;
    for(int i=head[u];i;i=edge[i].nxt){
        int v=edge[i].to;
        if(v==fa)continue;
        if(sz[v]>mx)smx=mx,mx=sz[v];
        else if(sz[v]>smx)smx=sz[v];
    }
    for(int i=head[u];i;i=edge[i].nxt){
        int v=edge[i].to;
        if(v==fa)continue;
        if(smx==mx||sz[v]!=mx){
            f[u]+=T1.query(rt[v],1,n,1,n-2*mx);
        }else{
            f[u]+=T1.query(rt[v],1,n,2*mx-n,n-2*smx);
        }
    }
    for(int i=head[u];i;i=edge[i].nxt){
        int v=edge[i].to;
        if(v==fa)continue;
        rt[u]=T1.merge(rt[u],rt[v]);
    }
    if(fa){
        if(smx==mx||n-sz[u]!=mx){
            f[u]-=T1.query(rt[u],1,n,L[u]=1,R[u]=n-2*mx);
        }else{
            f[u]-=T1.query(rt[u],1,n,L[u]=2*mx-n,R[u]=n-2*smx);
        }
        T1.modify(rt[u],1,n,sz[u],1);
    }
}
ll ans;
struct BIT{
    int c[MAXN];
    void modify(int p,int x){
        for(;p<=n;p+=(p&(-p)))c[p]+=x;
    }
    int query(int p){
        int res=0;
        for(;p;p-=(p&(-p)))res+=c[p];
        return res;
    }
    int query(int l,int r){
        l=max(l,1),r=min(r,n);
        if(l>r)return 0;
        return query(r)-query(l-1);
    }
    void Init(){
        memset(c,0,sizeof(int)*(n+3));
    }
    BIT(){}
}T2;
void dfs2(int u,int fa){
    if(fa){
        T2.modify(sz[u],-1);
        T2.modify(n-sz[u],1);
        f[u]+=T1.query(rt[1],1,n,L[u],R[u])+T2.query(L[u],R[u]);
    }
    //cout<<"* "<<u<<" "<<f[u]<<endl;
    ans+=(ll)u*f[u];
    for(int i=head[u];i;i=edge[i].nxt){
        int v=edge[i].to;
        if(v==fa)continue;
        dfs2(v,u);
    }
    if(fa){
        T2.modify(sz[u],1);
        T2.modify(n-sz[u],-1);
    }
}
void Init(){
    memset(head,0,sizeof(int)*(n+3));tot=0;
    memset(rt,0,sizeof(int)*(n+3));T1.Init();
    T2.Init();
    memset(f,0,sizeof(int)*(n+3));
}
int main() {
    //freopen("data.txt","r",stdin);
    int Testcases=read();while(Testcases--){
        Init();
        n=read();
        for(int i=1,u,v;i<n;++i)u=read(),v=read(),add_edge(u,v),add_edge(v,u);
        //for(int i=1;i<=n;++i)ans+=(ll)i*solve_root(i);
        dfs1(1,0);
        ans=0;dfs2(1,0);
        printf("%lld
",ans);
    }
    return 0;
}

J T2 公交换乘

设(P=max_{i=1}^{n}{price_i})。我敲了一个O(nP)的模拟就直接AC了（大雾）

O(nP)代码片段：

const int MAXN=1e5+5;
int n;
struct node{int type,price,t;}a[MAXN];
deque<int>dq[1005];
int main() {
    n=read();
    for(int i=1;i<=n;++i)a[i].type=read(),a[i].price=read(),a[i].t=read();
    int ans=0;
    for(int i=1;i<=n;++i){
        if(a[i].type==0){
            ans+=a[i].price;
            dq[a[i].price].push_back(i);
        }
        else{
            int opt=-1;
            for(int j=a[i].price;j<=1000;++j){
                while(!dq[j].empty()&&a[dq[j].front()].t<a[i].t-45)dq[j].pop_front();
                if(!dq[j].empty()){
                    if(opt==-1||a[dq[j].front()].t<a[dq[opt].front()].t)opt=j;
                }
            }
            if(opt==-1)ans+=a[i].price;
            else dq[opt].pop_front();
        }
    }
    cout<<ans<<endl;
    return 0;
}

这里讲一下(O(nlog P))的做法。

我们开一棵下标为票价的值域的线段树。线段树的每个叶子节点上放一个deque。非叶子节点存子树内每个deque的front（首元素）的最小值（deque里存的值是车票的编号，其最小值也就是出现时间最早的车票）。特别地，如果一个deque为空，则令该叶子的值为无穷大。

对于一辆地铁，我们直接在它对应的票价的deque上新加入（push_back）一个下标。

对于一辆公交，我们要查询所有尚未使用的、票价不超过(price_i)的车票里时间最早的。相当于在线段树上查询一段后缀的最小值。

  • 如果最小值(<t_i-45)，则直接将其弹出，因为它已经过期，以后也不会再有用了。继续查询。

  • 如果查询到的最小值为无穷大，说明所有合法的票价都为空了，我们没有匹配到合法的地铁，这辆公交车必须自己买票。

  • 否则说明查到了一班合法的地铁。将其弹出（表示已使用）。

因为每辆地铁只会入队列、出队列一次，每次加入、弹出时涉及到的线段树操作是(O(log P))的。所以总复杂度(O(nlog P))。

参考代码：

//problem:P5661
#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define mk make_pair
#define lob lower_bound
#define upb upper_bound
#define fst first
#define scd second

typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;

namespace Fread{
    const int MAXN=1<<20;
    char buffer[MAXN],*S,*T;
    inline char getchar(){
        if(S==T){
            T=(S=buffer)+fread(buffer,1,MAXN,stdin);
            if(S==T)return EOF;
        }
        return *S++;
    }
}
#ifdef ONLINE_JUDGE
    #define getchar Fread::getchar
#endif
inline int read(){
    int f=1,x=0;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
inline ll readll(){
    ll f=1,x=0;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

const int MAXN=1e5+5,MAXP=1005,INF=1e9;
int n;
struct node{int type,price,t;}a[MAXN];
struct SegmentTree{
    int val[MAXP],pos[MAXN<<2];
    deque<int>dq[MAXP];
    void push_up(int p){
        pos[p]=(val[pos[p<<1]]<=val[pos[p<<1|1]]?pos[p<<1]:pos[p<<1|1]);
    }
    void build(int p,int l,int r){
        if(l==r){
            val[l]=INF;
            pos[p]=l;
            return;
        }
        int mid=(l+r)>>1;
        build(p<<1,l,mid);
        build(p<<1|1,mid+1,r);
        push_up(p);
    }
    void modify(int p,int l,int r,int pos,int x){
        if(l==r){
            if(x==-1){
                assert(!dq[l].empty());
                dq[l].pop_front();
                val[l]=(dq[l].empty()?INF:dq[l].front());
            }
            else{
                dq[l].push_back(x);
                val[l]=dq[l].front();
            }
            return;
        }
        int mid=(l+r)>>1;
        if(pos<=mid)modify(p<<1,l,mid,pos,x);
        else modify(p<<1|1,mid+1,r,pos,x);
        push_up(p);
    }
    int query(int p,int l,int r,int ql,int qr){
        if(ql<=l&&qr>=r)return pos[p];
        int mid=(l+r)>>1,res=0;
        if(ql<=mid)res=query(p<<1,l,mid,ql,qr);
        if(qr>mid){
            int x=query(p<<1|1,mid+1,r,ql,qr);
            if(!res||val[res]>val[x])res=x;
        }
        assert(res!=0);
        return res;
    }
}T;
int main() {
    n=read();
    for(int i=1;i<=n;++i)a[i].type=read(),a[i].price=read(),a[i].t=read();
    T.build(1,1,1000);
    int ans=0;
    for(int i=1;i<=n;++i){
        if(a[i].type==0){
            ans+=a[i].price;
            T.modify(1,1,1000,a[i].price,i);
        }
        else{
            while(true){
                int x=T.query(1,1,1000,a[i].price,1000);
                if(T.val[x]==INF){
                    ans+=a[i].price;
                    break;
                }
                else if(a[T.val[x]].t<a[i].t-45){
                    T.modify(1,1,1000,x,-1);
                }
                else{
                    T.modify(1,1,1000,x,-1);
                    break;
                }
            }
        }
    }
    cout<<ans<<endl;
    return 0;
}

J T3 纪念品

由于同一天内是可以既卖出又买入的，如果我们要将一样纪念品连续持有好几天，则我们可以视作在中间的每一天既卖出、又买入，这样我们可以在每天刚开始的时候，把手上所有的纪念品都换成钱，如果要继续持有，就在今天晚上再换回来。这样的好处是我们只需要DP出当天把所有纪念品换成钱后手上最多有多少钱即可，不用考虑其它资产。

设(f(i))表示第(i)天，把所有纪念品换成钱后，手上最多有多少钱。用这些钱我们可以在当天买纪念品、在下一天卖掉，从而在下一天得到更多的钱。

在每一天内，我们可能会买很多种不同的纪念品。设(g(x))表示在当前天，用(x)元钱，最多能在第二天（通过把手上的纪念品卖掉）换得多少钱。这相当于是完全背包的模型，因为每样纪念品可以在钱数足够的情况下买无限多个。每样纪念品都是背包的物品，它们的重量是它们在当前天的价格，而它们的价值是它们在下一天的价格。

对第(i)天，求出(g)后，则(f(i+1)=g(f(i)))。

边界是(f(1)=m)。

复杂度(O(TVn))，其中(V)是任意时刻的最大金币数量。

参考代码：

//problem:P5662
#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define mk make_pair
#define lob lower_bound
#define upb upper_bound
#define fst first
#define scd second

typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;

namespace Fread{
    const int MAXN=1<<20;
    char buffer[MAXN],*S,*T;
    inline char getchar(){
        if(S==T){
            T=(S=buffer)+fread(buffer,1,MAXN,stdin);
            if(S==T)return EOF;
        }
        return *S++;
    }
}
#ifdef ONLINE_JUDGE
    #define getchar Fread::getchar
#endif
inline int read(){
    int f=1,x=0;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
inline ll readll(){
    ll f=1,x=0;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

int t,n,m,a[105][105],f[105],g[10004];
int main() {
    t=read(),n=read(),m=read();
    for(int i=1;i<=t;++i)for(int j=1;j<=n;++j)a[i][j]=read();
    f[1]=m;
    for(int i=1;i<t;++i){
        g[0]=0;
        for(int j=1;j<=10000;++j){
            g[j]=max(j,g[j-1]);
            for(int k=1;k<=n;++k)if(j>=a[i][k])g[j]=max(g[j],g[j-a[i][k]]+a[i+1][k]);
        }
        f[i+1]=g[f[i]];
    }
    cout<<f[t]<<endl;
    return 0;
}

J T4 加工零件

发现编号为(a)的工人生产第(L)阶段的零件，需要(1)提供原材料，当且仅当存在一条(1)到(a)的路径长度为(L)。因为这个“路径”是允许在同一条边上来回横跳的，每横跳一次路径长度加(2)，所以我们可以把条件改为：当且仅当存在一条(1)到(a)的路径，长度(leq L)且奇偶性和(L)相同。

所以我们从(1)出发，对每个点求从(1)到它的奇数最短路和偶数最短路即可。因为每个点只会被入队、出队各一次，所以复杂度(O(n))。

参考代码：

//problem:P5663
#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define mk make_pair
#define lob lower_bound
#define upb upper_bound
#define fst first
#define scd second

typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;

namespace Fread{
    const int MAXN=1<<20;
    char buffer[MAXN],*S,*T;
    inline char getchar(){
        if(S==T){
            T=(S=buffer)+fread(buffer,1,MAXN,stdin);
            if(S==T)return EOF;
        }
        return *S++;
    }
}
#ifdef ONLINE_JUDGE
    #define getchar Fread::getchar
#endif
inline int read(){
    int f=1,x=0;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
inline ll readll(){
    ll f=1,x=0;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

const int MAXN=1e5+5,INF=0x3f3f3f3f;
struct EDGE{int nxt,to;}edge[MAXN<<1];
int n,m,q,head[MAXN],tot;
inline void add_edge(int u,int v){edge[++tot].nxt=head[u],edge[tot].to=v,head[u]=tot;}
int dis[MAXN][2];
void dij(){
    memset(dis,0x3f,sizeof(dis));
    dis[1][0]=0;
    queue<pii>q;q.push(mk(1,0));
    while(!q.empty()){
        int u=q.front().fst,t=q.front().scd;q.pop();
        for(int i=head[u];i;i=edge[i].nxt){
            int v=edge[i].to;
            int nd=t+1;
            if(nd<dis[v][nd&1]){
                dis[v][nd&1]=nd;
                q.push(mk(v,nd));
            }
        }
    }
}
int main() {
    n=read();m=read();q=read();
    for(int i=1,u,v;i<=m;++i)u=read(),v=read(),add_edge(u,v),add_edge(v,u);
    dij();
    while(q--){
        int u=read(),t=read();
        if(dis[u][t&1]<=t)puts("Yes");
        else puts("No");
    }
    return 0;
}

以上是关于CSP-J/S2019试题选做的主要内容，如果未能解决你的问题，请参考以下文章

置顶文章

csp-j/s是啥考试?

csp-js考内容

课下作业（选做）

csp-j/s是啥考试？

2020年csp第一轮认证分数线