HDU 5556 Land of Farms 【最大独立点集】

题目链接

题意：N*M的图中有一些旧农场，现在要建立一些新的农场，如果新的农场覆盖了某一个旧的农场中的一个点，它就必须覆盖整个这个旧农场。现在要建立尽可能多的新农场，使得每个新农场之间都不相邻，求最多能建立多少个新农场。

很容易想到最大独立点集这东西，把每个旧农场看成一个点，不是农场的点看成一个点，在相邻的之间建边，求最大独立点集即可。

最大独立点集=补图的最大独立团，因此求出补图的最大独立团。

#include <bits/stdc++.h>
#define maxn 210
using namespace std;

int ans, f[maxn], Set[maxn][maxn], a[maxn][maxn], p[maxn], sz;
int kase = 0;

/**
 * 求最大独立团
 */
bool Solve(int sz, int dep) {
    if (!sz)
        if (dep > ans)
            ans = dep, 1;
        else
            return 0;

    for (int i = 1; i <= sz; i++) {
        if (dep + sz - i + 1 <= ans)
            return 0;
        int u = Set[dep][i];
        if (dep + f[u] <= ans)
            return 0;
        int num = 0;
        for (int j = i + 1; j <= sz; j++)
            if (a[u][Set[dep][j]])
                Set[dep + 1][++num] = Set[dep][j];
        if (Solve(num, dep + 1))
            return 1;
    }
    return 0;
}

int T;
int N, M;
char g[15][15];
int cntp = 0; //记录有多少个点
int belong[15][15];
bool vis[15][15];
int dir_x[] = {0, 1, 0, -1};
int dir_y[] = { -1, 0, 1, 0};
bool jian[500][500];

void dfs(int x, int y, int tmp) {
    belong[x][y] = tmp;
    for (int i = 0; i < 4; i++) {
        int tx = x + dir_x[i];
        int ty = y + dir_y[i];
        if (tx < 1 || tx > N || ty < 1 || ty > M)
            continue;
        if (!vis[tx][ty] && g[tx][ty] == g[x][y]) {
            vis[tx][ty] = true;
            belong[tx][ty] = tmp;
            dfs(tx, ty, tmp);
        }
    }
}

int main() {
    scanf("%d", &T);
    while (T--) {
        scanf("%d %d", &N, &M);
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= M; j++) {
                scanf(" %c", &g[i][j]);
            }
        }
        cntp = 0;
        memset(belong, -1, sizeof(belong));
        memset(vis, false, sizeof(vis));
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= M; j++) {
                if (g[i][j] == '.') {
                    belong[i][j] = ++cntp;
                }
                if (g[i][j] >= '0' && g[i][j] <= '9') {
                    if (belong[i][j] != -1)
                        continue;
                    cntp++;
                    dfs(i, j, cntp);
                }
            }
        }
        // for (int i = 1; i <= N; i++) {
        //     for (int j = 1; j <= M; j++) {
        //         printf("%d ", belong[i][j]);
        //     }
        //     printf("\n");
        // }
        // printf("1\n");
        for (int i = 1; i <= cntp; i++) {
            for (int j = 1; j <= cntp; j++) {
                if (i != j)   a[i][j] = 1;
                else    a[i][j] = 0;
            }
        }
        memset(jian, false, sizeof(jian));
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= M; j++) {
                for (int k = 0; k < 4; k++) {
                    int ti = i + dir_x[k];
                    int tj = j + dir_y[k];
                    if (ti < 1 || ti > N || tj < 1 || tj > M)
                        continue;
                    int t1 = belong[ti][tj];
                    int t2 = belong[i][j];
                    if (t1 == t2) continue;
                    if (!jian[t1][t2] && !jian[t2][t1]) {
                        jian[t1][t2] = true;
                        jian[t2][t1] = true;
                        // addedge(t1, t2);
                        // addedge(t2, t1);
                        a[t1][t2] = 0;
                        a[t2][t1] = 0;
                    }
                }
            }
        }
        // for (int i = 1; i <= cntp; i++) {
        //     for (int j = 1; j <= cntp; j++) {
        //         printf("%d ", a[i][j]);
        //     }
        //     printf("\n");
        // }
        ans = 0;
        for (int i = cntp; i; i--) {
            sz = 0;
            for (int j = i + 1; j <= cntp; j++)
                if (a[i][j])
                    Set[1][++sz] = j;
            Solve(sz, 1);
            f[i] = ans;
        }
        printf("Case #%d: %d\n", ++kase, ans);
    }
    return 0;
}