2020 CCPC Qinhuangdao Solutions

Problem A

Solution:

　　很简单的组合计数公式题，答案是：$\frac{\binom{r}{2}}{\binom{r+b}{2}}$。

#include "bits/stdc++.h"
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,a,n) for(int i=n;i>=a;i--)
#define pb push_back
#define mp make_pair
#define FI first
#define SE second
#define maxn 100000
#define mod 1000000007
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef double db;

int main()
{
    int CAS; scanf("%d",&CAS); rep(cas,1,CAS)
    {
        int r,b; scanf("%d%d",&r,&b);
        int p=r*(r-1)/2,q=(r+b)*(r+b-1)/2;
        int g=__gcd(p,q);
        printf("Case #%d: %d/%d\n",cas,p/g,q/g);
    }
    return 0;
}

 

Problem B

Solution:

　　不失一般性，我们只用考虑查询操作中的点 $p = (x,y)$ 在最优长方形上下左右四条边中的下面的那条边的情况，即最优长方形上下行号满足 $x_1 \le x_2 = x$。（剩下三种情况可以通过将输入旋转90度/180度/270度来处理，对4种情况的4个答案取最大值即为原问题答案。）枚举 $x_1$，通过预处理的 $lft[x_1][y]$ 和 $rt[x_1][y]$ 可以 $O(1)$ 时间确定 $x_1$ 行内包含 $(x_1,y)$ 的最大区间。同样我们可以通过 $lft[x][y]$ 和 $rt[x][y]$ 知道 $x$ 行内包含 $(x,y)$的最大区间。这两个区间取交集后得到区间 $[l,r]$，我们只需要快速计算 $\{ j | (i,j) 是干地, \forall i \in [x_1+1, x-1]\}$ 中的最大值和最小值即可。发现预处理出每个点上方的湿地首次出现位置后，倒序枚举 $x_1$  并用并查集维护湿地形成的区间可以用 $O(\alpha(n))$ 完成询问。对于修改操作，重新计算  $p = (x,y)$ 所在行列的预处理的数组即可。

#include "bits/stdc++.h"
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,a,n) for(int i=n;i>=a;i--)
#define pb push_back
#define mp make_pair
#define FI first
#define SE second
#define maxn 1000
#define mod 1000000007
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef double db;

char S[maxn+5][maxn+5],s[maxn+5][maxn+5];
pair<int,pii> OP[maxn+5],op[maxn+5];
int ans[maxn+5];

int pre[maxn+5][maxn+5],lft[maxn+5][maxn+5],rt[maxn+5][maxn+5];
vi pool[maxn+5];
bool mark[maxn+5];
int fa[maxn+5],mx[maxn+5],mn[maxn+5];
int getfa(int x)
{
    if(fa[x]==x) return x;
    return fa[x]=getfa(fa[x]);
}


void mrg(int x,int y)
{
    int fx=getfa(x);
    int fy=getfa(y);
    fa[fy]=fx;
    mn[fx]=min(mn[fx],mn[fy]);
    mx[fx]=max(mx[fx],mx[fy]);
}

void solve(int n,int m,int Q)
{
    rep(i,1,n) rep(j,1,m) pre[i][j]=s[i][j]=='.'?i:pre[i-1][j];
    rep(i,1,n) rep(j,1,m) lft[i][j]=s[i][j]=='.'?j:lft[i][j-1];
    rep(i,1,n) per(j,1,m) rt[i][j]=s[i][j]=='.'?j:(j==m?m+1:rt[i][j+1]);
    rep(q,1,Q)
    {
        int x=op[q].SE.FI;
        int y=op[q].SE.SE;
        if(op[q].FI==1)
        {
            s[x][y]=s[x][y]=='.'?'#':'.';
            rep(i,x,n) pre[i][y]=s[i][y]=='.'?i:pre[i-1][y];
            rep(j,y,m) lft[x][j]=s[x][j]=='.'?j:lft[x][j-1];
            per(j,1,y) rt[x][j]=s[x][j]=='.'?j:(j==m?m+1:rt[x][j+1]);
        }
        else
        {
            if(s[x][y]=='#')
            {
                int l=lft[x][y]+1,r=rt[x][y]-1;
                ans[q]=max(ans[q],r-l+1);
                rep(i,1,x) pool[i].clear();
                rep(j,l-1,r+1) mark[j]=0;
                rep(j,l,r) pool[pre[x][j]].pb(j);
                per(i,1,x-1) 
                {
                    int L=lft[i][y]+1,R=rt[i][y]-1;
                    L=max(L,l); R=min(R,r);
                    if(L<=y && y<=R)
                    {
                        if(mark[L])
                        {
                            int f=getfa(L);
                            L=mx[f]+1;
                        }
                        if(mark[R])
                        {
                            int f=getfa(R);
                            R=mn[f]-1;
                        }
                        if(L<=y && y<=R) ans[q]=max(ans[q],(x-i+1)*(R-L+1));
                    } 
                    for(auto j: pool[i])
                    {
                        mark[j]=1; fa[j]=mx[j]=mn[j]=j;
                        if(mark[j-1]) mrg(j-1,j);
                        if(mark[j+1]) mrg(j,j+1);
                    }
                }
            }
        }
    }
}

