奔小康赚大钱

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

Problem Description

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

Input

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

Output

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

Sample Input

2 100 10 15 23

Sample Output

123

【分析】

　　只是打一下模版。最佳二分匹配KM算法。

来来上代码：

  1 #include<cstdio>
  2 #include<cstdlib>
  3 #include<cstring>
  4 #include<iostream>
  5 #include<algorithm>
  6 #include<queue>
  7 using namespace std;
  8 #define Maxn 310
  9 #define Maxm 160010
 10 #define INF 0xfffffff
 11 
 12 struct node
 13 {
 14     int x,y,c,next;
 15 }t[Maxm];int len;
 16 int first[Maxn];
 17 
 18 void ins(int x,int y,int c)
 19 {
 20     t[++len].x=x;t[len].y=y;t[len].c=c;
 21     t[len].next=first[x];first[x]=len;
 22 }
 23 
 24 int mymin(int x,int y) {return x<y?x:y;}
 25 int mymax(int x,int y) {return x>y?x:y;}
 26 
 27 int n;
 28 int match[Maxn],lx[Maxn],ly[Maxn];//lx,ly 可行顶标
 29 bool visx[Maxn],visy[Maxn];
 30 int slack[Maxn];
 31 
 32 bool ffind(int x)
 33 {
 34     visx[x]=1;
 35     for(int i=first[x];i;i=t[i].next) if(!visy[t[i].y])
 36     {
 37         int y=t[i].y;
 38         if(t[i].c==lx[x]+ly[y])
 39         {
 40             visy[y]=1;
 41             if(!match[y]||ffind(match[y]))//这里可以理解为有向的增广路，只在一段记录match
 42             {  
 43                 match[y]=x;
 44                 return 1;
 45             }
 46         }
 47         else slack[y]=mymin(slack[y],lx[x]+ly[y]-t[i].c);
 48     }
 49     return 0;
 50 }
 51 
 52 void solve()
 53 {
 54     memset(match,0,sizeof(match));
 55     memset(lx,0,sizeof(lx));
 56     memset(ly,0,sizeof(ly));
 57     for(int i=1;i<=n;i++)
 58      for(int j=first[i];j;j=t[j].next) lx[i]=mymax(lx[i],t[j].c);
 59     
 60     for(int i=1;i<=n;i++)
 61     {
 62         for(int j=1;j<=n;j++)
 63             slack[j]=INF;
 64         while(1)
 65         {
 66             memset(visx,0,sizeof(visx));
 67             memset(visy,0,sizeof(visy));
 68             if(ffind(i)) break;
 69             int delta=INF;
 70             for(int j=1;j<=n;j++)
 71             {
 72                 if(!visy[j])
 73                 {
 74                     delta=mymin(delta,slack[j]);
 75                 }
 76             }
 77             if(delta==INF) return;
 78             for(int j=1;j<=n;j++)
 79             {
 80                 if(visx[j]) lx[j]-=delta;
 81                 if(visy[j]) ly[j]+=delta;
 82                 else slack[j]-=delta;
 83             }
 84         }
 85     }
 86 }
 87 
 88 int main()
 89 {
 90     while(scanf("%d",&n)!=EOF)
 91     {
 92         len=0;
 93         memset(first,0,sizeof(first));
 94         for(int i=1;i<=n;i++)
 95         {
 96             for(int j=1;j<=n;j++)
 97             {
 98                 int x;
 99                 scanf("%d",&x);
100                 ins(i,j,x);
101             }
102         }
103         solve();
104         int ans=0;
105         for(int i=1;i<=n;i++) ans+=lx[i]+ly[i];
106         printf("%d\n",ans);
107     }
108     return 0;
109 }

HDU 2255

基础：

二分图：简单来说，如果图中点可以被分为两组，并且使得所有边都跨越组的边界，则这就是一个二分图。准确地说：把一个图的顶点划分为两个不相交集 U

匹配：在图论中，一个「匹配」（matching）是一个边的集合，其中任意两条边都没有公共顶点。例如，图 3、图 4 中红色的边就是图 2 的匹配。

Bipartite Graph(1) Bipartite Graph(2) Matching Maximum Matching

我们定义匹配点、匹配边、未匹配点、非匹配边，它们的含义非常显然。例如图 3 中 1、4、5、7 为匹配点，其他顶点为未匹配点；1-5、4-7为匹配边，其他边为非匹配边。

最大匹配：一个图所有匹配中，所含匹配边数最多的匹配，称为这个图的最大匹配。图 4 是一个最大匹配，它包含 4 条匹配边。

