Codeforces 786E. ALT 最小割+倍增

E. ALT

http://codeforces.com/problemset/problem/786/E

题意：

给出一棵 n 个节点的树与 m 个工人。
每个工人有一条上下班路线(简单路径)，一个工人会得到满足只要下面一项满足：
1、他得到一只puppy
2、他的上下班路径上每条边都有一只doge
求使所有工人满足的最小dog数并输出方案。n≤20000，m≤10000

想法：暴力建图，源点连向工人Xi，边Yi连向汇点，容量为1。然后工人向其路径上的边连容量为1的边。O(nm)

优化建图：路径为树上连续路径，那么可以套上树链剖分变成连续区间，再用线段树优化连边....O(mlog^2n)。

反正不带修改，那么求树上路径问题还可以用点分治和倍增。O(mlogn)

点分治：对于同一个重心，维护一条轨道，通过轨道可以到达这个点到重心所有点。

具体：add(D[i],Y[i]),add(D[i],D[i-1]);

倍增：可以形象成树上一条链被拆分成若干个区间，步长为2^j,大区间向其包含的小区间连边，这个类似线段树优化建边。具体：add(G[j][x],G[j-1][x]),add(G[j][x],G[j-1][ F[j-1][x] ]);

最小割方案的输出：对于Xi如果划分到{T}集合，那么他与源点的边就被割了，他得到了一只puppy。如果Yi被划分到{S}，那么它与汇点的边被割了，一只doge放在这条边上。

附上最小割+倍增的代码(点分治好麻烦....懒癌晚期患者表示不想写)

#include<cstdio>
#include<cmath>
#include<vector>
const int len(),N(),INF(0x7fffffff);
struct Node{int nd,nx,pos;}bot[len*+];int tot,first[len+],v,u;
int f[][len+],g[][len+],logg,depth[len+],pos[len+];
struct Data{int nd,fl,nx;};
std::vector<Data>Edge[N+];int S,T;
int n,m,ans,now,last,st[len+],top,flag[N+];;
int min(int a,int b){return a>b?b:a;}
void swap(int &a,int &b){if(a==b)return;a^=b;b^=a;a^=b;}
void add(int a,int b,int p){bot[++tot]=(Node){b,first[a],p};first[a]=tot;}
void addedge(int a,int b,int f)
{
    Edge[a].push_back((Data){b,f,(int)Edge[b].size()});
    Edge[b].push_back((Data){a,,(int)Edge[a].size()-});
}
template <class T>void read(T &x)
{
    x=;char ch=getchar();
    while(ch<''||ch>'')ch=getchar();
    while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
}
void update(int x)
{
    for(int j=;j<=logg;j++)
    {
        f[j][x]=f[j-][ f[j-][x] ];
        g[j][x]=++now;
        addedge(g[j][x],g[j-][x],INF);
        addedge(g[j][x],g[j-][ f[j-][x] ],INF);
    }
}
void Dfs(int x,int fa)
{
    f[][x]=fa; g[][x]=x;
    update(x); depth[x]=depth[fa]+;
    for(int v=first[x];v;v=bot[v].nx)
    if(bot[v].nd!=fa) pos[bot[v].nd]=bot[v].pos,Dfs(bot[v].nd,x);
}
int lca(int u,int v)
{
    if(depth[u]<depth[v])swap(u,v);
    for(int k=depth[u]-depth[v],j=;k;k>>=,j++) if(k&)u=f[j][u];
    if(u==v)return u;
    for(int j=logg;j>=&&f[][v]!=f[][u];j--)
    if(f[j][u]!=f[j][v])u=f[j][u],v=f[j][v];
    return f[][v];
}
void link(int x,int y,int t)
{
    for(int k=depth[x]-depth[t],j=;k;k>>=,j++)//LCA不选
    if(k&)addedge(now,g[j][x],INF),x=f[j][x];
    for(int k=depth[y]-depth[t],j=;k;k>>=,j++)//LCA不选
    if(k&)addedge(now,g[j][y],INF),y=f[j][y];
}
void DFS_Put(int x)
{
    flag[x]=;
    for(int v=,sz=Edge[x].size();v<sz;v++)
    {
        Data y=Edge[x][v];
        if(y.fl&&!flag[y.nd])DFS_Put(y.nd);
    }
}
int q[N+],l,h,dis[N+];
bool bfs(int s,int t)
{
    for(int i=;i<=T;i++)dis[i]=INF;
    q[l=]=s; h=; dis[s]=;
    while(h<l)
    {
        int x=q[++h];
        for(int v=,sz=Edge[x].size();v<sz;v++)
        {
            Data y=Edge[x][v];
            if(y.fl&&dis[y.nd]==INF)
            dis[y.nd]=dis[x]+,q[++l]=y.nd;
        }
    }
    return dis[t]!=INF;
}
int dfs(int x,int t,int flow)
{
    if(x==t)return flow;
    int sum=,tmp;
    for(int v=,sz=Edge[x].size();v<sz;v++)
    {
        Data y=Edge[x][v];
        if(y.fl&&dis[y.nd]==dis[x]+)
        {
            tmp=dfs(y.nd,t,min(y.fl,flow));
            flow-=tmp; sum+=tmp;
            Edge[x][v].fl-=tmp;
            Edge[y.nd][y.nx].fl+=tmp;
            if(!flow)break;
        }
    }
    if(!sum)dis[x]=-;
    return sum;
}

int main()
{
    read(n),read(m);logg=log2(n);
    for(int i=;i<n;i++)
    {
        read(u),read(v);
        add(u,v,i),add(v,u,i);
    }
    now=n;
    Dfs(,);
    S=now+m+; T=S+; last=now;
    for(int i=;i<=n;i++)addedge(i,T,);
    for(int i=,Lt;i<=m;i++)
    {
        read(v),read(u);
        now++; addedge(S,now,);
        Lt=lca(v,u);
        link(v,u,Lt);
    }
    while(bfs(S,T))ans+=dfs(S,T,INF);
    printf("%d\n",ans);
    DFS_Put(S);
    for(int i=;i<=m;i++) if(!flag[i+last])st[++top]=i;
    printf("%d ",top);
    while(top)printf("%d ",st[top--]);
    for(int i=;i<=n;i++) if(flag[i])st[++top]=pos[i];
    printf("\n");
    printf("%d ",top);
    while(top)printf("%d ",st[top--]);
    return ;
}