Asteroids（匈牙利算法入门）

Asteroids

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 16211		Accepted: 8819

Description

Bessie wants to navigate her spaceship through a dangerous asteroid field in the shape of an N x N grid (1 <= N <= 500). The grid contains K asteroids (1 <= K <= 10,000), which are conveniently located at the lattice points of the grid. 

Fortunately, Bessie has a powerful weapon that can vaporize all the asteroids in any given row or column of the grid with a single shot.This weapon is quite expensive, so she wishes to use it sparingly.Given the location of all the asteroids in the field, find the minimum number of shots Bessie needs to fire to eliminate all of the asteroids.

Input

* Line 1: Two integers N and K, separated by a single space. 
* Lines 2..K+1: Each line contains two space-separated integers R and C (1 <= R, C <= N) denoting the row and column coordinates of an asteroid, respectively.

Output

* Line 1: The integer representing the minimum number of times Bessie must shoot.

Sample Input

3 4
1 1
1 3
2 2
3 2

Sample Output

2

Hint

INPUT DETAILS: 
The following diagram represents the data, where "X" is an asteroid and "." is empty space: 
X.X 
.X. 
.X. 

OUTPUT DETAILS: 
Bessie may fire across row 1 to destroy the asteroids at (1,1) and (1,3), and then she may fire down column 2 to destroy the asteroids at (2,2) and (3,2).

Source

USACO 2005 November Gold

#include<stdio.h>
#include<string.h>
const int M = 510 ;
bool map[M][M] ;
int girl[M] ;
bool sta[M] ;
int n , m;

bool hungary (int x)
{
    for (int i = 1 ; i <= n ; i++) {
        if (map[x][i] && sta[i] == false) {
            sta[i] = true ;
            if (girl[i] == 0 || hungary (girl[i])) {
                girl[i] = x ;
                return true ;
            }
        }
    }
    return false ;
}

int main ()
{
   // freopen ("a.txt" , "r" , stdin) ;
    while (~ scanf ("%d%d" , &n , &m)) {
        int x , y , k = 0 ;
        memset (map , 0 , sizeof(map)) ;
        memset (girl , 0 , sizeof(girl)) ;
        for (int i = 0 ; i < m ; i++) {
            scanf ("%d%d" , &x , &y) ;
            map[x][y] = 1 ;
        }
        int all = 0 ;
        for (int i = 1 ; i <= n ; i++) {
            memset (sta , 0 , sizeof(sta)) ;
            if (hungary (i))
                all++ ;
        }
        printf ("%d\n" , all) ;
    }
    return 0 ;
}

 最小覆盖点 = 最大搭配数 。（匈牙利就是求最大搭配数）

#include<bits/stdc++.h>
using namespace std;
const int M = 5000 ;
int n ;
bool vis[M] ;
int from[M] ;
vector<int> g[M] ;
int tot ;

bool match (int u) {
    for (int i = 0 ; i < g[u].size () ; i ++) {
        int v = g[u][i] ;
        if (!vis[v] ) {
            vis[v] = 1 ;
            if (from[v] == -1 || match (from[v] ) ) {
                from[v] = u ;
                return true ;
            }
        }
    }
    return false ;
}

int hungary () {
    memset (from , -1 , sizeof(from )) ;
    for (int i = 1 ; i <= n ; i ++) {
        memset (vis , 0 , sizeof(vis)) ;
        if (match (i) ) 
               tot ++ ;
    }
    return tot ;
}    

 

补充定义和定理：

最大匹配数：最大匹配的匹配边的数目

最小点覆盖数：选取最少的点，使任意一条边至少有一个端点被选择

最大独立数：选取最多的点，使任意所选两点均不相连

最小路径覆盖数：对于一个 DAG（有向无环图），选取最少条路径，使得每个顶点属于且仅属于一条路径。路径长可以为 0（即单个点）。

定理1：最大匹配数 = 最小点覆盖数（这是 Konig 定理）

定理2：最大匹配数 = 最大独立数

定理3：最小路径覆盖数 = 顶点数 - 最大匹配数

推荐：http://www.renfei.org/blog/bipartite-matching.html