int main()
{
    int CAS; scanf("%d",&CAS); rep(cas,1,CAS)
    {
        int n,m,Q; scanf("%d%d%d",&n,&m,&Q);
        rep(i,1,n) scanf("%s",S[i]+1);
        rep(q,1,Q) scanf("%d%d%d",&OP[q].FI,&OP[q].SE.FI,&OP[q].SE.SE);
        rep(q,1,Q) ans[q]=0;
        
        rep(i,1,n) rep(j,1,m) s[i][j]=S[i][j];
        rep(q,1,Q) op[q]=mp(OP[q].FI,mp(OP[q].SE.FI,OP[q].SE.SE));
        solve(n,m,Q);

        rep(i,1,n) rep(j,1,m) s[j][n-i+1]=S[i][j];
        rep(q,1,Q) op[q]=mp(OP[q].FI,mp(OP[q].SE.SE,n-OP[q].SE.FI+1));
        solve(m,n,Q);

        rep(i,1,n) rep(j,1,m) s[n-i+1][m-j+1]=S[i][j];
        rep(q,1,Q) op[q]=mp(OP[q].FI,mp(n-OP[q].SE.FI+1,m-OP[q].SE.SE+1));
        solve(n,m,Q);

        rep(i,1,n) rep(j,1,m) s[m-j+1][i]=S[i][j];
        rep(q,1,Q) op[q]=mp(OP[q].FI,mp(m-OP[q].SE.SE+1,OP[q].SE.FI));
        solve(m,n,Q);

        printf("Case #%d:\n",cas);
        rep(q,1,Q) if(OP[q].FI==2) printf("%d\n",ans[q]);
    }
    return 0;
}

 

Problem C

Solution:

　　这是个假题。std考虑的情况是 Bob 在障碍物构成的凸包内。此时 Alex 一定是和 BoB 位置重叠才会最优。因此极角排序后扫一遍就行了。（我的代码是先求出射线和线段交，再在边框上排序。）

#include "bits/stdc++.h"
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,a,n) for(int i=n;i>=a;i--)
#define pb push_back
#define mp make_pair
#define FI first
#define SE second
#define maxn 100000
#define mod 1000000007
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef double db;

const db eps=1e-10;
int cmp(db x) {return (x>eps)-(x<-eps);}
struct P
{
    db x,y;
    P():x(0),y(0){}
    P(db a,db b):x(a),y(b){}
    void in() {scanf("%lf%lf",&x,&y);}
    P operator +(const P &a) const {return P(x+a.x,y+a.y);}
    P operator -(const P &a) const {return P(x-a.x,y-a.y);}
    P operator *(const db &a) const {return P(x*a,y*a);}
    P operator /(const db &a) const {return P(x/a,y/a);}
    db norm() {return sqrt(x*x+y*y);}
};

db dot(P a,P b) {return a.x*b.x+a.y*b.y;}
db cross(P a,P b) {return a.x*b.y-a.y*b.x;}
bool p_on_seg(P p,P s,P t)
{
    return cmp(cross(p-s,t-s))==0 && cmp(dot(p-s,p-t))<=0;
}

struct L
{
    P a,b;
    L(){}
    L(P x,P y):a(x),b(y){}
};

bool l_cross(L l1,L l2,P &a)
{
    if(!cmp(cross(l1.a-l1.b,l2.a-l2.b))) return 0;
    db s1=cross(l1.a-l2.a,l2.b-l2.a);
    db s2=cross(l1.b-l2.a,l2.b-l2.a);
    a=(l1.b*s1-l1.a*s2)/(s1-s2);
    return 1;
}

