LCP 4. 覆盖

题目链接

题解：

我们可以对棋盘进行黑白染色，使得任意相邻的两个格子颜色不相同，然后进行二分图最大匹配。

 Code:

class Solution {
public:
    int N;
    int M;

    vector<vector<int>> dir{{1,0},{0,1},{-1,0},{0,-1}};

    int domino(int n, int m, vector<vector<int>>& broken) {
        N=n;
        M=m;
        vector<vector<int>> grid(N*M,vector<int>(N*M,0));
        vector<int> bro(N*M,0);
        for(auto b:broken){
            bro[b[0]*M+b[1]]=1;
        }
        for(int i=0;i<N*M;++i){
            if(bro[i]) continue;
            int x=i/M;
            int y=i%M;
            if((x+y)%2!=0) continue;
            for(int d=0;d<4;++d){
                int nx=x+dir[d][0];
                int ny=y+dir[d][1];
                if(nx<0 || nx>=N || ny<0 || ny>=M || bro[nx*M+ny]) continue;
                grid[i][nx*M+ny]=1;
            }
        }
        vector<int> mat(N*M,-1);
        int res=0;
        for(int i=0;i<N*M;++i){
            if(bro[i]) continue;
            int x=i/M;
            int y=i%M;
            if((x+y)%2==0){
                vector<int> visited(N*M,0);
                if(dfs(i,grid,visited, mat)){
                    res++;
                }
            }
        }
        return res;
    }

    bool dfs(int u, vector<vector<int>> &grid, vector<int> &visited, vector<int> &mat){
        for(int i=0;i<M*N;++i){
            if(grid[u][i]){
                if(!visited[i]){
                    visited[i]=1;
                    if(mat[i]==-1 || dfs(mat[i],grid,visited,mat)){
                        mat[i]=u;
                        return true;
                    }
                }
            }
        }
        return false;
    }
};

用最大流做：

class Solution {
public:
    int N;
    int M;
    int S;
    int T;
    vector<vector<int>> dir{{1,0},{0,1},{-1,0},{0,-1}};

    int domino(int n, int m, vector<vector<int>>& broken) {
        N=n;
        M=m;
        S=M*N;
        T=M*N+1;
        vector<vector<int>> grid(N*M+3,vector<int>(N*M+3,0)); //残余容量
        vector<int> bro(N*M,0);
        for(auto b:broken){
            bro[b[0]*M+b[1]]=1;
        }
        for(int i=0;i<N*M;++i){
            if(bro[i]) continue;
            int x=i/M;
            int y=i%M;
            if((x+y)%2!=0){
                grid[i][T]=1;
                continue;
            }
            grid[S][i]=1;
            for(int d=0;d<4;++d){
                int nx=x+dir[d][0];
                int ny=y+dir[d][1];
                if(nx<0 || nx>=N || ny<0 || ny>=M || bro[nx*M+ny]) continue;
                grid[i][nx*M+ny]=1;
            }
        }
        int res=0;
        
        while(true){
            vector<int> pre(N*M+3,-1);
            bfs(grid,pre);
            
            if(pre[T]==-1) break;
            int minflow=INT_MAX;
            int v=T;
            while(true){
                int u=pre[v];
                minflow=min(minflow,grid[u][v]);
                if(u==S) break;
                v=u;
            }
            v=T;
            while(true){
                int u=pre[v];
                grid[u][v]-=minflow;
                grid[v][u]+=minflow;
                if(u==S) break;
                v=u;
            }
            res+=minflow;
        }

        return res;
    }

    void bfs(vector<vector<int>> &grid, vector<int> &pre){
        queue<int> q;
        vector<int> visited(N*M+3,0);
        visited[S]=1;
        q.push(S);
        while(!q.empty()){
            int cur=q.front();
            q.pop();
            if(cur==T) break;
            for(int i=0;i<N*M+3;++i){
                if(grid[cur][i]>0 && visited[i]==0){
                    visited[i]=1;
                    q.push(i);
                    pre[i]=cur;
                }
            }
        }
    }
};

状压DP:

class Solution {
public:
    int M;
    int N;
    int domino(int n, int m, vector<vector<int>>& broken) {
        M=n;
        N=m;
        vector<int> b(n,0);
        for(auto bro:broken){
            b[bro[0]]|=(1<<bro[1]);
        }
        
        vector<vector<int>> dp(n,vector<int>(1<<(N+N),-1));
        return dfs(0,dp,b,0);
    }

    int dfs(int state, vector<vector<int>> &dp, vector<int> &b, int row){
        if(dp[row][state]!=-1) return dp[row][state];
        int res=0;
        for(int j=0;j<N-1;++j){
            if(((1<<j)&b[row])==0 && ((1<<(j+1))&b[row])==0 && ((1<<j)&state)==0 && ((1<<(j+1))&state)==0){
                int ns=state|(1<<j)|(1<<(j+1));
                res=max(res,1+dfs(ns,dp,b,row));
            }
        }
        if(row+1<M){
            for(int j=0;j<N;++j){
                if(((1<<j)&b[row])==0 && ((1<<j)&b[row+1])==0 && ((1<<j)&state)==0 && ((1<<(j+N))&state)==0 ){
                    int ns=state|(1<<j)|(1<<(j+N));
                    res=max(res,1+dfs(ns,dp,b,row));
                }
            }

            int ns=state>>N;
            
            res=max(res,dfs(ns,dp,b,row+1));
        }
        return dp[row][state]=res;
    }
};