HDU-2255 奔小康赚大钱 裸KM

                                                                         奔小康赚大钱

Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 2474    Accepted Submission(s): 1087

Problem Description

传说在遥远的地方有一个非常富裕的村落,有一天,村长决定进行制度改革：重新分配房子。
这可是一件大事,关系到人民的住房问题啊。村里共有n间房间,刚好有n家老百姓,考虑到每家都要有房住（如果有老百姓没房子住的话，容易引起不安定因素），每家必须分配到一间房子且只能得到一间房子。
另一方面,村长和另外的村领导希望得到最大的效益,这样村里的机构才会有钱.由于老百姓都比较富裕,他们都能对每一间房子在他们的经济范围内出一定的价格,比如有3间房子,一家老百姓可以对第一间出10万,对第2间出2万,对第3间出20万.(当然是在他们的经济范围内).现在这个问题就是村领导怎样分配房子才能使收入最大.(村民即使有钱购买一间房子但不一定能买到,要看村领导分配的).

 

Input

输入数据包含多组测试用例，每组数据的第一行输入n,表示房子的数量(也是老百姓家的数量)，接下来有n行,每行n个数表示第i个村名对第j间房出的价格(n<=300)。

 

Output

请对每组数据输出最大的收入值，每组的输出占一行。

 

Sample Input

2100 1015 23

 

Sample Output

123

 

Source

HDOJ 2008 Summer Exercise（4）- Buffet Dinner

 

Recommend

lcy

 

引用理论：

对于这里给出 一：基本概念 二：算法原理和语言描述 三：结合图形理解KM算法过程

一.

首先给出一些摘要知识点以及算法的语言描述(如果前面看过前辈们的，只是对于算法过程不了解的可以直接看后面结合图形的算法详细解说，这里归纳个人觉得对于一个小白学习有用的知识点)

首先

KM算法的正确性基于以下定理：

若由二分图中所有满足A[ i ]+B[j]=w[i,j]的边(i,j)构成的子图（称做相等子图）有完备匹配，那么这个完备匹配就是二分图的最大权匹配。

1. 完备匹配：如下图，设G＝<V₁，V₂，E>为二部图，|V₁|≤|V₂|，M为G中一个最大匹配，且|M|＝|V₁|，则称M为V₁到V₂的完备匹配。

那么对于V1的点都有与之对应的匹配，就是完备匹配(就是完全把V1的点都匹配完)

2. 可行顶标：对于左边的点设 lx[MAX] 数组， 对于右边的点设 ly[MAX] 数组，Vi,j 表示 vi 到 vj 的权值(这里的原因是为了求解最优完备匹配，可以在下面理解)

3. 相等子图：相等子图为完备匹配中所有的匹配(就是全部的V1的点，和与之匹配的V2中的点)，但是对于边就只包含lx[i] + ly[j] =  V(i,j)的边

4.最优完备匹配：那么这个就是我们的目的啦，对于上面说的完备匹配之下要求最优，那么结合相等子图来就有若由二分图中所有满足A[i]+B[j]=w[i,j]的边(i,j)构成的相等子图有完备匹配，那么这个完备匹配就是二分图的最大权匹配。

这个定理是显然的。因为对于二分图的任意一个匹配，如果它包含于相等子图，那么它的边权和等于所有顶点的顶标和；如果它有的边不包含于相等子图，那么它的边权和小于所有顶点的顶标和。所以相等子图的完备匹配一定是二分图的最大权匹配。

5. 交错树：这里是在对V1中的一个顶点进行匹配的时候所标记过得V1、V2的点和与之的连线，形成的一个像树装的图

二：

那么在了解了以上的基本概念之后，就来接触KM算法

1.首先基本的原理：该算法是通过给每个顶点一个标号（叫做顶标）来把求最大权匹配的问题转化为求完备匹配的问题的。设顶点V1的顶标为lx[ i ]，V2顶点的顶标为ly[ j ]，顶点V1的 i 与V2的 j 之间的边权为V[i,j]。在算法执行过程中的任一时刻，对于任一条边(i,j)，lx[ i ]+ly[j]>=V[i,j]始终成立。

2.基本流程：

(1).初始时为了使lx[ i ]+ly[j]>=V[i,j]恒成立，将V1的点的标号记为与其相连边的最大边权值，V2的点标号全记为0

(2)用匈牙利算法在相等子图寻找完备匹配 

