二分圖 KM演算法（求二分圖帶權值的最大匹配）
阿新 • • 發佈：2019-01-05
先說KM演算法求二分圖的最佳匹配思想，再詳講KM的實現。
【KM演算法求二分圖的最佳匹配思想】
對於具有二部劃分( V1, V2 )的加權完全二分圖，其中 V1= { x1, x2, x3, ... , xn }， V2= { y1, y2, y3, ... , yn }，邊< xi, yj >具有權值 Wi,j 。該帶權二分圖中一個總權值最大的完美匹配，稱之為最佳匹配。
記 L(x) 表示結點 x 的標記量，如果對於二部圖中的任何邊<x,y>，都有 L(x)+ L(y)>= Wx,y，我們稱 L 為二部圖的可行頂標。
設 G(V,E) 為二部圖， G'(V,E') 為二部圖的子圖。如果對於 G' 中的任何邊<x,y> 滿足， L(x)+ L(y)== Wx,y，我們稱 G'(V,E') 為 G(V,E) 的等價子圖。
定理一：設 L 是二部圖 G 的可行頂標。若 L 等價子圖 GL 有完美匹配 M，則 M 是 G 的最佳匹配。
證明：由於 GL 是 G 的等價子圖，M 是 GL 的完美匹配，所以，M 也是 G 的完美匹配。以由於對於匹配 M 的每條邊 e ，都有 e∈ E( GL )，而且 M 中每條邊覆蓋每個頂點正好一次，所以
W( M )= å W(e), e∈ M = å L(x), x∈ V
另一方面，對於 G 的任何完美匹配 M' 有
W( M' )= å W(e), e∈ M' <= å L(x), x∈ V
於是 W( M )>= W( M' )，即 M 是 G 的最優匹配。
由上述定理，我們可以通過來不斷修改可行頂標，得到等價子圖，從而求出最佳匹配。
就像匈牙利演算法一樣，我們依次為每一個頂點 i 尋找增廣路徑，如果尋找增廣路徑失敗，我們就修改相應的可行頂標，來得到增廣路徑。
如圖：
| 1 2 3 |
| 3 2 4 |
| 2 3 5 |
若要對這個完全二分圖求最佳匹配
初始化：
Lx(1)= max{ y| w(1,y), 1<= y<= 3 }= max{ 1, 2, 3 }= 3, Ly(1)= 0
Lx(2)= max{ 3, 2, 4 }= 4, Ly(2)= 0
Lx(3)= max{ 2, 3, 5 }= 5, Ly(3)= 0;
我們建立等價子圖( 滿足 Lx(x)+ Ly(y)== W(x,y) ) 如下：
km演算法求二分圖最佳匹配
對於該圖，運用匈牙利演算法對 X 部頂點 1 求增廣路徑，得到一個匹配，如圖( 紅色代表匹配邊 )：km演算法求二分圖最佳匹配
對 X 部頂點 2 求增廣路徑失敗，尋找增廣路徑的過程為 X 2-> Y 3-> X 1。我們把尋找增廣路徑失敗的 DFS 的交錯樹中，在 X 部頂點集稱之為 S， 在 Y 部的頂點集稱之為 T。則 S= { 1, 2 }，T= { 3 }。現在我們就通過修改頂標值來擴大等價子圖，如何修改。
1) 我們尋找一個 d 值，使得 d= min{ (x,y)| Lx(x)+ Ly(y)- W(x,y), x∈ S, y∉ T }，因些，這時 d= min{
Lx(1)+Ly(1)-W(1,1), Lx(1)+Ly(2)-W(1,2), Lx(2)+Ly(1)-W(2,1), Lx(2)+Ly(2)-W(2,2) }=
min{ 3+0- 1, 3+0-2, 4+0-3, 4+0-2 }= min{ 2, 1, 1, 2 }= 1。
尋找最小的 d 是為了保證修改後仍滿足性質對於邊 <x,y> 有 Lx(x)+ Ly(y)>= W(x,y)。
2) 然後對於頂點 x
1. 如果 x∈ S 則 Lx(x)= Lx(x)- d。
2. 如果 x∈ T 則 Ly(x)= Ly(x)+ d。
3. 其它情況保持不變。
如此修改後，我們發現對於邊<x,y>，頂標 Lx(x)+ Ly(y) 的值為
1. Lx(x)- d+ Ly(y)+ d， x∈ S, y∈ T。
2. Lx(x)+ Ly(y)， x∉ S, y∉ T。
3. Lx(x)- d+ Ly(y)， x∈ S, y∉ T。
4. Lx(x)+ Ly(y)+ d， x∉ S, y∈ T。
易知，修改後對於任何邊仍滿足 Lx(x)+ Ly(y)>= W(x,y)，並且第三種情況頂標值減少了 d，如此定會使等價子圖擴大。
就上例而言: 修改後 Lx(1)= 2, Lx(2)= 3, Lx(3)= 5, Ly(1)= 0, Ly(1)= 0, Ly(2)= 0, Ly(3)= 1。
這時 Lx(2)+Ly(1)=3+0=3= W(2,1)，在等價子圖中增加了一條邊，等價子圖變為：
km演算法求二分圖最佳匹配
如此按以上方法，得到等價子圖的完美匹配。
另外計算 d 值的時候可以進行一些優化。
定義 slack(y)= min{ (x,y)| Lx(x)+ Ly(y)- W(x,y)，x∈ S, y∉ T }
這樣能在尋找增廣路徑的時候就順便將 slack 求出。
（以上為摘上網路）
【KM演算法及其具體過程】
（1）可行點標：每個點有一個標號，記lx[i]為X方點i的標號，ly[j]為Y方點j的標號。如果對於圖中的任意邊(i, j, W)都有lx[i]+ly[j]>=W，則這一組點標是可行的。特別地，對於lx[i]+ly[j]=W的邊(i, j, W)，稱為可行邊；
（2）KM 演算法的核心思想就是通過修改某些點的標號（但要滿足點標始終是可行的），不斷增加圖中的可行邊總數，直到圖中存在僅由可行邊組成的完全匹配為止，此時這個 匹配一定是最佳的（因為由可行點標的的定義，圖中的任意一個完全匹配，其邊權總和均不大於所有點的標號之和，而僅由可行邊組成的完全匹配的邊權總和等於所 有點的標號之和，故這個匹配是最佳的）。一開始，求出每個點的初始標號：lx[i]=max{e.W|e.x=i}（即每個X方點的初始標號為與這個X方 點相關聯的權值最大的邊的權值），ly[j]=0（即每個Y方點的初始標號為0）。這個初始點標顯然是可行的，並且，與任意一個X方點關聯的邊中至少有一條可行邊；
（3）然後，從每個X方點開始DFS增廣。DFS增廣的過程與最大匹配的Hungary演算法基本相同，只是要注意兩點：一是隻找可行邊，二是要把搜尋過程中遍歷到的X方點全部記下來（可以用vst搞一下），以進行後面的修改；
（4） 增廣的結果有兩種：若成功（找到了增廣軌），則該點增廣完成，進入下一個點的增廣。若失敗（沒有找到增廣軌），則需要改變一些點的標號，使得圖中可行邊的 數量增加。方法為：將所有在增廣軌中（就是在增廣過程中遍歷到）的X方點的標號全部減去一個常數d，所有在增廣軌中的Y方點的標號全部加上一個常數d，則 對於圖中的任意一條邊(i, j, W)（i為X方點，j為Y方點）：
<1>i和j都在增廣軌中：此時邊(i, j)的(lx[i]+ly[j])值不變，也就是這條邊的可行性不變（原來是可行邊則現在仍是，原來不是則現在仍不是）；
<2>i在增廣軌中而j不在：此時邊(i, j)的(lx[i]+ly[j])的值減少了d，也就是原來這條邊不是可行邊（否則j就會被遍歷到了），而現在可能是；
<3>j在增廣軌中而i不在：此時邊(i, j)的(lx[i]+ly[j])的值增加了d，也就是原來這條邊不是可行邊（若這條邊是可行邊，則在遍歷到j時會緊接著執行DFS(i)，此時i就會被遍歷到），現在仍不是；
<4>i和j都不在增廣軌中：此時邊(i, j)的(lx[i]+ly[j])值不變，也就是這條邊的可行性不變。
這 樣，在進行了這一步修改操作後，圖中原來的可行邊仍可行，而原來不可行的邊現在則可能變為可行邊。那麼d的值應取多少？顯然，整個點標不能失去可行性，也 就是對於上述的第<2>類邊，其lx[i]+ly[j]>=W這一性質不能被改變，故取所有第<2>類邊的 (lx[i]+ly[j]-W)的最小值作為d值即可。這樣一方面可以保證點標的可行性，另一方面，經過這一步後，圖中至少會增加一條可行邊。
（5）修改後，繼續對這個X方點DFS增廣，若還失敗則繼續修改，直到成功為止；
（6）以上就是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值即可。但還要注意一點：修 改頂標後，要把所有不在交錯樹中的Y頂點的slack值都減去d。
【求二分圖的最小匹配】
只需把權值取反，變為負的，再用KM算出最大權匹配，取反則為其最小權匹配。
hdoj 2255
#include <stdio.h>
#include <string.h>
#define M 310
#define inf 0x3f3f3f3f
int n,nx,ny;
int link[M],lx[M],ly[M],slack[M]; //lx,ly為頂標，nx,ny分別為x點集y點集的個數
int visx[M],visy[M],w[M][M];
int DFS(int x)
{
visx[x] = 1;
for (int y = 1;y <= ny;y ++)
{
if (visy[y])
continue;
int t = lx[x] + ly[y] - w[x][y];
if (t == 0) //
{
visy[y] = 1;
if (link[y] == -1||DFS(link[y]))
{
link[y] = x;
return 1;
}
}
else if (slack[y] > t) //不在相等子圖中slack 取最小的
slack[y] = t;
}
return 0;
}
int KM()
{
int i,j;
memset (link,-1,sizeof(link));
memset (ly,0,sizeof(ly));
for (i = 1;i <= nx;i ++) //lx初始化為與它關聯邊中最大的
for (j = 1,lx[i] = -inf;j <= ny;j ++)
if (w[i][j] > lx[i])
lx[i] = w[i][j];
for (int x = 1;x <= nx;x ++)
{
for (i = 1;i <= ny;i ++)
slack[i] = inf;
while (1)
{
memset (visx,0,sizeof(visx));
memset (visy,0,sizeof(visy));
if (DFS(x)) //若成功（找到了增廣軌），則該點增廣完成，進入下一個點的增廣
break; //若失敗（沒有找到增廣軌），則需要改變一些點的標號，使得圖中可行邊的數量增加。
//方法為：將所有在增廣軌中（就是在增廣過程中遍歷到）的X方點的標號全部減去一個常數d，
//所有在增廣軌中的Y方點的標號全部加上一個常數d
int d = inf;
for (i = 1;i <= ny;i ++)
if (!visy[i]&&d > slack[i])
d = slack[i];
for (i = 1;i <= nx;i ++)
if (visx[i])
lx[i] -= d;
for (i = 1;i <= ny;i ++) //修改頂標後，要把所有不在交錯樹中的Y頂點的slack值都減去d
if (visy[i])
ly[i] += d;
else
slack[i] -= d;
}
}
int res = 0;
for (i = 1;i <= ny;i ++)
if (link[i] > -1)
res += w[link[i]][i];
return res;
}
int main ()
{
int i,j;
while (scanf ("%d",&n)!=EOF)
{
nx = ny = n;
// memset (w,0,sizeof(w));
for (i = 1;i <= n;i ++)
for (j = 1;j <= n;j ++)
scanf ("%d",&w[i][j]);
int ans = KM();
printf ("%d\n",ans);
}
return 0;
}
【KM演算法求二分圖的最佳匹配思想】
對於具有二部劃分( V1, V2 )的加權完全二分圖，其中 V1= { x1, x2, x3, ... , xn }， V2= { y1, y2, y3, ... , yn }，邊< xi, yj >具有權值 Wi,j 。該帶權二分圖中一個總權值最大的完美匹配，稱之為最佳匹配。
記 L(x) 表示結點 x 的標記量，如果對於二部圖中的任何邊<x,y>，都有 L(x)+ L(y)>= Wx,y，我們稱 L 為二部圖的可行頂標。
設 G(V,E) 為二部圖， G'(V,E') 為二部圖的子圖。如果對於 G' 中的任何邊<x,y> 滿足， L(x)+ L(y)== Wx,y，我們稱 G'(V,E') 為 G(V,E) 的等價子圖。
定理一：設 L 是二部圖 G 的可行頂標。若 L 等價子圖 GL 有完美匹配 M，則 M 是 G 的最佳匹配。
證明：由於 GL 是 G 的等價子圖，M 是 GL 的完美匹配，所以，M 也是 G 的完美匹配。以由於對於匹配 M 的每條邊 e ，都有 e∈ E( GL )，而且 M 中每條邊覆蓋每個頂點正好一次，所以
W( M )= å W(e), e∈ M = å L(x), x∈ V
另一方面，對於 G 的任何完美匹配 M' 有
W( M' )= å W(e), e∈ M' <= å L(x), x∈ V
於是 W( M )>= W( M' )，即 M 是 G 的最優匹配。
由上述定理，我們可以通過來不斷修改可行頂標，得到等價子圖，從而求出最佳匹配。
就像匈牙利演算法一樣，我們依次為每一個頂點 i 尋找增廣路徑，如果尋找增廣路徑失敗，我們就修改相應的可行頂標，來得到增廣路徑。
如圖：
| 1 2 3 |
| 3 2 4 |
| 2 3 5 |
若要對這個完全二分圖求最佳匹配
初始化：
Lx(1)= max{ y| w(1,y), 1<= y<= 3 }= max{ 1, 2, 3 }= 3, Ly(1)= 0
Lx(2)= max{ 3, 2, 4 }= 4, Ly(2)= 0
Lx(3)= max{ 2, 3, 5 }= 5, Ly(3)= 0;
我們建立等價子圖( 滿足 Lx(x)+ Ly(y)== W(x,y) ) 如下：
km演算法求二分圖最佳匹配
對於該圖，運用匈牙利演算法對 X 部頂點 1 求增廣路徑，得到一個匹配，如圖( 紅色代表匹配邊 )：km演算法求二分圖最佳匹配
對 X 部頂點 2 求增廣路徑失敗，尋找增廣路徑的過程為 X 2-> Y 3-> X 1。我們把尋找增廣路徑失敗的 DFS 的交錯樹中，在 X 部頂點集稱之為 S， 在 Y 部的頂點集稱之為 T。則 S= { 1, 2 }，T= { 3 }。現在我們就通過修改頂標值來擴大等價子圖，如何修改。
1) 我們尋找一個 d 值，使得 d= min{ (x,y)| Lx(x)+ Ly(y)- W(x,y), x∈ S, y∉ T }，因些，這時 d= min{
Lx(1)+Ly(1)-W(1,1), Lx(1)+Ly(2)-W(1,2), Lx(2)+Ly(1)-W(2,1), Lx(2)+Ly(2)-W(2,2) }=
min{ 3+0- 1, 3+0-2, 4+0-3, 4+0-2 }= min{ 2, 1, 1, 2 }= 1。
尋找最小的 d 是為了保證修改後仍滿足性質對於邊 <x,y> 有 Lx(x)+ Ly(y)>= W(x,y)。
2) 然後對於頂點 x
1. 如果 x∈ S 則 Lx(x)= Lx(x)- d。
2. 如果 x∈ T 則 Ly(x)= Ly(x)+ d。
3. 其它情況保持不變。
如此修改後，我們發現對於邊<x,y>，頂標 Lx(x)+ Ly(y) 的值為
1. Lx(x)- d+ Ly(y)+ d， x∈ S, y∈ T。
2. Lx(x)+ Ly(y)， x∉ S, y∉ T。
3. Lx(x)- d+ Ly(y)， x∈ S, y∉ T。
4. Lx(x)+ Ly(y)+ d， x∉ S, y∈ T。
易知，修改後對於任何邊仍滿足 Lx(x)+ Ly(y)>= W(x,y)，並且第三種情況頂標值減少了 d，如此定會使等價子圖擴大。
就上例而言: 修改後 Lx(1)= 2, Lx(2)= 3, Lx(3)= 5, Ly(1)= 0, Ly(1)= 0, Ly(2)= 0, Ly(3)= 1。
這時 Lx(2)+Ly(1)=3+0=3= W(2,1)，在等價子圖中增加了一條邊，等價子圖變為：
km演算法求二分圖最佳匹配
如此按以上方法，得到等價子圖的完美匹配。
另外計算 d 值的時候可以進行一些優化。
定義 slack(y)= min{ (x,y)| Lx(x)+ Ly(y)- W(x,y)，x∈ S, y∉ T }
這樣能在尋找增廣路徑的時候就順便將 slack 求出。
（以上為摘上網路）
【KM演算法及其具體過程】
（1）可行點標：每個點有一個標號，記lx[i]為X方點i的標號，ly[j]為Y方點j的標號。如果對於圖中的任意邊(i, j, W)都有lx[i]+ly[j]>=W，則這一組點標是可行的。特別地，對於lx[i]+ly[j]=W的邊(i, j, W)，稱為可行邊；
（2）KM 演算法的核心思想就是通過修改某些點的標號（但要滿足點標始終是可行的），不斷增加圖中的可行邊總數，直到圖中存在僅由可行邊組成的完全匹配為止，此時這個 匹配一定是最佳的（因為由可行點標的的定義，圖中的任意一個完全匹配，其邊權總和均不大於所有點的標號之和，而僅由可行邊組成的完全匹配的邊權總和等於所 有點的標號之和，故這個匹配是最佳的）。一開始，求出每個點的初始標號：lx[i]=max{e.W|e.x=i}（即每個X方點的初始標號為與這個X方 點相關聯的權值最大的邊的權值），ly[j]=0（即每個Y方點的初始標號為0）。這個初始點標顯然是可行的，並且，與任意一個X方點關聯的邊中至少有一條可行邊；
（3）然後，從每個X方點開始DFS增廣。DFS增廣的過程與最大匹配的Hungary演算法基本相同，只是要注意兩點：一是隻找可行邊，二是要把搜尋過程中遍歷到的X方點全部記下來（可以用vst搞一下），以進行後面的修改；
（4） 增廣的結果有兩種：若成功（找到了增廣軌），則該點增廣完成，進入下一個點的增廣。若失敗（沒有找到增廣軌），則需要改變一些點的標號，使得圖中可行邊的 數量增加。方法為：將所有在增廣軌中（就是在增廣過程中遍歷到）的X方點的標號全部減去一個常數d，所有在增廣軌中的Y方點的標號全部加上一個常數d，則 對於圖中的任意一條邊(i, j, W)（i為X方點，j為Y方點）：
<1>i和j都在增廣軌中：此時邊(i, j)的(lx[i]+ly[j])值不變，也就是這條邊的可行性不變（原來是可行邊則現在仍是，原來不是則現在仍不是）；
<2>i在增廣軌中而j不在：此時邊(i, j)的(lx[i]+ly[j])的值減少了d，也就是原來這條邊不是可行邊（否則j就會被遍歷到了），而現在可能是；
<3>j在增廣軌中而i不在：此時邊(i, j)的(lx[i]+ly[j])的值增加了d，也就是原來這條邊不是可行邊（若這條邊是可行邊，則在遍歷到j時會緊接著執行DFS(i)，此時i就會被遍歷到），現在仍不是；
<4>i和j都不在增廣軌中：此時邊(i, j)的(lx[i]+ly[j])值不變，也就是這條邊的可行性不變。
這 樣，在進行了這一步修改操作後，圖中原來的可行邊仍可行，而原來不可行的邊現在則可能變為可行邊。那麼d的值應取多少？顯然，整個點標不能失去可行性，也 就是對於上述的第<2>類邊，其lx[i]+ly[j]>=W這一性質不能被改變，故取所有第<2>類邊的 (lx[i]+ly[j]-W)的最小值作為d值即可。這樣一方面可以保證點標的可行性，另一方面，經過這一步後，圖中至少會增加一條可行邊。
（5）修改後，繼續對這個X方點DFS增廣，若還失敗則繼續修改，直到成功為止；
（6）以上就是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值即可。但還要注意一點：修 改頂標後，要把所有不在交錯樹中的Y頂點的slack值都減去d。
【求二分圖的最小匹配】
只需把權值取反，變為負的，再用KM算出最大權匹配，取反則為其最小權匹配。
hdoj 2255
#include <stdio.h>
#include <string.h>
#define M 310
#define inf 0x3f3f3f3f
int n,nx,ny;
int link[M],lx[M],ly[M],slack[M]; //lx,ly為頂標，nx,ny分別為x點集y點集的個數
int visx[M],visy[M],w[M][M];
int DFS(int x)
{
visx[x] = 1;
for (int y = 1;y <= ny;y ++)
{
if (visy[y])
continue;
int t = lx[x] + ly[y] - w[x][y];
if (t == 0) //
{
visy[y] = 1;
if (link[y] == -1||DFS(link[y]))
{
link[y] = x;
return 1;
}
}
else if (slack[y] > t) //不在相等子圖中slack 取最小的
slack[y] = t;
}
return 0;
}
int KM()
{
int i,j;
memset (link,-1,sizeof(link));
memset (ly,0,sizeof(ly));
for (i = 1;i <= nx;i ++) //lx初始化為與它關聯邊中最大的
for (j = 1,lx[i] = -inf;j <= ny;j ++)
if (w[i][j] > lx[i])
lx[i] = w[i][j];
for (int x = 1;x <= nx;x ++)
{
for (i = 1;i <= ny;i ++)
slack[i] = inf;
while (1)
{
memset (visx,0,sizeof(visx));
memset (visy,0,sizeof(visy));
if (DFS(x)) //若成功（找到了增廣軌），則該點增廣完成，進入下一個點的增廣
break; //若失敗（沒有找到增廣軌），則需要改變一些點的標號，使得圖中可行邊的數量增加。
//方法為：將所有在增廣軌中（就是在增廣過程中遍歷到）的X方點的標號全部減去一個常數d，
//所有在增廣軌中的Y方點的標號全部加上一個常數d
int d = inf;
for (i = 1;i <= ny;i ++)
if (!visy[i]&&d > slack[i])
d = slack[i];
for (i = 1;i <= nx;i ++)
if (visx[i])
lx[i] -= d;
for (i = 1;i <= ny;i ++) //修改頂標後，要把所有不在交錯樹中的Y頂點的slack值都減去d
if (visy[i])
ly[i] += d;
else
slack[i] -= d;
}
}
int res = 0;
for (i = 1;i <= ny;i ++)
if (link[i] > -1)
res += w[link[i]][i];
return res;
}
int main ()
{
int i,j;
while (scanf ("%d",&n)!=EOF)
{
nx = ny = n;
// memset (w,0,sizeof(w));
for (i = 1;i <= n;i ++)
for (j = 1;j <= n;j ++)
scanf ("%d",&w[i][j]);
int ans = KM();
printf ("%d\n",ans);
}
return 0;
}