poj3041 Asteroids（二分图最小顶点覆盖、二分图匹配）

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

 

 

分别以n个行和n个列为结点，建立二分图，每一个星球对应一个连接其所在行和列的边，问题转化为求这个二分图的最小顶点覆盖。

在二分图中，有结论：最小顶点覆盖数=最大匹配数

自己yy了一个证明：

首先，我们证明不存在小于最大匹配数的最小顶点覆盖数。

这是显然的，因为这些顶点根本无法覆盖所有的匹配边。

接下来证明存在等于最大匹配数的最小顶点覆盖数。

首先证明，在最大匹配中，每条匹配边连接的两个顶点a,b最多只有一个与非匹配点有连边。

用反证法：假设a与c，b与d这件都有边，且c，d都不是匹配点，则可以去掉连接a,b的匹配边，加上连接a,c和连接b,d的匹配边，是匹配数+1，这与最大匹配矛盾。

这样，我们构造这样一个顶点集合：对于每条匹配边，选择其连接的两个点中的一个（如果两个点有与非匹配点有连边的点，则选那个点；否则随便选一个）。

这个集合中有最大匹配数个点。

我们证明：这个点集能覆盖所有的边。

若一条边是匹配边，则其显然被覆盖。

若一条边不是匹配边：

1）若其与某匹配顶点有连边，则该匹配顶点必在我们构造的点集中，所以该边被覆盖

2）若其连接着两个非匹配点，则可以增加这条边为匹配边，是匹配数+1，这与最大匹配矛盾，故此情况不成立

所以，这个点集能覆盖所有的边。

综上所述，在二分图中，最小顶点覆盖数=最大匹配数已得到证明。

 program rrr(input,output);
 const
   inf=;
 type
   etype=record
      t,c,rev,next:longint;
   end;
 var
   e:array[..]of etype;
   a,cur,d:array[-..]of longint;
   q:array[..]of longint;
   n,m,i,x,y,h,t,cnt,ans:longint;
 procedure ins(x,y,c:longint);
 begin
    inc(cnt);e[cnt].t:=y;e[cnt].c:=c;e[cnt].next:=a[x];a[x]:=cnt;
 end;
 procedure add(x,y:longint);
 begin
    ins(x,y,);ins(y,x,);
    e[cnt].rev:=cnt-;e[cnt-].rev:=cnt;
 end;
 function min(a,b:longint):longint;
 begin
    if a<b then exit(a) else exit(b);
 end;
 procedure bfs;
 begin
    for i:=-n to n+ do d[i]:=-;
    h:=;t:=;q[]:=;d[]:=;
    while h<t do
       begin
          inc(h);
          i:=a[q[h]];
          while i<>inf do
             begin
                if (d[e[i].t]=-) and (e[i].c>) then
                   begin
                      d[e[i].t]:=d[q[h]]+;
                      inc(t);q[t]:=e[i].t;
                   end;
                i:=e[i].next;
             end;
       end;
 end;
 function dfs(k,f:longint):longint;
 var
   ans,r,i:longint;
 begin
    if (k=n+) or (f=) then exit(f);
    ans:=;i:=cur[k];
    while i<>inf do
       begin
          if (e[i].c>) and (d[e[i].t]=d[k]+) then
             begin
                r:=dfs(e[i].t,min(f,e[i].c));
                dec(e[i].c,r);inc(e[e[i].rev].c,r);
                ans:=ans+r;f:=f-r;
                if f= then break;
             end;
          i:=e[i].next;
          cur[k]:=i;
       end;
    if f> then d[k]:=-;
    exit(ans);
 end;
 begin
    assign(input,'r.in');assign(output,'r.out');reset(input);rewrite(output);
    readln(n,m);
    cnt:=;for i:=-n to n+ do a[i]:=inf;
    for i:= to n do begin add(,-i);add(i,n+); end;
    for i:= to m do begin readln(x,y);add(-x,y); end;
    ans:=;
    while true do
       begin
          bfs;
          if d[n+]=- then break;
          for i:=-n to n+ do cur[i]:=a[i];
          ans:=ans+dfs(,inf);
       end;
    write(ans);
    close(input);close(output);
 end.