CODE FESTIVAL 2016 Final

链接

D. Pair Cards

对于 $i\in[0,m)$ 统计有多少对相同的数 $x\mod m=i$，以及有多少数 $x\mod m=i$。考虑贪心匹配，首先 $0$ 和 $\frac m2$ 直接自己匹配，对于 $i\in[1,\frac m2)$，将它与 $m-i$ 匹配，优先将散的匹配对面的，然后再用一对的匹配，如果匹配光了就自己匹配。

正确性显然。复杂度 $O(n+m)$。

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#define N 100010
using namespace std;
int a[N],b[N],c[N];
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    int mx=0;
    for(int i=1,x;i<=n;i++) scanf("%d",&x),c[x]++,mx=max(mx,x);
    for(int i=1;i<=mx;i++) a[i%m]+=c[i]&1,b[i%m]+=c[i]/2;
    int res=a[0]/2+b[0];
    if(m%2==0) res+=a[m/2]/2+b[m/2];
    for(int i=1;i*2<m;i++)
    {
        int v=min(a[i],a[m-i]);
        res+=v;a[i]-=v,a[m-i]-=v;
        if(a[i]){v=min(a[i]/2,b[m-i]);res+=v*2;a[i]-=v*2,b[m-i]-=v;}
        if(a[m-i]){v=min(a[m-i]/2,b[i]);res+=v*2;a[m-i]-=v*2,b[i]-=v;}
        res+=b[i]+b[m-i];
    }
    printf("%d\n",res);
    return 0;
}

E. Cookies

假设总共吃了 $k$ 次（假设最后剩下的饼干也被吃掉，此时 $X$ 就是剩下的饼干数量），其中第 $i$ 次吃之前额外做了 $t_i$ 秒的饼干。发现第 $1$ 次吃时有 $X=t_1$，第二次吃时有 $X=t_1\times t_2$，第三次吃时有 $X=t_1t_2\times t_3$。所以有 $X=\prod t_i$。总时间是 $\sum t_i+(k-1)a$。

考虑每次吃 $X$ 至少翻一倍，所以 $k$ 不会超过 $60$。考虑枚举 $k$，令 $C=(k-1)a$，根据基本不等式有：

$$\sum_{i\in[1,k]} t_i\leq k\sqrt[k]{\prod t_i}\leq k\sqrt[k]{n}$$

等号成立条件是 $t_i$ 全部相等且 $\prod t_i=n$。

显然当 $t_i\in \mathbb{Z}^+$ 时，$t_i\in\left\{\lfloor\sqrt[k]{n}\rfloor,\lceil\sqrt[k]{n}\rceil\right\}$ 时最优。枚举有多少个选 $\lfloor\sqrt[k]{n}\rfloor$ 即可。

复杂度 $O(\log^2 n)\sim O(\log^3 n)$。

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#define N 100010
#define ll long long
using namespace std;
int main()
{
    ll n,a;scanf("%lld%lld",&n,&a);
    ll ans=1e18;
    for(int i=1;i<=60;i++)
    {
        ll x=floor(pow(n,1.0/i));
        for(int j=0;j<=i;j++)
        {
            ll s=1;
            for(int k=1;k<=i-j;k++) s*=x;
            for(int k=i-j+1;k<=i;k++) s*=(x+1);
            if(s>=n){ans=min(ans,x*(i-j)+(x+1)*j+(i-1)*a); break;}
        }
    }
    printf("%lld\n",ans);
    return 0;
}

F. Road of the King

很妙的题。

首先因为这条路径是从 $1$ 出发的，所以 $1$ 必然能到路径经过的所有点。所以只需要所有点能到 $1$ 即强连通。

容易发现如果一个点和 $1$ 强连通，那么这个点与 $1$ 号点可以认为是等价的。所以我们只需要知道现在是否在强连通分量里即可。

同样，一个不包含 $1$ 的子强连通分量也不必记录，因为路径中前者一定能到达后者，而如果存在某一刻连到 $1$ 所在的连通分量中，那么所有路径上的点都并入 $1$ 所在的强连通分量。

考虑 dp。用 $f_{i,j,k}$ 表示当前路径长度为 $i$，强连通分量大小为 $j$，被访问过但是没有在连通分量的点数为 $k$ 的方案数。