db c[maxn*4+5];

int main()
{
    int CAS; scanf("%d",&CAS); rep(cas,1,CAS)
    {
        int w,h; scanf("%d%d",&w,&h);
        P cor[5]={P(0,0),P(w,0),P(w,h),P(0,h),P(0,0)};
        db base[4]={0,(db)w,(db)w+h,(db)w+h+w};
        P o; o.in();
        int tot=0;
        int n; scanf("%d",&n);
        rep(cc,1,n)
        {
            P p; p.in();
            rep(i,0,3)
            {
                P cr;
                if(l_cross(L(o,p),L(cor[i],cor[i+1]),cr) && cmp(dot(p-o,cr-o))>0 && p_on_seg(cr,cor[i],cor[i+1]))
                {
                    c[++tot]=base[i]+(cr-cor[i]).norm();
                }
            }
        }
        sort(c+1,c+tot+1);
        c[tot+1]=c[1]+2*(w+h);
        db ans=0;
        rep(i,1,tot) ans=max(ans,c[i+1]-c[i]);
        printf("Case #%d: %.10f\n",cas,ans);
    }
    return 0;
}

 

Problem E

Solution:

　　枚举所有学生真正成绩的最大值 $x$，统计集合 $\{ i | a_i 和 b_i 中至少一个在 [p\%\cdot x,x]内\}$。我们可以从小到大枚举 $x$，这样可以用双端指针滑窗来统计。（代码是我脑抽写了个树状数组过的。）

#include "bits/stdc++.h"
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,a,n) for(int i=n;i>=a;i--)
#define pb push_back
#define mp make_pair
#define FI first
#define SE second
#define maxn 400000
#define mod 1000000007
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef double db;

struct BIT
{
    int a[maxn+5],n;
    void init(int N)
    {
        n=N;
        rep(i,1,n) a[i]=0;
    }
    void add(int x,int v)
    {
        for(;x<=n;x+=x&-x) a[x]+=v;
    }
    int ask(int x)
    {
        int r=0;
        for(;x;x-=x&-x) r+=a[x];
        return r;
    }
}bit;

pii cj[maxn+5];

int main()
{
    int CAS; scanf("%d",&CAS); rep(cas,1,CAS)
    {
        int n,p; scanf("%d%d",&n,&p);
        vi vec,sc;
        int mn=0;
        rep(i,1,n) 
        {
            int a,b; scanf("%d%d",&a,&b);
            cj[i]={a,b};
            vec.pb(a); vec.pb(b);
            sc.pb(a); sc.pb(b);
            mn=max(mn,b);
        }
        sort(sc.begin(),sc.end());
        sort(vec.begin(),vec.end());
        vec.erase(unique(vec.begin(),vec.end()),vec.end());
        sort(cj+1,cj+n+1);
        int N=vec.size(),ptr=1;
        bit.init(N);
        int ans=0;
        rep(i,0,N-1) if(vec[i]>=mn)
        {
            int a=vec[i],thr=(1ll*a*p+99)/100;
            int tmp=0;
            tmp+=upper_bound(sc.begin(),sc.end(),a)-lower_bound(sc.begin(),sc.end(),thr);
            while(ptr<=n && cj[ptr].FI<=a)
            {
                int id=lower_bound(vec.begin(),vec.end(),cj[ptr].SE)-vec.begin()+1;
                bit.add(id,1); ptr++;
            }
            int id=lower_bound(vec.begin(),vec.end(),thr)-vec.begin()+1;
            tmp-=bit.ask(N)-bit.ask(id-1);
            ans=max(ans,tmp);
        }
        printf("Case #%d: %d\n",cas,ans);
    }
    return 0;
}

 

Problem F

Solution:

　　发现对于一个连通块的最优解要么是一个点都不选，要么是所有点都选。所以DFS或者并查集一下就行了。

#include "bits/stdc++.h"
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,a,n) for(int i=n;i>=a;i--)
#define pb push_back
#define mp make_pair
#define FI first
#define SE second
#define maxn 300000
#define mod 1000000007
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef double db;

int fa[maxn+5],sz[maxn+5],deg[maxn+5];
int getfa(int x)
{
    if(x==fa[x]) return x;
    return fa[x]=getfa(fa[x]);
}

