ZOJ 2342

首先，最优的方案里，我们是不会增加石头路的费用的，也不可能去降低烂泥路的费用，所以可以认为对石头路有d=c-l，对烂泥路有d=c+l，l>=0。生成树加上原图一条边，一定构成一个圈；而最小生成树加上原图一条边，不但构成圈，而且有新加上边的权值一定不比圈中其余边的权值小，否则我们就可以得到了一个更小的生成树。利用这个性质，对于每个圈，都可以构造一些列不等式，假设i是石头路，而j是烂泥路，就有d_i<=d_j，即c_i-l_i<=c_j+l_j，即l_i+l_j>=c_j-c_i。而我们的目标是使得所有的l之和最小。这一组不等式如何求呢，其实这就是二分图最大权匹配(Maximum Weighted Matching)的对偶问题二分图最小权覆盖(Minimum Weighted Cover)！所以用匈牙利算法(Kuhn & Munkres (kuhnMunkres) Hungarian Algotithm)解决之。

shi哥说的这个对偶问题看了好久都不明白。

总结这类题目，要求du+dv>=wuv(或者du+dv<=wuv)，且u和v分属于不同的两个集合（即二分图），求sum(d)的最小（大）值,则直接跑km，最后的顶标数字就是一组最优解

 

#include<cstdio>

#include<cstring>

#include<cmath>

#include<algorithm>

#include<iostream>

#define MAXN 410

#define inf 100000000

using namespace std;

struct Edge{

    int v,id,next;

}edge[MAXN*2];

int e,head[MAXN];



int n,m,c[MAXN];



int N,mat[MAXN],lx[MAXN],ly[MAXN],slack[MAXN],w[MAXN][MAXN];

bool flag[MAXN],flagx[MAXN],flagy[MAXN];

void init()

{

    e=0;

    memset(head,-1,sizeof(head));

}

void addedge(int u,int v,int id)

{

    edge[e].v=v;

    edge[e].id=id;

    edge[e].next=head[u];

    head[u]=e++;

}



bool find(int s,int t,int id)

{

    if(s==t)

        return true;

    flag[s]=true;

    for(int i=head[s];i!=-1;i=edge[i].next){

        int v=edge[i].v;

        if(flag[v])

            continue;

        if(find(v,t,id)){

            if(c[edge[i].id]>c[id])

                w[edge[i].id][id-n+1]=c[edge[i].id]-c[id];

            return true;

        }

    }

    return false;

}



bool dfs(int u)

{

    flagx[u]=true;

    for(int i=1;i<=N;i++){

        if(flagy[i])

            continue;

        if(lx[u]+ly[i]==w[u][i]){

            flagy[i]=true;

            if(mat[i]==-1||!flagx[mat[i]]&&dfs(mat[i])){

                mat[i]=u;

                return true;

            }

        }

        else

            slack[i]=min(slack[i],lx[u]+ly[i]-w[u][i]);

    }

    return false;

}

void km()

{

    for(int i=1;i<=N;i++){

        lx[i]=ly[i]=0;

        mat[i]=-1;

        for(int j=1;j<=N;j++)

            lx[i]=max(lx[i],w[i][j]);

    }

    for(int i=1;i<=N;i++){

        while(1){

            for(int j=1;j<=N;j++){

                flagx[j]=flagy[j]=false;

                slack[j]=inf;

            }

            if(dfs(i))

                break;

            int d=inf;

            for(int j=1;j<=N;j++)

                if(!flagy[j])

                    d=min(d,slack[j]);

            for(int j=1;j<=N;j++){

                if(flagx[j])

                    lx[j]-=d;

                if(flagy[j])

                    ly[j]+=d;

            }

        }

    }

}

    

int main()

{

    int t,u,v;

    scanf("%d",&t);

    while(t--){

        scanf("%d%d",&n,&m);

        init();

        for(int i=1;i<n;i++){

            scanf("%d%d%d",&u,&v,c+i);

            addedge(u,v,i);

            addedge(v,u,i);

        }

        memset(w,0,sizeof(w));

        for(int i=n;i<=m;i++){

            scanf("%d%d%d",&u,&v,c+i);

            memset(flag,false,sizeof(flag));

            find(u,v,i);

        }

        N=max(n-1,m-n+1);

        km();

        for(int i=1;i<=m;i++)

            printf("%d\n",i<n?c[i]-lx[i]:c[i]+ly[i-n+1]);

    }

    return 0;

}