[APIO2013]

A.机器人

题目大意：给定一个n*m的地图，有一些障碍物和k个机器人，你每次可以选择一个机器人往任意一个方向推，遇到转向器会转向，两个编号相邻的机器人可以合并，求最少推多少次可以全部合并。

$n,m\leqslant 500 k\leqslant 9$

题解：用f[i][j][k][l]表示i到j的机器人在(k,l)合并的最小次数，那么当(k',l')推一次可以到(k,l)的时候，它可以从f[i][j][k'][l']+1转移。当然，它还可以从f[i][p][k][l]+f[p+1][j][k][l]转移，所以我们先计算出

所有点推一次到哪里，每次做完一个f[i][j]之后，就做一次spfa。

但是spfa会T，并不能过。我们考虑开两个队列，在spfa之前把起始的位置拍好序扔到队列1，然后每次取出两个队列队头较小的松弛，松弛到的点加入队列2，这样可以保证队列1和队列2有序，spfa就进化为了bfs，排序最好用O(n)的计数排序，跑的飞快。

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
#define INF 32639
using namespace std;
inline int read()
{
    int x =  , f = ; char ch = getchar();
    while(ch < '' || ch > ''){ if(ch == '-') f = -;  ch = getchar();}
    while(ch >= '' && ch <= ''){x = x *  + ch - '';ch = getchar();}
    return x * f;
}

unsigned short d[][][][];int mark[][][],top=;
int n,h,w,cnt=,L,R;
int v[],sa[];
char st[][];
struct P{short x,y;
    P(short x=,short y=):x(x),y(y){}
    bool operator !(){return x==&&y==;}
}pos[],to[][][],q[];
bool b[][];
const int dis[][]={{,},{,},{,-},{-,}};
queue<P> q1,q2;

P dfs(int x,int y,int dir)
{
    if(mark[x][y][dir]==cnt) return to[x][y][dir]=P(-,-);mark[x][y][dir]=cnt;
    if(!(!to[x][y][dir])) return to[x][y][dir];
    int pre=dir;
    if(st[x][y]=='A') dir=(dir+)%;
    if(st[x][y]=='C') dir=(dir+)%;
    int xx=x+dis[dir][],yy=y+dis[dir][];
    if(xx<||yy<||xx>h||yy>w||st[xx][yy]=='x') return to[x][y][pre]=P(x,y);
    return to[x][y][pre]=dfs(xx,yy,dir);
}

void spfa()
{
    memset(v,,sizeof(v));
    for(int i=;i<=top;i++)v[d[L][R][q[i].x][q[i].y]]++;
    for(int i=;i<=INF;i++)v[i]+=v[i-];
    for(int i=;i<=top;i++) sa[v[d[L][R][q[i].x][q[i].y]]--]=i;
    for(int i=;i<=top;i++) q1.push(q[sa[i]]);
    top=;
    while((!q1.empty())||(!q2.empty()))
    {
        P now;
        if(q1.empty()||((!q2.empty())&&d[L][R][q1.front().x][q1.front().y]>d[L][R][q2.front().x][q2.front().y]))
            now=q2.front(),q2.pop();
        else
            now=q1.front(),q1.pop();
        b[now.x][now.y]=;
        for(int i=;i<;i++)
        {
            P t=to[now.x][now.y][i];
            if(t.x==-||t.y==-) continue;
            if(d[L][R][now.x][now.y]+<d[L][R][t.x][t.y])
            {
                d[L][R][t.x][t.y]=d[L][R][now.x][now.y]+;
                if(!b[t.x][t.y])
                {
                    b[t.x][t.y]=;
                    q2.push(t);
                }
            }
        }

    }
}

int main()
{
    n=read();w=read();h=read();
    memset(d,,sizeof(d));
    for(int i=;i<=h;i++)
    {
        scanf("%s",st[i]+);
        for(int j=;j<=w;j++)
            if(st[i][j]>''&&st[i][j]<='')
                pos[st[i][j]-'']=P(i,j);
    }
    for(int i=;i<=h;i++)
        for(int j=;j<=w;j++)
            if(st[i][j]!='x')
                for(int k=;k<;k++)
                    ++cnt,dfs(i,j,k);
    for(int i=;i<=n;i++)
    {
        b[pos[i].x][pos[i].y]=;q[++top]=pos[i];
        L=R=i;d[i][i][pos[i].x][pos[i].y]=;spfa();
    }
    for(int l=,j;l<=n;l++)
        for(int i=;(j=i+l-)<=n;i++)
        {
            for(int x=;x<=h;x++)
                for(int y=;y<=w;y++)
                {
                    for(int k=i;k<j;k++)
                        d[i][j][x][y]=min(d[i][j][x][y],(unsigned short)(d[i][k][x][y]+d[k+][j][x][y]));
                    if(d[i][j][x][y]<INF)
                        q[++top]=P(x,y),b[x][y]=;
                }
            L=i;R=j;spfa();
        }
    unsigned short ans=;
    for(int i=;i<=h;i++)
        for(int j=;j<=w;j++)
            ans=min(ans,d[][n][i][j]);
    if(ans<) printf("%u\n",ans);
    else puts("-1");
    return ;
}

B.[Apio2013]道路费用