(3)若未找到完备匹配则修改可行顶标的值 ，扩充相等子图
(4)重复(2)(3)直到找到相等子图的完备匹配为止

3.这里值得注意的是找完备匹配不难理解，主要是进行可行顶标的修改扩充相等子图，有：

引用：朴素的实现方法，时间复杂度为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。

引用：如果当前的相等子图没有完备匹配，就按下面的方法修改顶标以使扩大相等子图，直到相等子图具有完备匹配为止。

我们求当前相等子图的完备匹配失败了，是因为对于某个V1顶点，我们找不到一条从它出发的交错路。这时我们获得了一棵交错树，它的叶子结点全部是V1顶点。现在我们把交错树中V1顶点的顶标全都减小某个值d，V2顶点的顶标全都增加同一个值d，那么我们会发现：

1）两端都在交错树中的边(i,j)，lx[ i ]+ly[j]的值没有变化。也就是说，它原来属于相等子图，现在仍属于相等子图。

2）两端都不在交错树中的边(i,j)，lx[ i ]和ly[j]都没有变化。也就是说，它原来属于（或不属于）相等子图，现在仍属于（或不属于）相等子图。

3）V1端不在交错树中，V2端在交错树中的边(i,j)，它的lx[ i ]+ly[j]的值有所增大。它原来不属于相等子图，现在仍不属于相等子图。

4）V1端在交错树中，V2端不在交错树中的边(i,j)，它的lx[ i ]+ly[j]的值有所减小。也就说，它原来不属于相等子图，现在可能进入了相等子图，因而使相等子图得到了扩大。

-----------------------------------------------------------------------------------------------------------------------

三：那么这里我们 就结合图形来理解扩充相等子图以及KM的算法过程

(可以结合模板代码看)

这里结合hdu2255：如果对应有案例

3

2 1 1

3 2 1

1 1 1

首先给出以下图：（V1，V2，V[i,j]）v[i,j]表示边的权值

那么首先就是进行V1中的1的匹配，得下图 (INF表示无穷大)

用红色的边代表匹配，这里对于V1的1能顺利一次匹配成功，就没有更改vis 的一些值，(小小的偷懒)，那么下面就要对V1的2号顶点进行匹配，那么此过程中我们，我们首先考虑V2的1号点，发现它被V1的1号匹配了，那么就先把V1的1号赶走去和V2其他的几个点尝试匹配，并且在这个过程中我们会修改上图如下：

对于这一次匹配的过程中我们发现形成了一个上面说的交错树，那么对于V1的2号匹配失败之后我们就开始了修改顶标并扩充相等子图的操作，(注意此过程我们找出了 lx[i]+ly[j]-V[i,j] 的最小存于slack中，我们扩充的过程中找一次找到最小的即可)

那么首先我们要找不在交叉树中的V2的 j 点中slack[j]最小的 为 d=1

那么修改之后再一次匹配之前如下图：

那么我们发现lx[1]+ly[1]-V[1,1]没有变，lx[2]+ly[1]-V[2,1]也没有变，但是我们可以发现其他的lx[1]与lx[2]与其他的ly的和减小啦，那么V1的2号再次匹配的过程的时候就在考虑V2的1号的时候，发现V2的1号匹配者V1的1号可以去匹配V2的2号，这里就是扩充了一条边，那么这里就匹配成如下图：

那么下面还有一个V1的顶点3，这个看起来可能第一感觉会说，直接匹配V2的3就是的，但是实际上KM的算法过程不是那么简单的，那么我们来一步步的模拟，首先，我们V1的3号去尝试匹配V2的1号，发现lx[3]+ly[1]-V[3,1]=1，那么匹配失败，更新如下图：

那么V1的3号就再考虑V2的2，此时有lx[3]+ly[2]-V[3,2]=0,但是发现V2的2早被V1的1匹配了(link[2]=1)，那么根据匈牙利算法，把V1的1赶走去尝试与V2的其他点匹配，那么此时我们先关注V1的1，现在它可以考虑V2的1号，发现lx[1]+ly[1]-V[1,1]=0,但是此时V2的1号被V1的2号匹配啦(link[1]=2)，那么同样根据匈牙利算法，把V1的2号赶走，那么此时如下图：(注意红的色部分的值变化)

