hdu 2448最短路+最佳匹配

 先说一说最佳匹配吧，最佳匹配本属于最大流。带权的二分图，要么求最小权的完全匹配，要么求最大权的完全匹配，具体化问题：分工问题如下：某公司有工作人员x1,x2,...,xn,他们去做工作y1,y2,...,yn,每人适合做其中的一项或几项工作，每个人做不同的工作的效益不一样，我们需要制定一个分工方案，使公司的总效益最大，这就是所谓最佳分配问题。

这里我们就要用到一个算法叫Kuhn-Munkres算法。

 （转）KM算法是通过给每个顶点一个标号（叫做顶标）来把求最大权匹配的问题转化为求完备匹配的问题的。设顶点Xi的顶标为A[i]，顶点Yi的顶标为B [i]，顶点Xi与Yj之间的边权为w[i,j]。在算法执行过程中的任一时刻，对于任一条边(i,j)，A[i]+B[j]>=w[i,j]始终 成立。KM算法的正确性基于以下定理： 
　　若由二分图中所有满足A[i]+B[j]=w[i,j]的边(i,j)构成的子图（称做相等子图）有完备匹配，那么这个完备匹配就是二分图的最大权匹配。 
　　这个定理是显然的。因为对于二分图的任意一个匹配，如果它包含于相等子图，那么它的边权和等于所有顶点的顶标和；如果它有的边不包含于相等子图，那么它的边权和小于所有顶点的顶标和。所以相等子图的完备匹配一定是二分图的最大权匹配。 
　　初始时为了使A[i]+B[j]>=w[i,j]恒成立，令A[i]为所有与顶点Xi关联的边的最大权，B[j]=0。如果当前的相等子图没有完备匹配，就按下面的方法修改顶标以使扩大相等子图，直到相等子图具有完备匹配为止。 
　　我们求当前相等子图的完备匹配失败了，是因为对于某个X顶点，我们找不到一条从它出发的交错路。这时我们获得了一棵交错树，它的叶子结点全部是X顶点。现在我们把交错树中X顶点的顶标全都减小某个值d，Y顶点的顶标全都增加同一个值d，那么我们会发现： 
两端都在交错树中的边(i,j)，A[i]+B[j]的值没有变化。也就是说，它原来属于相等子图，现在仍属于相等子图。 
两端都不在交错树中的边(i,j)，A[i]和B[j]都没有变化。也就是说，它原来属于（或不属于）相等子图，现在仍属于（或不属于）相等子图。 
X端不在交错树中，Y端在交错树中的边(i,j)，它的A[i]+B[j]的值有所增大。它原来不属于相等子图，现在仍不属于相等子图。 
X端在交错树中，Y端不在交错树中的边(i,j)，它的A[i]+B[j]的值有所减小。也就说，它原来不属于相等子图，现在可能进入了相等子图，因而使相等子图得到了扩大。 
　　现在的问题就是求d值了。为了使A[i]+B[j]>=w[i,j]始终成立，且至少有一条边进入相等子图，d应该等于min{A[i]+B[j]-w[i,j]|Xi在交错树中，Yi不在交错树中}。 
　　以上就是KM算法的基本思路。但是朴素的实现方法，时间复杂度为O(n4)——需要找O(n)次增广路，每次增广最多需要修改O(n)次顶 标，每次修改顶标时由于要枚举边来求d值，复杂度为O(n2)。实际上KM算法的复杂度是可以做到O(n3)的。我们给每个Y顶点一个“松弛量”函数 slack，每次开始找增广路时初始化为无穷大。在寻找增广路的过程中，检查边(i,j)时，如果它不在相等子图中，则让slack[j]变成原值与A [i]+B[j]-w[i,j]的较小值。这样，在修改顶标时，取所有不在交错树中的Y顶点的slack值中的最小值作为d值即可。但还要注意一点：修改 顶标后，要把所有的slack值都减去d。

也可以看看http://hi.baidu.com/lyc5305562/item/fbd2819a544350d81f4271ab

hdu2448可以作为学习最佳匹配的入门题。

