CCPC Wannafly Camp 2019 div.1 day2 G Routes

• 观察一：任意两点的最短路不超过2k-1.

  首先从一个城市到另外一个城市只有两种本质不同路径，一种是不用热气球，一种是用热气球。
  所以基本想法就是把任意两个点的min（不用热气球，用热气球）加起来。
  不用热气球相当于只能在铁路上走，所以距离就等于|i-j|，暴力枚举某个点左右O(k)个点即可（因为|i-j|要不超过2k-1），这个很容易。
  下面讨论怎么计算用热气球的路径总和。

  先规定符号:
  col[i]表示i号点的颜色;
  f[i][c]表示i号点到颜色c的最短距离;
  g[a][b]表示颜色a到颜色b的最短距离。

  那么i到j用了热气球的最短路为min(f[i][c]+f[j][c]+1),+1表示在c这里用了一次热气球。
  暴力枚举是O(n^2·k)的。

• 观察二：g[col[i]][c]<=f[i][c]<=g[col[i]][c]+1,即点到团的距离至多是团到团的距离加一。

  • 推论：g[col[i]][col[j]]<=dis(i,j)<=g[col[i]][col[j]]+2。

那么可令一个二进制串sta[i]表示i这个点f和g的差，换言之，如果g[col[i]][c]==f[i][c],则sta[i]的第c位是0，否则为1.

如果枚举起点i，终点的颜色b，中转热气球是a，那么用预处理的sta[]可以做到O(nk^2)，这里不做过多阐述。

考虑枚举起点i的颜色a，终点j的颜色b。
那么a到b的路径大概可以分成一下几类：
1、dis(i,j)==g[a][b]且i->j用过热气球。
2、dis(i,j)==g[a][b]但i->j没用过热气球。
3、dis(i,j)==g[a][b]+1且i->j用过热气球。
4、dis(i,j)==g[a][b]+1但i->j没用过热气球。
5、dis(i,j)==g[a][b]+2.

5是最容易的，因为如果dis(i,j)==g[a][b]+2的话，中间一定用过热气球。
1、3也很容易，因为走过去的时候就用过热气球了。
考虑2和4，因为走过去的时候没用过热气球，所以要在a或b那里额外再用一次，答案额外+1。

那么只要利用预处理的sta[]还有另外一些东西就可以统计出以上五种路径的数量，那么就做完了。

复杂度是O(nk+k³+k²·2^k).

还有一道类似但非常简单的二进制处理题HDU5823

#include<bits/stdc++.h>
#define maxn 1000050
#define maxm 2000050
#define maxk 16
#define maxs (1<<maxk)
using namespace std;
typedef long long LL;

int m,n,K,status;

int pos[maxn];
char s[maxn];

int col[maxn],col_cnt[maxn];

int last[maxk],mn[maxk];

void init()
{
    scanf("%d%d%d",&n,&m,&K);
    status=1<<K;

    for (int c=0;c<K;++c)
        col_cnt[c]=0;
    for (int k=1;k<=m;++k)
    {
        scanf("%s",s+pos[k]);
        pos[k+1]=pos[k]+strlen(s+pos[k]);

        for (int i=pos[k];i<pos[k+1];++i)
            ++col_cnt[col[i]=s[i]-'a'];
    }
}

int dis[maxk][maxn];
int dis_col[maxk][maxk];

int D,C;

