HDU-2255 奔小康赚大钱

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。

 

引用2：

【最优完备匹配】
对于二分图的每条边都有一个权（非负），要求一种完备匹配方案，使得所有匹配边的权和最大，记做最优完备匹配。（特殊的，当所有边的权为1时，就是最大完备匹配问题）
KM算法：（全称是Kuhn-Munkras，是这两个人在1957年提出的，有趣的是，匈牙利算法是在1965年提出的）
为每个点设立一个顶标Li，先不要去管它的意义。
设vi,j��为(i,j)边的权，如果可以求得一个完备匹配，使得每条匹配边vi,j=Li+Lj，其余边vi,j≤Li+Lj。
此时的解就是最优的，因为匹配边的权和=∑Li，其余任意解的权和都不可能比这个大

定理：二分图中所有vi,j=Li+Lj的边构成一个子图G，用匈牙利算法求G中的最大匹配，如果该匹配是完备匹配，则是最优完备匹配。
（不知道怎么证明）
问题是，现在连Li的意义还不清楚。
其实，我们现在要求的就是L的值，使得在该L值下达到最优完备匹配。

L初始化：
Li=max{wi,j}(i∈x,j∈y)
Lj=0

建立子图G，用匈牙利算法求G的最大匹配，如果在某点i (i∈x)找不到增广轨，则得不到完备匹配。
此时需要对L做一些调整：
设S为寻找从i出发的增广轨时访问的x中的点的集合，T为访问的y中的点的集合。
找到一个改进量dx，dx=min{Li+Lj-wi,j}(i∈S,j不∈T)
Li=Li-dx (i∈S)
Li=Li+dx (i∈T)

重复以上过程，不断的调整L，直到求出完备匹配为止。
从调整过程中可以看出：
每次调整后新子图中在包含原子图中所有的边的基础上添加了一些新边。
每次调整后∑Li会减少dx，由于每次dx取最小，所以保证了解的最优性。

复杂度分析：
设n为点数，m为边数，从每个点出发寻找增广轨的复杂度是O(m)，如果找不到增广轨，对L做调整的复杂度也是O(m)，而一次调整或者找到一条增广轨，或者将两个连通分量合成一个，而这两种情况最多都只进行O(n)次，所以总的复杂度是O(nm)

扩展：
根据KM算法的实质，可以求出使得所有匹配边的权和最小的匹配方案。
L初始化：
Li=min{wi,j}(i∈x,j∈y)
Lj=0
dx=min{wi,j-Li-Lj}(i∈S,j不∈T)
Li=Li+dx (i∈S)
Li=Li-dx (i∈T)

接下来是我的代码：

1. #include<iostream>  
2. #include<algorithm>  
3. #include<cstdio>  
4. #include<cstdlib>  
5. #include<cstring>  
6. #include<queue>  
7. #include<math.h>  
8. #include<climits>  
9. #define MAXN 305  
10. using namespace std;  
11. int map[MAXN][MAXN],lx[MAXN],ly[MAXN],vx[MAXN],vy[MAXN],matchy_x[MAXN];  
12.   
13. bool hungary(int u,int n)  
14. {  
15.     vx[u]=1;  
16.     for(int i=0;i<n;i++)  
17.     {  
18.         if(vy[i] || lx[u]+ly[i]!=map[u][i]) continue;  
19.         vy[i]=1;  
20.         if(matchy_x[i]==-1 || hungary(matchy_x[i],n))  
21.         {  
22.             matchy_x[i]=u;  
23.             return 1;  
24.         }  
25.     }  
26.     return 0;  
27. }  
28.   
29. void EK_match(int n)  
30. {  
31.     memset(matchy_x,-1,sizeof(matchy_x));  
32.     for(int v=0;v<n;v++)  
33.     {  
34.         while(1)//一点能找到一个点和i匹配。  
35.         {  
36.             memset(vx,0,sizeof(vx));  
37.             memset(vy,0,sizeof(vy));  
38.             if(hungary(v,n))  
39.                 break;  
40.             else//和匈牙利的差别大概就是下面。  
41.             {  
42.                 int temp=INT_MAX;  
43.                 for(int i=0;i<n;i++) if(vx[i])  
44.                     for(int j=0;j<n;j++)   
45.                         if(!vy[j] && temp>lx[i]+ly[j]-map[i][j])  
46.                             temp=lx[i]+ly[j]-map[i][j];  
47.                 for(int i=0;i<n;i++)  
48.                 {  
49.                     if(vx[i]) lx[i]-=temp;  
50.                     if(vy[i]) ly[i]+=temp;  
51.                 }  
52.             }  
53.         }  
54.     }  
55. }  
56.   
57. int main()  
58. {  
59.     int i,j,n,m,t,maxx;  
60.     while(~scanf("%d",&n))  
61.     {  
62.         for(i=0;i<n;i++)  
63.         {  
64.             maxx=0;  
65.             for(j=0;j<n;j++)  
66.              {  
67.                  scanf("%d",&t);  
68.                  map[i][j]=t;  
69.                  maxx=t>maxx?t:maxx;  
70.              }  
71.              lx[i]=maxx;  
72.         }  
73.         EK_match(n);  
74.         int ans=0;  
75.         for(i=0;i<n;i++)  
76.              ans+=map[matchy_x[i]][i];  
77.         printf("%d\n",ans);  
78.     }  
79.     return 0;  
80. }  