int main()
{
    int CAS; scanf("%d",&CAS); rep(cas,1,CAS)
    {
        int n,m; scanf("%d%d",&n,&m);
        rep(i,1,n) fa[i]=i,sz[i]=1,deg[i]=0;
        rep(i,1,m)
        {
            int x,y; scanf("%d%d",&x,&y);
            int fx=getfa(x);
            int fy=getfa(y);
            if(fx!=fy)
            {
                if(sz[fx]<sz[fy]) swap(fx,fy);
                sz[fx]+=sz[fy];
                deg[fx]+=deg[fy];
                fa[fy]=fx;
            }
            fx=getfa(x);
            deg[fx]+=2;
        }
        int ans=0;
        rep(i,1,n) if(getfa(i)==i)
        {
            if(deg[i]/2>sz[i]) ans+=deg[i]/2-sz[i];
        }
        printf("Case #%d: %d\n",cas,ans);
    }
    return 0;
}

 

Problem G

Solution:

　　$k=1$ 直接输出 $n$。$k \ge 2$ 时枚举 $i \in [1, n^{1/k}]$，用快速幂可以 $O(\log k)$ 时间内算出 $i^k$ 和 $(i+1)^k$，从而计算出 $|\{x|\lfloor x^{1/k} \rfloor = i, x\le n, x \equiv 0 (\text{mod }i)\}|$。

#include "bits/stdc++.h"
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,a,n) for(int i=n;i>=a;i--)
#define pb push_back
#define mp make_pair
#define FI first
#define SE second
#define maxn 100000
#define mod 1000000007
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef double db;

ll qp(ll a,int k)
{
    ll res=1;
    while(k)
    {
        if(k&1) res=res*a;
        a=a*a;
        k>>=1;
    }
    return res;
}

int main()
{
    int CAS; scanf("%d",&CAS); rep(cas,1,CAS)
    {
        int n,k; scanf("%d%d",&n,&k);
        int ans=0;
        if(k==1) ans=n;
        else
        {
            rep(i,1,n)
            {
                ll low=qp(i,k);
                ll upp=(db)k*log10(i+1)>=9.5?inf:qp(i+1,k);
                upp=min(upp-1,(ll)n);
                ans+=upp/i-(low-1)/i;
                if(upp==n) break;
            }
        }
        printf("Case #%d: %d\n",cas,ans);
    }
    return 0;
}

 

Problem H

Solution:

　　首先注意到一个常见的“拆贡献”套路：$cnt(a,t)^2 = |\{(i,j) | a_i = a_j = t, 1 \le i, j \le n\}|$。因此 \[\sum_{a \in S_n} cnt(a,t)^2 = \sum_{a \in S_n}|\{(i,j) | a_i = a_j = t, 1 \le i, j \le n\}| = \sum_{1\le i,j \le n} |\{a \in S_n | a_i = a_j = t\}| = \sum_{1\le i\le n} |\{a \in S_n | a_i = t\}| + 2 \sum_{1\le i<j \le n} |\{a \in S_n | a_i = a_j = t\}|。\] 我们来说一下对任意一个 $i$，$|\{a \in S_n | a_i = t\}|$ 要怎么算。分两类情况来处理：

　　1. $\forall j < i$, $a_j < t$。令 $p$ 为 $a$ 的前缀最大值序列，那么我们知道 $p_{i-1} = t - 1$。令 $dp_1(i,x)$ 表示 $|\{(a_1, ...,a_i) | p_j-p_{j-1} \le 1, j \in [1, i], p_i = x\}|$，$dp_2(i,x)$ 表示 $|\{(a_1, ...,a_i) | p'_j-p'_{j-1} \le 1, j \in [1, i]\}|$，其中对于$(a_1, ... , a_i)$ 定义 $p'_j = \max\{x, a_1, ..., a_j\} $。我们发现此种情况下 $a$ 数列的个数等于 $dp_1(i-1,t-1) \cdot dp_2(n-i,t)$。

　　2. $\exists j < i$, $a_j = t$。我们枚举最小的 $j$，答案就是 $\sum_{j<i} dp_1(j-1,t-1) \cdot dp_2(n-j-1,t)$。（假想你有一个长 $n-1$ 的合法数列且 $t$ 首次出现位置小于 $i$，那么你在位置 $i$ 处插入一个 $t$ 就好了。）