题意：给定n个港口，m个矿点，有n条船，每个港口可以放一条船，因为矿点的人要坐船到最近的港口休息，船只能是从矿点到矿点，或是矿点到港口。

思路：因为是n条船，n个港口，每个港口只放一条船，说明是完全匹配，又要路径最短，说明是最佳匹配，也说明要先求最短路，可以看出港口与港口之间是无向图，而港口与矿点之间是有向图。

#include<iostream>
using namespace std;
const int N=309;
const int inf=1<<28;
int map[N][N];
int lx[N],ly[N],fa[N],visx[N],visy[N],sta[N];
int nx,ny,n,m;
int Min[N][N];
int pt[N];
void floyd(int n)
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
            Min[i][j]=map[i][j];
    }
        for(int k=1;k<=n;k++)
        {
            for(int i=1;i<=n;i++)
                for(int j=1;j<=n;j++)
                    if(Min[i][j]>Min[i][k]+Min[k][j])
                        Min[i][j]=Min[i][k]+Min[k][j];
        }
}
void build()//建二分图
{
    nx=ny=n;//因为船是n，港口是n
    int i,j;
    for( i=1;i<=n;i++)
        for(j=1;j<=n;j++)
        {
            map[i][j]=Min[pt[i]][j];//船所在的矿点，到任意一个港口的距离
            map[i][j]*=-1;//把图取反，求最小权
        }
}
int min_(int a,int b)
{
    if(a<b)return a;
    return b;
}
bool find(int u)//匈牙利算法
{
    visx[u]=1;
    for(int v=1;v<=ny;v++)
    {
        if(!visy[v])
        {
            int w=lx[u]+ly[v]-map[u][v];
            if(!w)
            {
                visy[v]=1;
                if(fa[v]==-1||find(fa[v]))
                {
                    fa[v]=u;
                    return true;
                }
            }else if(w<sta[v])//用这个数组可以降低复杂度
                sta[v]=w;
                
                
        }
    }
    return false;
}
void KM()
{
    int i,j;
    for(i=1;i<=nx;i++)
    {
        lx[i]=-1*inf;
        for(j=1;j<=ny;j++)
        {
            if(map[i][j]>lx[i])
                lx[i]=map[i][j];//Ai把顶标初始最大权
        }
    }
    memset(ly,0,sizeof(ly));//Bi顶标初始0
    memset(fa,-1,sizeof(fa));
    for(i=1;i<=nx;i++)
    {
        for(j=0;j<=n+m;j++)
            sta[j]=inf;    
        while(1)
        {
            int d=inf;
            memset(visx,0,sizeof(visx));
            memset(visy,0,sizeof(visy));
            if(find(i)) break;
            for(j=1;j<=ny;j++)
                if(!visy[j])
                    d=min_(sta[j],d);
                for(j=1;j<=nx;j++)
                    if(visx[j])
                        lx[j]-=d;//所有访问过的Ai顶标减去最小值
                    for(j=1;j<=ny;j++)
                    {
                        if(visy[j])
                            ly[j]+=d;//所有访问过的Bi顶标加上最小值
                        sta[j]-=d;
                    }
        }
    }
}
int main()
{
    int k,p,i,j,a,b,c;
    while(scanf("%d%d%d%d",&n,&m,&k,&p)!=EOF)
    {
        for(i=1;i<=n;i++)
        {
            scanf("%d",&pt[i]);
            pt[i]+=n;
        }
        for(i=0;i<=n+m;i++)
        {
            for(j=0;j<=n+m;j++)
                map[i][j]=inf;
        }
        for(i=1;i<=k;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            a+=n;
            b+=n;
            if(c<map[a][b])
                map[a][b]=map[b][a]=c;
        }
        for(i=1;i<=p;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            b+=n;
            if(c<map[b][a])
                map[b][a]=c;
        }
        floyd(n+m);
        build();
        KM();
        int sum=0;
        for(i=1;i<=nx;i++)
        {
            if(fa[i]!=-1)
            {
                sum+=-1*map[fa[i]][i];//最后要把最小权取反
            }
        }
        printf("%d\n",sum);
        
    }
    return 0;
}