POJ 3041 Asteroids（模板——二分最大匹配（BFS增广））

题目链接：

http://poj.org/problem?id=3041

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).

题意描述：

输入矩阵的大小和小行星的个数及坐标

计算并输出至少需要多少颗能量弹消灭掉所有的小行星

解题思路：

首先建立二分图，行和列为两个集合，有小行星的位置存入邻接矩阵为1，使用匈牙利算法，计算二分最大匹配，最后求的最小顶点覆盖。

AC代码：

#include<stdio.h>
#include<string.h>
int n,k,e[510][510],pred[510],queue[250000],cx[510],cy[510];
int maxmatch();
int main()
{
    int i,x,y;
    while(scanf("%d%d",&n,&k) != EOF)
    {
        memset(e,0,sizeof(e));
        for(i=1;i<=k;i++)
        {
            scanf("%d%d",&x,&y);
            e[x][y]=1;
        }
        printf("%d
",maxmatch());//输出最小顶点覆盖数 
    }
    return 0;
}
int maxmatch()
{
    int i,j,y;
    int cur,tail,res=0;
    memset(cx,0xff,sizeof(cx));
    memset(cy,0xff,sizeof(cy));
    
    for(i=1;i<=n;i++)
    {
        if(cx[i] != -1)//找到x集合中每个未盖点i进行一次找交错轨 
        continue;
        
        for(j=1;j<=n;j++)
            pred[j]=-2;//初始化为-2
             
        cur=0;//队列初始化 
        tail=0;
        
        for(j=1;j<=n;j++)//将i的邻接顶点加入队列 
        {
            if(e[i][j])
            {
                pred[j]=-1;//-1表示遍历到，是邻接顶点 
                queue[tail++]=j;
            }
        }
        
        while(cur < tail)//BFS 
        {
            y=queue[cur];
            if(cy[y]==-1)
            break;//找到了一个未匹配的点，则找到了一条交错轨 
            cur++;
            //已经匹配给cy[y]了，从cy[y]出发，将其邻接点加入队列 
            for(j=1;j<=n;j++)
            {
                if(pred[j] == -2 && e[ cy[y ]][j])
                {
                    pred[j]=y;
                    queue[tail++]=j;
                }
            }
        }
        if(cur == tail)//没有找到交错轨 
        continue; 
        
        while(pred[y] > -1)//更改交错轨上的匹配状态 
        {
            cx[ cy[pred[y]] ] = y;
            cy[y]=cy[ pred[y] ];
            y=pred[y];
        }
        cy[y]=i;
        cx[i]=y;
        
        res++;//匹配数加1 
    }
    return res;
}