　　我们注意到这两种情况需要的 $dp_1$ 和 $dp_2$ 都可以事先 $O(n^2)$ 预处理好，对 $\sum_{j<i} dp_1(j-1,t-1) \cdot dp_2(n-j-1,t)$ 处理出前缀和，就可以 $O(1)$ 计算出 $|\{a \in S_n | a_i = t\}|$ 了。

　　对于计算 $\sum_{1\le i<j \le n} |\{a \in S_n | a_i = a_j = t\}|$，我们对任意一个 $i$ 可以类似地 $O(1)$ 计算出 $\sum_{j: i<j \le n} |\{a \in S_n | a_i = a_j = t\}|$。因此对于一个 $t$，我们可以 $O(n)$ 的时间内算出 $\sum_{a \in S_n} cnt(a,t)^2$。因此总时间复杂度为 $O(n^2)$。

#include "bits/stdc++.h"
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,a,n) for(int i=n;i>=a;i--)
#define pb push_back
#define mp make_pair
#define FI first
#define SE second
#define maxn 3000
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef double db;

int mod;

int dp[maxn+5][maxn+5],dp2[maxn+5][maxn+5];
int ans[maxn+5];

int main()
{
    int CAS; scanf("%d",&CAS); rep(cas,1,CAS)
    {
        int n; scanf("%d%d",&n,&mod);
        dp[0][0]=1%mod;
        rep(i,1,n) rep(x,1,i) dp[i][x]=(1ll*dp[i-1][x]*x+dp[i-1][x-1])%mod;
        rep(x,0,n) dp2[0][x]=1%mod; 
        rep(i,0,n) dp2[i][n+1]=0;
        rep(i,1,n) rep(x,1,n) dp2[i][x]=(1ll*dp2[i-1][x]*x+dp2[i-1][x+1])%mod;

        rep(x,1,n)
        {
            int A=0,tmp=0,tmp2=0;
            rep(i,x,n) 
            {
                A=(A+1ll*dp[i-1][x-1]*dp2[n-i][x]+2ll*dp[i-1][x-1]*dp2[n-i-1][x]%mod*(n-i)+tmp+2ll*tmp2*(n-i))%mod;
                if(i<=n-1) tmp=(tmp+1ll*dp[i-1][x-1]*dp2[n-i-1][x])%mod;
                if(i<=n-2) tmp2=(tmp2+1ll*dp[i-1][x-1]*dp2[n-i-2][x])%mod;
            }
            ans[x]=A;
        }
        printf("Case #%d:\n",cas);
        rep(i,1,n) printf("%d%c",ans[i]," \n"[i==n]);
    }
    return 0;
}

 

Problem I

Solution:

　　把技能看成向量。注意到两个向量 $a,b$ 张成的集合 $\{ra+sb|r,z \in \mathbb{Z}\} = \{r(a-b)+sb|r,z \in \mathbb{Z}\}$ ，于是我们可以对拥有的任意两个向量辗转相除，让其中一个向量的横坐标为 $0$。因此我们只需要维护两个向量 $p,q$ 其中 $p$ 横坐标非 $0$，$q$ 横坐标为 $0$。新获得一个向量就拿去先和 $p$ 辗转相除更新 $p$，余下的横坐标为 $0$ 的分量再拿去更新 $q$。查询的时候用 $p,q$ 很容易判断是否可行。

#include "bits/stdc++.h"
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,a,n) for(int i=n;i>=a;i--)
#define pb push_back
#define mp make_pair
#define FI first
#define SE second
#define maxn 100000
#define mod 1000000007
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef double db;

struct P
{
    ll x,y;
    P():x(0),y(0){}
    P(ll x,ll y):x(x),y(y){}
    P operator -(const P &a) const {return P(x-a.x,y-a.y);}
    P operator *(const ll &a) const {return P(x*a,y*a);}
};

void gcd(P &a,P &b)
{
    while(a.x!=0)
    {
        ll t=b.x/a.x;
        b=b-a*t;
        swap(a,b);
    }
}