完美匹配：如果一个图的某个匹配中，所有的顶点都是匹配点，那么它就是一个完美匹配。图 4 是一个完美匹配。显然，完美匹配一定是最大匹配（完美匹配的任何一个点都已经匹配，添加一条新的匹配边一定会与已有的匹配边冲突）。但并非每个图都存在完美匹配。

举例来说：如下图所示，如果在某一对男孩和女孩之间存在相连的边，就意味着他们彼此喜欢。是否可能让所有男孩和女孩两两配对，使得每对儿都互相喜欢呢？图论中，这就是完美匹配问题。如果换一个说法：最多有多少互相喜欢的男孩/女孩可以配对儿？这就是最大匹配问题。

基本概念讲完了。求解最大匹配问题的一个算法是匈牙利算法，下面讲的概念都为这个算法服务。

交替路：从一个未匹配点出发，依次经过非匹配边、匹配边、非匹配边…形成的路径叫交替路。

增广路：从一个未匹配点出发，走交替路，如果途径另一个未匹配点（出发的点不算），则这条交替路称为增广路（agumenting path）。例如，图 5 中的一条增广路如图 6 所示（图中的匹配点均用红色标出）：

增广路有一个重要特点：非匹配边比匹配边多一条。因此，研究增广路的意义是改进匹配。只要把增广路中的匹配边和非匹配边的身份交换即可。由于中间的匹配节点不存在其他相连的匹配边，所以这样做不会破坏匹配的性质。交换后，图中的匹配边数目比原来多了 1 条。

我们可以通过不停地找增广路来增加匹配中的匹配边和匹配点。找不到增广路时，达到最大匹配（这是增广路定理）。匈牙利算法正是这么做的。在给出匈牙利算法 DFS 和 BFS 版本的代码之前，先讲一下匈牙利树。

匈牙利树一般由 BFS 构造（类似于 BFS 树）。从一个未匹配点出发运行 BFS（唯一的限制是，必须走交替路），直到不能再扩展为止。例如，由图 7，可以得到如图 8 的一棵 BFS 树：

这棵树存在一个叶子节点为非匹配点（7 号），但是匈牙利树要求所有叶子节点均为匹配点，因此这不是一棵匈牙利树。如果原图中根本不含 7 号节点，那么从 2 号节点出发就会得到一棵匈牙利树。这种情况如图 9 所示（顺便说一句，图 8 中根节点 2 到非匹配叶子节点 7 显然是一条增广路，沿这条增广路扩充后将得到一个完美匹配）。

KM算法（最佳完美匹配）

二分图的最佳完美匹配

如果二分图的每条边都有一个权（可以是负数），要求一种完备匹配方案，使得所有匹配边的权和最大，记做最佳完美匹配。（特殊的，当所有边的权为1时，就是最大完备匹配问题）
我们使用KM算法解决该问题。

KM（Kuhn and Munkres）算法，是对匈牙利算法的一种贪心扩展，如果对匈牙利算法还不够明白，建议先重新回顾一下匈牙利算法。

KM是对匈牙利算法的一种贪心扩展，这种贪心不是对边的权值的贪心，算法发明者引入了一些新的概念，从而完成了这种扩展。

可行顶标

对于原图中的任意一个结点，给定一个函数

l x (x) + l y (y) >= w e i g h t (x, y)

相等子图

相等子图是原图的一个生成子图（生成子图即包含原图的所有结点，但是不包含所有的边）,并且该生成子图中只包含满足

l x (x) + l y (y) = w e i g h t (x, y)

的边,这样的边我们称之为可行边。

算法原理

定理：如果原图的一个相等子图中包含完备匹配，那么这个匹配就是原图的最佳二分图匹配。
证明：由于算法中一直保持顶标的可行性，所以任意一个匹配的权值之和肯定小于等于所有结点的顶标之和，则相等子图中的完备匹配肯定是最优匹配。

这就是为什么我们要引入可行顶标和相等子图的概念。
上面的证明可能太过抽象，我们结合图示更直观的表述。

该图表示原图，且

对于原图的任意一个匹配

这里写图片描述

那么对于

都满足

l x (x) + l y (y) >= w e i g h t (x, y)

所以

\sum i = 1 x i \in X l x (x i) + \sum i = 1 y i \in Y l y (y i) = K >= \sum

可以看出，一个匹配中的边权之和最大为

那么很显然，当一个匹配

如果对于每一条边

l x (x i) + l y (y i) == w e i g h t (x i, y i)

那么