转移考虑枚举下一个点是哪一类点。复杂度 $O(n^3)$。

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#define N 310
#define mod 1000000007
using namespace std;
int f[N][N][N];
void add(int &u,int v){u=(u+v>=mod?u+v-mod:u+v);}
int main()
{
    int n,m;scanf("%d%d",&n,&m);
    f[0][1][0]=1;
    for(int i=0;i<m;i++)
        for(int j=1;j<=i+1;j++)
            for(int k=0;j+k<=i+1;k++) if(f[i][j][k])
            {
                add(f[i+1][j][k+1],1ll*f[i][j][k]*(n-j-k)%mod);
                add(f[i+1][j][k],1ll*f[i][j][k]*k%mod);
                add(f[i+1][j+k][0],1ll*f[i][j][k]*j%mod);
            }
    printf("%d\n",f[m][n][0]);
    return 0;
}

G. Zigzag MST

观察 kruskal，可以发现 $z$ 边一定会在 $z+1$ 边加入前被尝试加入。换句话说在 $z+1$ 边被加入时，$z$ 边两端一定是连通的。

所以原题的连边方式可以看成：$(a,b)$ 连边权为 $c$，$(a+i-1,a+i)$ 连边权为 $c+2i-1$，$(b+i-1,b+i)$ 连边权为 $c+2i$。

这样除了 $(a,b)$ 边，剩下的都是在 $(i,i+1)$ 之间的边，对两端相同的边取最小值加入生成树即可。

复杂度 $O(m\log m)$。

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 400010
using namespace std;
int g[N],f[N];
struct road{
    int x,y,w;
}r[N];
int find(int x){return f[x]==x?f[x]:(f[x]=find(f[x]));}
int main()
{
    int n,m;scanf("%d%d",&n,&m);
    memset(g,0x3f,sizeof(g));
    for(int i=0;i<n;i++) f[i]=i;
    for(int i=1;i<=m;i++)
    {
        int x,y,w;scanf("%d%d%d",&x,&y,&w);
        r[i]=(road){x,y,w};
        g[x]=min(g[x],w+1);
        g[y]=min(g[y],w+2);
    }
    for(int i=0;i<n*2;i++) g[(i+1)%n]=min(g[(i+1)%n],g[i%n]+2);
    for(int i=0;i<n;i++) r[++m]=(road){i,(i+1)%n,g[i]};
    sort(r+1,r+m+1,[&](road a,road b){return a.w<b.w;});
    long long ans=0;
    for(int i=1;i<=m;i++)
    {
        int x=find(r[i].x),y=find(r[i].y);
        if(x==y) continue;
        f[x]=y;
        ans+=r[i].w;
    }
    printf("%lld\n",ans);
    return 0;
}

H. Tokaido

首先对于 $M=1$ 的部分。注意到因为所有格子权值都是非负数，所以如果当前行动的人棋子所在格子的下一格不是对手的棋子，它一定会往下一格走。

考虑 dp，用 $f_i$ 表示当前对手在 $i$ ，自己在 $i-1$ 时自己最大分数减对手最大分数。用 $s_i$ 表示 $\sum_{j\leq i} a_j$，有 $\displaystyle f_i=\max_{j>i}\left(a_j-s_{j-1}-f_j\right)+s_i$。

$\max$ 内部分与 $i$ 无关，直接维护当前最大值即可。复杂度 $O(n)$。

对于 $M>1$。不妨换种角度考虑：对手棋子在 $i$，自己棋子在 $i+1$。如果这一步移到 $i+1$，相当于取 $a_{i+1}$ 同时互换先后手。否则等于放弃 $a_{i+1}$ 同时保留先手权。所以 dp 方程为：$f_i=|a_{i+1}-f_{i+1}|$。

考虑维护 $F(x)$ 表示当最后一个数字为 $x$ 时的值。显然 $F(x)$ 图像始终是一条折线。$f_3(x)=F(x),f_n(x)=x$，然后递推式与 dp 方程类似。

从 $f_{i+1}(x)\rightarrow f_i(x)$ 不是很好维护。考虑倒过来，即维护 $g_i(x)$，使得 $g_i(f_{i}(x))=F(x)$。显然 $g_3(x)=x$。由于 $f_n(x)=x$，所以 $g_n(x)=F(x)$。

推导一下，有：

$$g_i(f_{i}(x))=f(x)=g_{i+1}(f_{i+1}(x))\\ g_i(|a_i-f_{i+1}(x)|)=g_{i+1}(f_{i+1}(x))\\ g_{i+1}(x)=g_i(|a_i-x|)\\ $$

大力将绝对值拆开，有：