int main()
{
    int CAS; scanf("%d",&CAS); rep(cas,1,CAS)
    {
        P a,p;
        int n; scanf("%d",&n);
        ll ans=0;
        while(n--)
        {
            int op;
            ll x,y; scanf("%d%lld%lld",&op,&x,&y);
            if(op==1)
            {
                P b(x,y);
                gcd(b,a);
                if(b.y) p.y=__gcd(p.y,abs(b.y));
                if(p.y) a.y%=p.y;
            }
            if(op==2)
            {
                P q(x,y); int w; scanf("%d",&w);
                if(x)
                {
                    if(a.x==0 || x%a.x!=0) continue;
                    ll t=x/a.x;
                    y-=t*a.y;
                }
                if(y==0) ans+=w;
                else if(p.y && y%p.y==0) ans+=w;
            }
        }
        printf("Case #%d: %lld\n",cas,ans);
    }
    return 0;
}

 

Problem J

Solution:

　　首先不同的长度 $d$ 排出来的矩阵肯定互不相同，因此我们可以对不同的 $d$ 单独处理。

　　先考虑 $d$ 整除 $n$ 的情况。此时只有一种切法，将串切成 $k=n/d$ 个小串。通过哈希合并相同的小串后，假设我们有 $k_1$ 个串 $s_1$, ..., $k_l$ 个串 $s_l$ （$k_1 + ... + k_l = k$），那么能排出的互不相同的矩阵一共有 $\frac{k!}{k_1!...k_l!}$ 个。

　　现在考虑 $d$ 不整除 $n$ 的情况。此时一共有 $\lfloor n/d \rfloor +1$ 种切法。注意到顺序/倒序枚举长度不够 $d$ 的那段小串的话，一种切法变到另一个切法对于上面所说的 $k_1, ..., k_l$ 的影响很小，只影响两个 $k_i$，因此可以 $O(1)$ 维护 $(k_1, ..., k_l)$。注意不同的切法有可能产生相同的 $(k_1, ..., k_l)$，所以这里还需要一共哈希来去重。

　　因此总时间复杂度为 $O(\sum_{d=1}^n n/d)$，即 $O(n\log n)$。注意别用 unoredered_map 存哈希，会被卡常。（手写或者用 pbds 里的 hash table 都可以过这题。）

#include "bits/stdc++.h"
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,a,n) for(int i=n;i>=a;i--)
#define pb push_back
#define mp make_pair
#define FI first
#define SE second
#define maxn 400000
#define mod 998244353
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef double db;

typedef unsigned long long hashv;
const hashv base=131,BASE=400009;
hashv pw[maxn+5],PW[maxn+5];

char s[maxn+5];
hashv hx[maxn+5];

ll fac[maxn+5],ifac[maxn+5],inv[maxn+5];

const int HASH=9999991;

struct HASHMAP
{
    int head[HASH],next[maxn*3+5],tot;
    hashv state[maxn*3+5];
    int f[maxn*3+5];
    vi used;
    void init()
    {
        tot=0;
        memset(head,-1,sizeof(head));
    }
    void reset()
    {
        tot=0;
        for(auto x: used) head[x]=-1;
        used.clear();
    }
    void insert(hashv val,int x)
    {
        int h=val%HASH;
        used.pb(h);
        for(int i=head[h];i!=-1;i=next[i]) if(val==state[i])
        {
            f[i]=x;
            return;
        }
        f[tot]=x;
        state[tot]=val;
        next[tot]=head[h];
        head[h]=tot++;
    }
    
    void add(hashv val,int x)
    {
        int h=val%HASH;
        used.pb(h);
        for(int i=head[h];i!=-1;i=next[i]) if(val==state[i])
        {
            f[i]+=x;
            return;
        }
        f[tot]=x;
        state[tot]=val;
        next[tot]=head[h];
        head[h]=tot++;
    }
    int ask(hashv val)
    {
        int h=val%HASH;
        for(int i=head[h];i!=-1;i=next[i]) if(val==state[i]) return f[i];
        return 0;
    }
    int operator [](const hashv &x) {return ask(x);}
}H,id,M;

