POJ-3041-建图/二分图匹配/网络流

Asteroids

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 26351		Accepted: 14254

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

 

　　给出一个N*N的地图，和数个障碍物的位置(i,j) 每次操作可以将某一行或者某一列的障碍物都清楚，问最少的操作次数。

　　每一行/列缩一个点，对于每个(i,j)，就把行i点和列j点连一条边，这样每一条边就对应着一个障碍物，操作转化为选取一个点之后，与这个点相连的边对应的障碍物都将被清除，问最少选出几个点能覆盖所有的边，又二分图中最小点覆盖=最大匹配数，所以就是求一个最大匹配。

　　这个题网络流也能解，按理说复杂度比匈牙利低，建图思路一样，行向列建边容量为1，源点向行点建边，列点向汇点建边跑最大流。

　　按理说树dp也可以求最小点覆盖但是一直WA不知为何= =

　　匈牙利:

#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
using namespace std;
int match[510],N;
bool vis[510];
vector<int>g[510];
int dfs(int u){
    for(int i=0;i<g[u].size();++i){
        if(!vis[g[u][i]]){
            vis[g[u][i]]=1;
            if(match[g[u][i]]==-1||dfs(match[g[u][i]])){
                match[g[u][i]]=u;
                return 1;
            }
        }
    }
    return 0;
}
int main() {
    int t,n,m,i,j;
        scanf("%d%d",&n,&m);
        for(i=1;i<=n;++i)g[i].clear();
        N=n;
        while(m--){
            scanf("%d%d",&i,&j);
            g[i].push_back(j);
        }
    memset(match,-1,sizeof(match));
    int ans=0;
    for(i=1;i<=n;++i){
        memset(vis,0,sizeof(vis));
        ans+=dfs(i);
    }
    cout<<ans<<endl;
    return 0;
}                

dinic:

　　

       
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<cstdlib>
using namespace std;
#define inf 0x3f3f3f3f
struct Edge{
    int v,cap,flow,next;
}e[50050];
int first[1010],tot,N;
int d[1010],cur[1010];
bool vis[1010];
void add(int u,int v,int cap){
    e[tot].v=v;
    e[tot].cap=cap;
    e[tot].flow=0;
    e[tot].next=first[u];
    first[u]=tot++;
}
bool bfs(){
    memset(vis,0,sizeof(vis));
    queue<int>q;
    q.push(0);
    d[0]=0;
    vis[0]=1;
    while(!q.empty()){
        int u=q.front();
        q.pop();
        for(int i=first[u];~i;i=e[i].next){
            if(!vis[e[i].v] && e[i].cap>e[i].flow){
                vis[e[i].v]=1;
                d[e[i].v]=d[u]+1;
                q.push(e[i].v);
            }
        }
    }
    return vis[N*2+1];
}
int dfs(int x,int a){
    if(x==N*2+1 || a==0) return a;
    int flow=0,f;
    for(int &i=cur[x];~i;i=e[i].next){
        if(d[x]+1==d[e[i].v] && (f=dfs(e[i].v,min(a,e[i].cap-e[i].flow)))>0){
            e[i].flow+=f;
            e[i^1].flow-=f;
            flow+=f;
            a-=f;
            if(a==0) break;
        }
    }
    return flow;
}
int solve(){
    int ans=0;
    while(bfs()){
        for(int i=0;i<=N*2+1;++i)cur[i]=first[i];
        ans+=dfs(0,inf);
    }
    return ans;
}
int main(){
    int m,i,j;
    while(cin>>N>>m){
        memset(first,-1,sizeof(first));
        tot=0;
        for(i=1;i<=N;++i){
            add(0,i,1);
            add(i,0,0);
            add(i+N,N*2+1,1);
            add(N*2+1,i+N,0);
        }
        while(m--){
            scanf("%d%d",&i,&j);
            add(i,j+N,1);
            add(j+N,i,0);
        }
        cout<<solve()<<endl;
    }
    return 0;
}