算法问题实战策略 Bishops 二分匹配

地址 https://algospot.com/judge/problem/read/BISHOPS

 

 

 

 

 

 

解答 使用二分匹配

 

 

// 11111.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <vector>
#include <string>
#include <memory.h>


using namespace std;

const int MAX_N = 64, MAX_M = 64;

//A B中的顶点个数
int n, m;

//adj[i][j] =Ai和Bj是否 相连
bool adj[MAX_N][MAX_M];

//保存与各顶点匹配的相应顶点的序号
vector<int> aMatch, bMatch;

//dfs()访问与否
vector<bool> visited;

//找出从A中顶点a连接到B中尚未匹配的顶点的路径
bool dfs(int a) {
    if (visited[a]) return false;
    visited[a] = true;
    for (int b = 0; b < m; ++b) {
        if (adj[a][b]) {
            //b尚未匹配时 从bMatch[b]起始寻找 增广路径
            if (bMatch[b] == -1 || dfs(bMatch[b])) {
                //发现增广路径 把 a和b互相匹配
                aMatch[a] = b;
                bMatch[b] = a;
                return true;
            }//if (bMatch[b] == -1 || dfs(bMatch[b])) {
        }//if (adj[a][b]) {
    }

    return false;
}


//计算aMatch与bMatch后返回最大匹配的大小
int bipartiteMatch() {
    //所有顶点起始均未连接
    aMatch = vector<int>(n, -1);
    bMatch = vector<int>(m, -1);

    int size = 0;
    for (int start = 0; start < n; ++start) {
        visited = vector<bool>(n, false);
        //利用深度优先搜索找出从start起始的增广路径
        if (dfs(start))
            ++size;
    }
    return size;
}


//=================================================
const int dx[2] = { -1,1 };
const int dy[2] = { 1,1 };

vector<string> board;

int id[2][8][8];

int placeBishops() {
    memset(id, -1, sizeof id);
    int count[2] = { 0,0 };
    for (int dir = 0; dir < 2; ++dir) {
        for (int y = 0; y < board.size(); ++y) {
            for (int x = 0; x < board.size(); ++x) {
                if (board[y][x] == '.' && id[dir][y][x] == -1) {
                    int cy = y, cx = x;
                    while (0 <= cy && cy < board.size() &&
                        0 <= cx && cx < board.size() &&
                        board[cy][cx] == '.') {
                        id[dir][cy][cx] = count[dir];
                        cy += dy[dir];
                        cx += dx[dir];
                    }
                    count[dir]++;
                }
            }
        }
    }

    n = count[0];
    m = count[1];
    memset(adj, 0, sizeof adj);
    for (int y = 0; y < board.size(); ++y) {
        for (int x = 0; x < board.size(); ++x) {
            if (board[y][x] == '.')
                adj[id[0][y][x]][id[1][y][x]] = 1;
        }
    }

    return bipartiteMatch();
}

vector<int> ans;
int main()
{
    int a,b;
    cin >> a;

    while (a--) {
        cin >> b;
        board.clear();
        for (int i = 0; i < b; i++) {
            string s;
            cin >> s;
            board.push_back(s);
        }

        ans.push_back(placeBishops());
    }

    for (auto & e : ans) {
        cout << e << endl;
    }
}

/*
.....
.....
.....
.....
.....
*/

 

#include <iostream>
#include <vector>
#include <memory.h>
#include <string>


using namespace std;
/*
3
5
.....
.....
.....
.....
.....
8
..**.*.*
**.***.*
*.**...*
.*.**.**
*.**.*.*
..**.*.*
...*.*.*
**.*.*.*
8
*.*.*.*.
.*.*.*.*
*.*.*.*.
.*.*.*.*
*.*.*.*.
.*.*.*.*
*.*.*.*.
.*.*.*.*
예제 출력
8
18
7
*/

const int MAX_N = 70;


//adj[i][j] =Ai和Bj是否 相连
bool adj[MAX_N][MAX_N];

vector<string> board;
string s;

int t; int ans;
int m, n;

int id[2][MAX_N][MAX_N];

vector<int> aMatch, bMatch;

vector<bool> visited;


bool dfs(int a)
{
    if (visited[a]) return false;

    visited[a] = true;

    for (int b = 1; b <= n; b++) {
        if (adj[a][b]) {
            //b尚未匹配时 从bMatch[b]起始寻找 增广路径
            if (bMatch[b] == -1 || dfs(bMatch[b])) {
                aMatch[a] = b;
                bMatch[b] = a;
                return true;
            }
        }
    }

    return false;
}


int MaxMatch()
{
    //所有顶点起始均未连接
    aMatch = vector<int>(m + 1, -1);
    bMatch = vector<int>(n + 1, -1);

    int size = 0;

    for (int start = 1; start <= m; ++start) {
        visited = vector<bool>(m + 1, false);
        if (dfs(start))
            ++size;
    }

    return size;
}

int PlaceRobot()
{
    memset(id, -1, sizeof id);
    int count[2] = { 0 };
    int dir = 0;
    //0左斜  1右斜

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < m; j++) {
            if (board[i][j] == '.' && id[dir][i][j] == -1) {
                count[dir]++;
                int ci = i; int cj = j;
                while (ci >= 0 && ci < m && cj >= 0 && cj < m && board[ci][cj] == '.') {
                    id[dir][ci][cj] = count[dir];
                    ci += 1; cj += -1;
                }
            }
        }
    }

    dir = 1;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < m; j++) {
            if (board[i][j] == '.' && id[dir][i][j] == -1) {
                count[dir]++;
                int ci = i; int cj = j;
                while (ci >= 0 && ci < m && cj >= 0 && cj < m && board[ci][cj] == '.') {
                    id[dir][ci][cj] = count[dir];
                    ci += 1; cj += 1;
                }
            }
        }
    }

    m = count[0]; n = count[1];
    memset(adj, 0, sizeof adj);

    for (int i = 0; i < board.size(); i++) {
        for (int j = 0; j < board[0].size(); j++) {
            if (board[i][j] == '.') {
                adj[id[0][i][j]][id[1][i][j]] = 1;
            }
        }
    }

    return MaxMatch();
}

int main()
{
    cin >> t;
    vector<int> v;
    for (int k = 1; k <= t; k++) {
        cin >> m;
        n = m;
        board.clear();
        for (int i = 0; i < m; i++) {
            cin >> s;
            board.push_back(s);
        }

        v.push_back(PlaceRobot());
    }

    for (auto e : v) {
        cout << e << endl;
    }

    return 0;
}