匈牙利算法

你有一块棋盘，棋盘上有一些格子已经坏掉了。你还有无穷块大小为1 * 2的多米诺骨牌，你想把这些骨牌不重叠地覆盖在完好的格子上，请找出你最多能在棋盘上放多少块骨牌？这些骨牌可以横着或者竖着放。

 

输入：n, m代表棋盘的大小；broken是一个b * 2的二维数组，其中每个元素代表棋盘上每一个坏掉的格子的位置。

输出：一个整数，代表最多能在棋盘上放的骨牌数。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/broken-board-dominoes
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 

二分图详解----匈牙利算法+km算法+ Gale-Shapley---婚姻匹配算法算法+例题

网友代码1：

class Solution {
public:
    int dir[4][2] = {-1, 0, 1, 0, 0, 1, 0, -1};
    int n1, m1, match[81]; 
    bool used[81], brok[81]; 
    int domino(int n, int m, vector<vector<int>>& broken) {
        if (broken.empty()) return n * m / 2;
        n1 = n, m1 = m;
        memset(brok, false, sizeof(brok));
        memset(match, -1, sizeof(match));
        for (const auto& b : broken) {
            brok[b[0] * m + b[1]] = true;
        }
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if ((i + j) % 2 || brok[i * m + j]) continue;
                memset(used, false, sizeof(used));
                if (dfs(i, j)) ++ans;
            }
        }
        return ans;
    }
    bool dfs(int x, int y) {
        for (int i = 0; i < 4; ++i) {
            int dx = x + dir[i][0], dy = y + dir[i][1], id = dx * m1 + dy;
            if (dx < 0 || dx >= n1 || dy < 0 || dy >= m1 || brok[id] || used[id]) 
                continue;
            used[id] = true;
            if (match[id] == -1 || dfs(match[id] / m1, match[id] % m1)) {
                match[id] = x * m1 + y;
                return true;
            }
        }
        return false;
    }
};

 

网友代码2：

class Solution {
public:
    vector<int> es[64];
    int md[64],ud[64];
    int d[5]={-1,0,1,0,-1};
    bool dfs(int u){
        if(ud[u]==-1)
        {   ud[u]=1;
            for(int next:es[u]){
            if(md[next]==-1||dfs(md[next]))
                {md[u]=next;md[next]=u;return true;}
        }
        }
        return false;
    }
    int domino(int m, int n, vector<vector<int>>& bk) {
        bool bs[m][n]={};
        for(vector<int>& v:bk)
            bs[v[0]][v[1]]=true;
        for(int i=0;i<m;++i)
            for(int j=0;j<n;++j)
                if(!bs[i][j])
                    for(int k=0;k<4;++k)
                    {
                        int r=i+d[k],c=j+d[k+1];
                        if(r>=0&&r<m&&c>=0&&c<n&&!bs[r][c])
                            es[i*n+j].emplace_back(r*n+c);
                    }
        memset(md,0xff,sizeof md);
        int res=0;
        for(int i=0;i<m;++i)
            for(int j=0;j<n;++j){
                if(!bs[i][j]&&md[i*n+j]==-1)
                {   memset(ud,0xff,sizeof ud);
                    if(dfs(i*n+j))
                        res++;
                }
            }
        return res;
    }
    
};