$$g_{i+1}(x)=\left\{\begin{matrix} g_i\left(a_i-x\right)&,x\in[0,a_i]\\ g_i\left(x-a_i\right)&,x>a_i \end{matrix}\right.$$

那么 $g_{i+1}$ 本质上就是将 $g_i$ 图像向右平移了 $a_i$ 格，并令 $x\in[0,a_i),g_{i+1}(x)=g_{i}\left(2a_i-x\right)$。

直接大力维护，复杂度 $O(m+\sum a_i)$。

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#define N 1000010
#define ll long long
using namespace std;
int a[N],n,m;ll f[N],s[N];
vector<int>res;
int main()
{
    scanf("%d",&n);
    for(int i=1;i<n;i++) scanf("%d",&a[i]),s[i]=s[i-1]+a[i];
    int w=s[n-1]-s[2];
    res.reserve(w*2);
    for(int i=0;i<=w;i++) res.push_back(w-i);
    for(int i=3;i<n;i++)
    {
        int t=res.size()-1;
        for(int j=1;j<=a[i];j++) res.push_back(res[t-j]);
    }
    reverse(res.begin(),res.end());
    scanf("%d",&m);
    while(m --> 0)
    {
        int x;scanf("%d",&x);
        if(x>w) printf("%d\n",x-w+a[1]-a[2]);
        else printf("%d\n",res[x]+a[1]-a[2]);
    }
    return 0;
}

I. Reverse Grid

首先如果 $n$ 是奇数，那么最中间的一行的翻转与其他行无关，特殊处理。$m$ 同理。不妨假设 $n,m$ 都是偶数。

考虑矩阵中的每一个格子只能出现在 $4$ 个位置上，不妨把这四个位置拿出来，要使得矩阵的其他位置不交换，只能令行交换和列交换次数都是偶数。容易发现：如果四个位置字母互不相同，这样可以使这四个位置在逆序对奇偶性不变下任意排列，即 $12$ 种方案；如果存在字母相同，因为可以任意交换相同的字母，所以方案数就是四个字母的排列。

但上面考虑的都是所有行列交换次数都为偶数的情况。由于第 $i$ 行和第 $n-i+1$ 行的等价的，不妨只考虑 $i\leq \frac n2$ 的行与 $j\leq \frac m2$ 的列。容易发现如果存在点 $(i,j)$ 对应四个字母互不相同，$i$ 行翻转或者 $j$ 列翻转之后，$(i,j)$ 的奇偶性都会改变。

对行列分别建二分图，每个点点权 $\in\{0,1\}$，相当于问有多少种给边赋点权的方式，使每条边的权值是其两端点权异或和。容易发现对于每个连通块，每个节点点权完全取反。

用并查集，复杂度 $O(nm)$。

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 210
#define mod 1000000007
using namespace std;
char s[N][N];int c[26];const int fac[]={1,1,2,6,24,120};
int f[N*2],g[N*2],_2[N*2];
int find(int x){return x==f[x]?f[x]:(f[x]=find(f[x]));}
int main()
{
    int n,m;scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%s",s[i]+1);
    for(int i=_2[0]=1;i<=n+m;i++) _2[i]=_2[i-1]*2ll%mod;
    int n0=n,m0=m;n/=2,m/=2;
    int res=1;
    if(n0&1){bool r0=false;for(int i=1;i<=m;i++) if(s[n+1][i]!=s[n+1][m0-i+1]) r0=true;if(r0) res*=2;}
    if(m0&1){bool r0=false;for(int i=1;i<=n;i++) if(s[i][m+1]!=s[n0-i+1][m+1]) r0=true;if(r0) res*=2;}
    for(int i=1;i<=n+m;i++) f[i]=i;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            memset(c,0,sizeof(c));
            c[s[i][j]-'a']++,c[s[n0-i+1][j]-'a']++,c[s[i][m0-j+1]-'a']++,c[s[n0-i+1][m0-j+1]-'a']++;
            int r=fac[4];
            for(int p=0;p<26;p++) r/=fac[c[p]];
            if(r!=24) res=1ll*res*r%mod;
            else
            {
                res=12ll*res%mod;
                f[find(i)]=find(j+n);
            }
        }
    for(int i=1;i<=n+m;i++) g[find(i)]++;
    for(int i=1;i<=n+m;i++) if(f[i]==i) res=1ll*res*_2[g[i]-1]%mod;
    printf("%d",res);
    return 0;
}