int main()
{
    pw[0]=PW[0]=1;
    rep(i,1,maxn) pw[i]=pw[i-1]*base;
    rep(i,1,maxn) PW[i]=PW[i-1]*BASE;

    inv[1]=fac[0]=ifac[0]=1;
    rep(i,2,maxn) inv[i]=inv[mod%i]*(mod-mod/i)%mod;
    rep(i,1,maxn) fac[i]=fac[i-1]*i%mod;
    rep(i,1,maxn) ifac[i]=ifac[i-1]*inv[i]%mod;

    H.init();
    id.init();
    M.init();
    
    int CAS; scanf("%d",&CAS); rep(cas,1,CAS)
    {
        scanf("%s",s+1);
        int n=strlen(s+1);
        rep(i,1,n) hx[i]=hx[i-1]*base+s[i];
        ll ans=0;
        rep(d,1,n)
        {
            M.reset();
            id.reset();
            int cnt=0;
            int N=n/d;
            hashv I=0;
            rep(j,1,N)
            {
                hashv h=hx[j*d]-hx[(j-1)*d]*pw[d];
                M.add(h,1);
                if(id[h]==0) id.insert(h,++cnt);
                I+=PW[id[h]];
            }
            ll tmp=fac[N];
            rep(i,0,M.tot-1) tmp=tmp*ifac[M.f[i]]%mod;
            ans=(ans+tmp)%mod;
            int off=n%d;
            if(n%d)
            {
                H.reset();
                H.insert(I,1);
                per(j,1,N)
                {
                    hashv oh=hx[j*d]-hx[(j-1)*d]*pw[d];
                    tmp=tmp*fac[M[oh]]%mod;
                    M.add(oh,-1);
                    tmp=tmp*ifac[M[oh]]%mod;
                    hashv nh=hx[j*d+off]-hx[(j-1)*d+off]*pw[d];
                    tmp=tmp*fac[M[nh]]%mod;
                    M.add(nh,1);
                    tmp=tmp*ifac[M[nh]]%mod;
                    if(id[nh]==0) id.insert(nh,++cnt);
                    I-=PW[id[oh]];
                    I+=PW[id[nh]];
                    if(H[I]==0)
                    {
                        ans=(ans+tmp)%mod;
                        H.insert(I,1);
                    }
                }
            }
        } 
        printf("Case #%d: %lld\n",cas,ans);
    }
    return 0;
}

 

Problem K

Solution:

　　先假设对于每条从根到叶子的链我们都派一个人从根走到叶子然后停在叶子。那么对于一个叶子 $v$ 要花费 $dis(v)$ 的代价，其中 $dis(v)$ 表示根到点 $v$的距离。假设合并两条链 $root \rightarrow v, root \rightarrow v'$，让一个人先走到 $v$ 再走到 $v'$ 然后停下，会发现花费变为 $dis(v') + 2dis(v) -2dis(lca(u,v))$。这里观察到两个性质：一是让 $dis(v') \le dis(v)$ 在合并时会相对较好，二是如果我们对每个叶子 $v$ 定义 $mark(v)$ 为在其向上 $\lfloor dis(v) \rfloor$ 的祖先，那么我们发现合并 $v,v'$ 会变得更优当且仅当 $mark(v)$ 是 $mark(v')$ 的祖先。因此我们 DFS 的时候统计所有最深的 $mark(v)$ 带来的影响就行了。

#include "bits/stdc++.h"
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,a,n) for(int i=n;i>=a;i--)
#define pb push_back
#define mp make_pair
#define FI first
#define SE second
#define maxn 1000000
#define mod 1000000007
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef double db;

int val[maxn+5],sta[maxn+5];
vi e[maxn+5];
int ans=0;

int dfs(int now,int fa,int dep)
{
    sta[dep]=now;
    int x=sta[dep-(dep-1)/2];
    val[x]=max(val[x],dep-1);
    int cnt=0;
    for(auto v: e[now]) if(v!=fa)
    {
        cnt+=dfs(v,now,dep+1);
    }
    if(val[now]!=-1 && cnt==0)
    {
        cnt=1;
        ans-=val[now];
    } 
    ans+=now==1?0:2*(max(1,cnt));
    return cnt;
}

int main()
{
    int CAS; scanf("%d",&CAS); rep(cas,1,CAS)
    {
        int n; scanf("%d",&n);
        rep(i,1,n) e[i].clear(),val[i]=-1;
        rep(i,2,n)
        {
            int x; scanf("%d",&x);
            e[i].pb(x);
            e[x].pb(i);
        }
        ans=0;
        dfs(1,0,1);
        printf("Case #%d: %d\n",cas,ans);
    }
    return 0;
}

 

Problem L

Solution:

