HDU 4185 ——Oil Skimming——————【最大匹配、方格的奇偶性建图】

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn = 660;
const int INF = 0x3f3f3f3f;
vector<int>G[maxn];
int Mx[maxn], My[maxn], dx[maxn], dy[maxn], used[maxn], dis;
char Map[maxn][maxn];
int lis[maxn][maxn];
bool SearchP(int _n){
    queue<int>Q;
    memset(dx,-1,sizeof(dx));
    memset(dy,-1,sizeof(dy));
    int dis = INF;
    for(int i = 1; i <= _n; i++){
        if(Mx[i] == -1){
            dx[i] = 0;
            Q.push(i);
        }
    }
    int v;
    while(!Q.empty()){
        int u = Q.front(); Q.pop();
        if(dx[u] > dis) break;
        for(int i = 0; i < G[u].size(); i++){
            v = G[u][i];
            if(dy[v] == -1){
                dy[v] = dx[u] + 1;
                if(My[v] == -1){
                    dis = dy[v];
                }else{
                    dx[My[v]] = dy[v] + 1;
                    Q.push(My[v]);
                }
            }
        }
    }
    return dis != INF;
}
int dfs(int u){
    int v;
    for(int i = 0; i < G[u].size(); i++){
        v = G[u][i];
        if(!used[v] && dy[v] == dx[u] + 1){
            used[v] = 1;
            if(My[v] != -1 && dy[v] == dis){
                continue;
            }
            if(My[v] == -1 || dfs(My[v])){
                Mx[u] = v;
                My[v] = u;
                return true;
            }
        }
    }
    return false;
}
int MaxMatch(int ln,int rn){
    int ret = 0;
    memset(Mx,-1,sizeof(Mx));
    memset(My,-1,sizeof(My));
    while(SearchP(ln)){
        memset(used,0,sizeof(used));
        for(int i = 1; i <= ln; i++){
            if(Mx[i] == -1 && dfs(i)){
                ret++;
            }
        }
    }
    return ret;
}
int main(){
    int T, cas = 0, n, m, N;
    scanf("%d",&T);
    while(T--){
        n =  m = 0;
        scanf("%d",&N);
        int N2 = N*N;
        for(int i = 0; i <= N2; i++){
            G[i].clear();
        }
        for(int i = 0; i <= N+1; i++){
            Map[i][0] = ‘.‘;
            Map[0][i] = ‘.‘;
            Map[N+1][i] = ‘.‘;
            Map[i][N+1] = ‘.‘;
        }
        for(int i = 1; i<= N; i++){
            getchar();
            for(int j = 1; j <= N; j++){
                scanf("%c",&Map[i][j]);
                if(Map[i][j] == ‘#‘){
                    if((i+j)%2 == 0){
                        ++n;
                        lis[i][j] = n;
                        if(Map[i-1][j] == ‘#‘){
                            G[n].push_back(lis[i-1][j]);
                        }
                        if(Map[i][j-1] == ‘#‘){
                            G[n].push_back(lis[i][j-1]);
                        }
                    }else{
                        ++m;
                        lis[i][j] = m;
                        if(Map[i-1][j] == ‘#‘){
                            G[lis[i-1][j]].push_back(m);
                        }
                        if(Map[i][j-1] == ‘#‘){
                            G[lis[i][j-1]].push_back(m);
                        }
                    }
                }
            }
        }
        int res = MaxMatch(n,m);
        printf("Case %d: %d\n",++cas,res);
    }
    return 0;
}
/*
4
.##.
..#.
.###
....
4
.##.
..#.
.###
..#.

4
.##.
..#.
.###
...#
*/