\sum i = 1 x i \in X l x (x i) + \sum i = 1 y i \in Y l y (y i) = K = \sum

相等子图的完备匹配（完美匹配）即满足上述条件（因为相等子图的每条边都是可行边，可行边满足

KM的算法流程

流程

Kuhn－Munkras算法（即KM算法）流程：

初始化可行顶标的值 (设定lx,ly的初始值)
用匈牙利算法寻找相等子图的完备匹配
若未找到增广路则修改可行顶标的值
重复(2)(3)直到找到相等子图的完备匹配为止

KM算法的核心部分即控制修改可行顶标的策略使得最终可到达一个完美匹配。

初始时，设定
当相等子图中不包含完备匹配的时候（也就是说还有增广路），就适当修改顶标。直到找到完备匹配为止。（整个过程在匈牙利算法中执行）

现在我们的问题是，遵循什么样的原则去修改顶标的值？

对于正在增广的增广路径上属于集合

为什么要这样做呢，我们来分析一下：
对于图中任意一条边

　　1、如果i和j都属于增广路,那么lx[i]−delta+ly[j]−+delta=lx[i]+ly[j]值不变，也就说edge(i,j)可行性不变，原来是相等子图的边就还是，原来不是仍然不是
　　2、如果i属于增广路，j不属于增广路,那么lx[i]−delta+ly[j]的值减小,也就是原来这条边不在相等子图中(否则j就会被遍历到了)，现在可能就会加入到相等子图。
　　3、如果i不属于增广路，j属于增广路,那么lx[i]+ly[j]+delta的值增大，也就是说原来这条边不在相等子图中(否则j就会被遍历到了)，现在还不可能加入到相等子图
　　4、如果i,j都不属于增广路，那么lx[i]和ly[j]都不会加减常数delta值不变,可行性不变

//看成匈牙利树更容易理解。

你每次i++，选一个为匹配的x点进行增广，找到以i为起点的匈牙利树。

如果长这样：

，那么你就找到了增广路，i的工作就完成了，i++即可，不需改变顶标。

否则，你的匈牙利树长这样，

你会把整棵树完整的找一遍。我的意思是，能走到的点的vis值都会标记到的。

上面说的“在增广路上”实际上是“在匈牙利树上”。

解释一下第2、3种情况。

2、若x在匈牙利树上，y不在，说明x->y并非相等子图上的边，不然因为找不到增广路，相等子图上的边我都会遍历一遍，所有点都会打上vis标记。

3、若x不在匈牙利树上，y在，x一定是i后面的点，它的匹配会在后面使其成立，所以可以看成不是相等子图上的边？【其实这个我还觉得有点迷吧。。但是顶标只是增加，所以不会错的。

//有slack的y必定有一条边连向一个打过vis标记的点【看代码这个就明白了】

【以上是个人的傻逼见解啊。。2017-04-25 10:44:23】

这样，在进行了这一步修改操作后，图中原来的可行边仍可行，而原来不可行的边现在则可能变为可行边。那么delta的值应取多少？

观察上述四种情况，只有第二类边(

因为对于每条边都要满足

证明：

d e l t a = M i n (l x [i] + l y [j] - w e i g h t (i, j)) = l x [i] + l y [j] -

l x [i] - d e l t a + l y [j] = l x [i] - l x [i] - l y [i] + M a x (w e i g h t (

下面我们重新回顾一下整个KM算法的流程：

1. 可行顶标：每个点有一个标号，记(
2. KM 算法的核心思想就是通过修改某些点的标号（但要满足点标始终是可行的），不断增加图中的可行边总数，直到图中存在仅由可行边组成的完全匹配为止，此时这个匹配一定是最佳的（证明上文已经给出）
3. 初始化：
4. 从每个
5. 增广的结果有两种：若成功（找到了增广路），则该点增广完成，进入下一个点的增广。若失败（没有找到增广路），则需要改变一些点的标号，使得图中可行边的数量增加。
6. 修改后，继续对这个

下面用图模拟：

初始化标杆使X标杆的值为斜体字的值。
KM算法1
连接每条边并且使得x1和y3匹配，然后遍历x2，发现x2找不到合法增广路。
KM算法2
把不合法路径上的x点都归为点集S,y点都归为T,将不在T中的y点和在S中的点尝试进行加边。
KM算法3
找到两条边，更新顶标之后，成功形成增广路，运用匈牙利算法反选。
KM算法4
给x3找一个合法的增广路，一下就找到了，直接反选，结束。
KM算法5
KM算法6
KM算法7
KM算法8
KM算法9