　　定义 $l_t[i] = \max\{l_{t-1}[i] + 1, l_{t-1}[i-1], l_{t-1}[i+1]\}$ 和 $r_t[i] = \min\{r_{t-1}[i] - 1, r_{t-1}[i-1], r_{t-1}[i+1]\}$，$l_0[i] = l[i]$，$r_0[i] = r[i]$。可以发现 $l_t[i] = \max_{i-t\ \le j \le i+t}{l[j] + (d - |j - i|)}$，$r_t[i] = \min_{i-t\ \le j \le i+t}{r[j] - (d - |j - i|)}$。我们发现如果 $r_t[i] < l_t[i]$，那么在时间 $t$ 时第 $i$ 列就会消失。因此我们可知 $ans[i] = \arg\min_{t\ge 1} \{r_t[i] < l_t[i]\}$。注意到 $ans[1]=1$，$|ans[i]-ans[i-1]| \le 1$，因此我们在确定 $ans[i-1]$ 后只需要枚举 $ans[i]$ 是 $\{ans[i-1]-1, ans[i-1], ans[i-1]+1\}$ 中的哪一个就行了。进一步发现这个可以用滑动窗口来做，时间复杂度为 $O(n)$。

#include "bits/stdc++.h"
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,a,n) for(int i=n;i>=a;i--)
#define pb push_back
#define mp make_pair
#define FI first
#define SE second
#define maxn 5000000
#define mod 998244353
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef double db;

typedef unsigned long long ull;

ull xorshift128p(ull &A,ull &B) 
{
    ull T=A,S=B;
    A=S;
    T^=T<<23;
    T^=T>>17;
    T^=S^(S>>26);
    B=T;
    return T+S;
}

void gen(int n,int L,int X,int Y,ull A,ull B,int l[],int r[]) 
{
    rep(i,1,n) 
    {
        l[i]=xorshift128p(A,B)%L+X;
        r[i]=xorshift128p(A,B)%L+Y;
        if(l[i]>r[i]) swap(l[i],r[i]);
    }
}

int l[maxn+5],r[maxn+5];
int ans[maxn+5];

struct monotone_queue
{
    pii q[maxn+5];
    int front,rear;
    void init()
    {
        front=0; rear=-1;
    }
    void push(int x,int id)
    {
        while(front<=rear && q[rear].FI>=x) rear--;
        q[++rear]=mp(x,id);
    }
    void pop(int id)
    {
        while(front<=rear && q[front].SE<=id) front++;
    }
    int top() 
    {
        if(front>rear) return inf;
        return q[front].FI;
    }
    int ask(int id)
    {
        rep(i,front,rear) if(q[i].SE>=id) return q[i].FI;
        return inf;
    }
}q1,q2,q3,q4;

void solve(int n,int l[],int r[],int ans[])
{
    q1.init(); q2.init();
    q3.init(); q4.init();

    int d=1;
    rep(i,1,n)
    {
        if(i==1)
        {
            q1.push(r[i+1]+i+1,i+1);
            q3.push(r[i-1]-(i-1),i-1);
            q3.push(r[i]-i,i);
            q2.push(-(l[i+1]-(i+1)),i+1);
            q4.push(-(l[i-1]+(i-1)),i-1);
            q4.push(-(l[i]+i),i);
            ans[i]=1;
        }
        else
        {
            q1.pop(i); q3.push(r[i]-i,i);
            q2.pop(i); q4.push(-(l[i]+i),i);
            d--;
            rep(j,0,2)
            {
                if(min(q1.top()-d-i,q3.ask(i-d)-d+i)<max(-q2.top()+d+i,-q4.ask(i-d)+d-i))
                {
                    ans[i]=d;
                    q3.pop(i-d-1); q4.pop(i-d-1);
                    break;
                }
                else 
                {
                    d++;
                    q1.push(r[i+d]+i+d,i+d);
                    q2.push(-(l[i+d]-i-d),i+d);
                }
            }
        }
    }
}

int main()
{
    int CAS; scanf("%d",&CAS); rep(cas,1,CAS)
    {
        int n,L,X,Y; ull A,B; scanf("%d%d%d%d%llu%llu",&n,&L,&X,&Y,&A,&B);
        gen(n,L,X,Y,A,B,l,r);
        l[0]=l[n+1]=inf,r[0]=r[n+1]=0;
        solve(n,l,r,ans);
        int ANS=0,pw=1;
        rep(i,1,n)
        {
            ANS=(ANS+1ll*ans[i]*pw)%mod;
            pw=3ll*pw%mod;
        }
        printf("Case #%d: %d\n",cas,ANS);
    }
    return 0;
}