$n\leqslant 10^{5},m\leqslant 3*10^{5},k\leqslant 20$

题解：强制选这K条边，然后我们发现K条边把整个图割成了K+1块，每一块内选的边肯定是相同的。我们把这几块缩点，然后枚举每条边选不选，对每种情况，暴力算出每条边的最大长度，通过dp算出这种情况的答案就可以啦。

复杂度$mlogm+k^{2}*2^{k}$

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define ll long long
#define INF 200000000000000000LL
#define MN 100000
#define MM 300000
#define MK 20
using namespace std;
inline int read()
{
    int x =  , f = ; char ch = getchar();
    while(ch < '' || ch > ''){ if(ch == '-') f = -;  ch = getchar();}
    while(ch >= '' && ch <= ''){x = x *  + ch - '';ch = getchar();}
    return x * f;
}

struct edge{
    int from,to;ll w;int kind;
}e[MM+MK+],ek[MK+],e3[MK+];
struct nedge{int to,next,kind;}e2[MN*+];
ll ans=,sum[MK+],p[MN+],val[MK+],mn[MK+];
int n,m,K,cnt=,s[MN+],head[MN+],cn=,bel[MN+],dep[MK+],fa2[MK+];
bool mark[MN+],b[MK+];

bool cmp(edge x,edge y){return x.w<y.w||(x.w==y.w&&x.kind>y.kind);}
int find(int x)
{
    return !s[x]?x:s[x]=find(s[x]);
}

void ins(int f,int t,int kind=)
{
    e2[++cnt]=(nedge){t,head[f],kind};head[f]=cnt;
    e2[++cnt]=(nedge){f,head[t],kind};head[t]=cnt;
}

void kruscal()
{
    for(int i=;i<=K;i++)
    {
        int x=find(ek[i].from),y=find(ek[i].to);
        s[x]=y,ins(ek[i].from,ek[i].to,);
    }
    for(int i=;i<=m;i++)
    {
        int x=find(e[i].from),y=find(e[i].to);
        if(x!=y)s[x]=y,ins(e[i].from,e[i].to,);
    }
}

void getv(int x)
{
    mark[x]=;bel[x]=cn;val[cn]+=p[x];
    for(int i=head[x];i;i=e2[i].next)
        if(!mark[e2[i].to]&&!e2[i].kind)
            getv(e2[i].to);
}

void dp(int x,int fa)
{
    sum[x]=val[x];fa2[x]=fa;
    for(int i=head[x];i;i=e2[i].next)
        if(e2[i].to!=fa)
        {
            dep[e2[i].to]=dep[x]+;
            dp(e2[i].to,x);sum[x]+=sum[e2[i].to];
        }
}
int tms=;
void solve()
{
    ll tot=;cnt=;
    for(int i=;i<=cn;i++)s[i]=,head[i]=,mn[i]=INF;
    for(int i=;i<=K;i++)
        if(b[i])
        {
            int x=find(ek[i].from),y=find(ek[i].to);
            if(x==y)return;s[x]=y;ins(ek[i].from,ek[i].to);
        }
    tms++;
    for(int i=;i<=K;i++)
    {
        int x=find(e3[i].from),y=find(e3[i].to);
        if(x!=y) s[x]=y,ins(e3[i].from,e3[i].to);
    }
    dp(,);
    for(int i=;i<=K;i++)
    {
        int u=e3[i].from,v=e3[i].to;
        if(dep[u]<dep[v]) swap(u,v);
        while(dep[u]>dep[v]) mn[u]=min(mn[u],e3[i].w),u=fa2[u];
        while(u!=v)
        {
            mn[u]=min(mn[u],e3[i].w);
            mn[v]=min(mn[v],e3[i].w);
            u=fa2[u],v=fa2[v];
        }
    }
    for(int i=;i<=K;i++) if(b[i])
    {
        int u=ek[i].from,v=ek[i].to;
        if(dep[u]<dep[v]) swap(u,v);
        tot+=1LL*mn[u]*sum[u];
    }
    ans=max(ans,tot);
}

void dfs(int x)
{
    if(x>K)
    {
        solve();
        return;
    }
    b[x]=;dfs(x+);
    b[x]=;dfs(x+);
}

int main()
{
    n=read();m=read();K=read();
    for(int i=;i<=m;i++)
        e[i].from=read(),e[i].to=read(),e[i].w=read();
    for(int i=;i<=K;i++)
        ek[i].from=read(),ek[i].to=read();
    for(int i=;i<=n;i++)p[i]=read();
    sort(e+,e+m+,cmp);kruscal();
    for(int i=;i<=n;i++)if(!mark[i]) ++cn,getv(i);
    cnt=;
    for(int i=;i<=cn;i++) s[i]=;
    for(int i=;i<=m+K;i++) if(!e[i].kind)
    {
        int x=bel[e[i].from],y=bel[e[i].to],f1=find(x),f2=find(y);
        if(f1!=f2) s[f1]=f2,e3[++cnt]=(edge){x,y,e[i].w,};
    }
    for(int i=;i<=K;i++) ek[i].from=bel[ek[i].from],ek[i].to=bel[ek[i].to];
    dfs();
    cout<<ans;
    return ;
}