顺便贴上来自大牛的优化： http://blog.csdn.net/niushuai666/article/details/7171525

1. #include<iostream>  
2. #include<cstdio>  
3. #include<cstring>  
4. #include<climits>  
5. #include<algorithm>  
6. using namespace std;  
7. #define N 310  
8. int map[N][N];  
9. bool visitx[N], visity[N];  
10. int lx[N], ly[N];  
11. int slack[N];  
12. int match[N];  
13. int n;  
14.   
15. int Scan()  
16. {  
17.     int res = 0 , ch ;  
18.     while( !( ( ch = getchar() ) >= '0' && ch <= '9' ) )  
19.     {  
20.         if( ch == EOF )  return 1 << 30 ;  
21.     }  
22.     res = ch - '0' ;  
23.     while( ( ch = getchar() ) >= '0' && ch <= '9' )  
24.         res = res * 10 + ( ch - '0' ) ;  
25.     return res ;  
26. }  
27.   
28. bool Hungary(int u) //匈牙利算法  
29. {  
30.     visitx[u] = true;  
31.     for(int i = 0; i < n; ++i)  
32.     {  
33.         if(visity[i])  
34.             continue;  
35.         if(lx[u] + ly[i] == map[u][i])  
36.         {  
37.             visity[i] = true;  
38.             if(match[i] == -1 || Hungary(match[i]))  
39.             {  
40.                 match[i] = u;  
41.                 return true;  
42.             }  
43.         }  
44.         else //不在相等子图  
45.             slack[i] = min(slack[i], lx[u] + ly[i] - map[u][i]);  
46.     }  
47.     return false;  
48. }  
49.   
50. void KM_perfect_match()  
51. {  
52.     int temp;  
53.     memset(lx, 0, sizeof(lx)); //初始化顶标  
54.     memset(ly, 0, sizeof(ly)); //ly[i]为0  
55.     for(int i = 0; i < n; ++i) //lx[i]为权值最大的边  
56.         for(int j = 0; j < n; ++j)  
57.             lx[i] = max(lx[i], map[i][j]);  
58.     for(int i = 0; i < n; ++i) //对n个点匹配  
59.     {  
60.         for(int j = 0; j < n; ++j)  
61.             slack[j] = INT_MAX;  
62.         while(1)  
63.         {  
64.             memset(visitx, false, sizeof(visitx));  
65.             memset(visity, false, sizeof(visity));  
66.             if(Hungary(i)) //匹配成功  
67.                 break;  
68.             else //匹配失败，找最小值  
69.             {  
70.                 temp = INT_MAX;  
71.                 for(int j = 0; j < n; ++j)  
72.                     if(!visity[j])  
73.                         if(temp > slack[j])  
74.                             temp = slack[j];  
75.                 for(int j = 0; j < n; ++j) //更新顶标  
76.                 {  
77.                     if(visitx[j])  
78.                         lx[j] -= temp;  
79.                     if(visity[j])  
80.                         ly[j] += temp;  
81.                     else  
82.                         slack[j] -= temp;  
83.                 }  
84.             }  
85.         }  
86.     }  
87. }  
88.   
89. int main()  
90. {  
91.     int ans;  
92.     while(scanf("%d", &n) != EOF)  
93.     {  
94.         ans = 0;  
95.         memset(match, -1, sizeof(match));  
96.         for(int i = 0; i < n; ++i)  
97.             for(int j = 0; j < n; ++j)  
98.                 map[i][j] = Scan();  
99.         KM_perfect_match();  
100.         for(int i = 0; i < n; ++i) //权值相加  
101.             ans += map[match[i]][i];  
102.         printf("%d\n", ans);  
103.     }  
104.     return 0;  
105. }