那么在此图的基础上，我们把关注V1的2号，发现只有V2的3号没有访问过，那么尝试匹配发现lx[2]+ly[3]-V[2,3]=1,匹配失败，那么V1的2号无处可去，回溯到被赶走的V1的1号，它发现赶不走V2的1的匹配者，那么就自己再找V2中别的人匹配，发现V2的2号被访问过啦，那么就找V2的3，此时发现能匹配，那么自己马上占领这里，那么此时就再回溯到V1的3，因为它把占领V2-2号的人赶到V2-1去了，所以自己就占领这里，那么如下图：

对于KM算法自己的通俗理解与代码详解：

注：KM算法：就是在匈牙利基础上加了 权值 的束缚！

那么，为了达到权值和最大 ，或者 最小，就不能简单的去算最多的边数。

步骤：（以HDU2255 例题为例）

1.首先要找到所有居民愿意花钱最多的 那个房子。

题目中用到lx,ly数组，是为了同时调节两个数组，使得权值和最大。

或者说当要松弛的时候使得 本来最大的矛盾权值和 尽可能的损失小一些来得到 满足条件的最大权值和！

2.（lx[x]+ly[y]-w[x][y]=0）条件下进行匈牙利算法。

lx[x]+ly[y]-w[x][y]这个条件十分巧妙:（算法精髓）

1.即可以只让指定居民 找到 它愿意付最多钱的房子。

2.又可以在发生多居民抢一个房子时，用它来得到该居民到其它房子的松弛量！（即该居民到其它房子 比 到这个用钱最多的房子 愿意花的钱数上差的值。）

那么我们就要把 发生矛盾的居民到 其它房子的松弛量  的最小值求出来。再用它去松弛，就可以让原本矛盾的最大权值和，损失最小而得到满足条件的最大权值和！

/*******对于每个居民有4个基本问题：1.这个房子访问过没有？ 2.这个房子能不能满足他的条件 3.这个房子是否被别人住了 4.被别人住了能不能得到调配**********/

转自

http://blog.csdn.net/cklsoft/article/details/8458053

#include<stdio.h>#include<string.h>#include<queue>using namespace std;const int maxn = 305;const int inf = 1<<30;int nx,ny;int map[maxn][maxn];  //邻接矩阵int cx[maxn],cy[maxn];         //保存匹配上的集合bool visx[maxn],visy[maxn];    //记录寻找增广路时点集x，y里的点是否搜索过int lx[maxn],ly[maxn];int Max( int a,int b ){return a>=b?a:b;}bool findpath(int u)               //给x[u]找匹配,这个过程和匈牙利匹配是一样的{visx[u] = 1;for( int v=1; v<=ny; v++ ){if( !visy[v] && lx[u] + ly[v] == map[u][v] ){visy[v] = 1;if( cy[v]==-1 || findpath( cy[v] ) ){cy[v] = u;cx[u] = v;return true;}}}return false;}int KM_perfect_match(){int ans = 0;int slack;memset( cx,-1,sizeof(cx) );memset( cy,-1,sizeof(cy) );memset( lx,0,sizeof(lx) );memset( ly,0,sizeof(ly) );for( int i = 1; i <= nx; i ++ ){for( int j = 1; j <= ny; j ++ ){lx[i] = Max( lx[i],map[i][j] );    //lx[i]为i点权值最大的边}//if( lx[i] == -1 )//return -1;                         //无法匹配}for( int k = 1; k <= nx; k ++ )       //为x里的每一个点找匹配 不断修改顶标，直到找到完备匹配或完美匹配{while(1){memset( visx,0,sizeof(visx) );memset( visy,0,sizeof(visy) );if( cx[k] == -1 && findpath(k) )break;else                            //匹配失败，找最小值{slack = inf;for( int i = 1; i <= nx; i ++ ){if( visx[i] ){for( int j = 1; j <= ny; j ++ ){if( !visy[j] && slack > lx[i] + ly[j] - map[i][j] )slack = lx[i] + ly[j] - map[i][j];}}}for( int i = 1; i <= nx; i ++ ){if( visx[i] )lx[i] -= slack;if( visy[i] )ly[i] += slack;}}}}for( int i = 1; i <= nx; i ++ ) //权值相加              ans += map[cy[i]][i];  return ans;}int main(){while( scanf("%d",&nx) != EOF ){          int ans = 0;ny = nx;         for( int i = 1; i <= nx; i ++ )              for( int j = 1; j <= ny; j ++ )                  scanf("%d", &map[i][j]);                          printf("%d\n", KM_perfect_match() );      }  }