void spfa()
{
    memset(dis_col,0x3f,sizeof(dis_col));
    for (int i=0;i<n;++i)
        for (int c=0;c<K;++c)
            dis[c][i]=K<<1;

    for (int k=1;k<=m;++k)
    {
        for (int c=0;c<K;++c)   last[c]=-1;
        for (int i=pos[k];i<pos[k+1];++i)
        {
            last[col[i]]=i;
            for (int c=0;c<K;++c)
                if (~last[c])
                {
                    int j=last[c],a=col[i];
                    dis_col[c][a]=min(dis_col[c][a],i-j),dis[c][i]=min(dis[c][i],i-j);
                    dis_col[a][c]=min(dis_col[a][c],i-j),dis[a][j]=min(dis[a][j],i-j);
                }
        }
    }

    for (int k=0;k<K;++k)
        for (int i=0;i<K;++i)
            for (int j=0;j<K;++j)
                dis_col[i][j]=min(dis_col[i][j],dis_col[i][k]+dis_col[k][j]+1);
    
    for (int k=1;k<=m;++k)
    {
        for (int c=0;c<K;++c)   mn[c]=maxn;
        for (int i=pos[k];i<pos[k+1];++i)
        {
            for (int c=0;c<K;++c)
                mn[c]=min(mn[c],dis_col[col[i]][c]+1-i);
            for (int c=0;c<K;++c) dis[c][i]=min(dis[c][i],i+mn[c]);
        }
        for (int c=0;c<K;++c)   mn[c]=maxn;
        for (int i=pos[k+1]-1;i>=pos[k];--i)
        {
            for (int c=0;c<K;++c)
                mn[c]=min(mn[c],dis_col[col[i]][c]+1+i);
            for (int c=0;c<K;++c) dis[c][i]=min(dis[c][i],mn[c]-i);
        }
    }
}

int sta[maxn];
int cnt[maxk][maxs],sum[maxk][maxs];

int sp[maxk][maxk][2];

void predo()
{
    spfa();

    for (int c=0;c<K;++c)
        for (int s=0;s<status;++s)
            cnt[c][s]=sum[c][s]=0;

    for (int a=0;a<K;++a)
        for (int b=0;b<K;++b)
            for (int j=0;j<=1;++j)
            {
                sp[a][b][j]=0;
                for (int c=0;c<K;++c)
                    if (dis_col[a][c]+1+dis_col[c][b]==dis_col[a][b]+j)
                        sp[a][b][j]|=1<<c;
            }

    for (int i=0;i<n;++i)
    {
        sta[i]=0;
        for (int c=0;c<K;++c)
            sta[i]|=(dis[c][i]-dis_col[c][col[i]])<<c;
        ++cnt[col[i]][sta[i]],++sum[col[i]][sta[i]];
    }
    //&
    for (int c=0;c<K;++c)
        for (int i=0;i<K;++i)
            for (int s=0;s<status;++s)
                if (s>>i&1)
                    sum[c][s^(1<<i)]+=sum[c][s];
}

LL solve()
{
    LL ans=0;
    for (int a=0;a<K;++a)
    {
        ans+=(LL)col_cnt[a]*(col_cnt[a]-1)/2;
        for (int b=0;b<a;++b)
        {
            LL res=(LL)col_cnt[a]*col_cnt[b]*dis_col[a][b];
            for (int s=0;s<status;++s)
            {
                if (!cnt[a][s]) continue;
                int t=(~s&sp[a][b][0]);
                if (t)
                    res+=(LL)cnt[a][s]*sum[b][t];
                else
                {
                    if (s>>b&1)
                    {
                        t=(~s&sp[a][b][1]);
                        res+=(LL)cnt[a][s]*(col_cnt[b]+sum[b][t]);
                    }
                    else
                        res+=(LL)cnt[a][s]*col_cnt[b];
                }
            }
            ans+=res;
        }
    }

    for (int k=1;k<=m;++k)
    {
        memset(last,-1,sizeof(last));
        for (int i=pos[k];i<pos[k+1];++i)
        {
            for (int c=0;c<K;++c)
            {
                if (!~last[c]||c==col[i])  continue;
                int j=last[c],a=col[i],b=col[j],d;

                if (~sta[i]&~sta[j]&sp[b][a][0]) continue;
                if (~sta[i]&~sta[j]&sp[b][a][1])
                    d=dis_col[a][b]+1;
                else
                    d=dis_col[a][b]+2;

                if (d>i-j)
                    ans+=(i-j)-d;
            }
            last[col[i]]=i;
        }
    }
    return ans;
}

int main()
{
    int T,icase=0;
    scanf("%d",&T);
    while (T--)
    {
        init();
        predo();
        printf("Case #%d: %lld\n",++icase,solve());
    }
    return 0;
}

`