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;
}