UVALive 6696 A Generalized N-Queens Problem （最大团算法）

大体题意：

给你一个n*n 的棋盘，有一定量的黑棋（相当于障碍）！，让你放尽可能多的白棋（皇后），使得任意两个白棋不能相互攻击！

思路：

想暴力的，结果也没搞出来！

发现有6ms过得，原来不是暴力！

请教了学长！

可以这样考虑：

对于每一个可以放白棋的地方，把他不能攻击到的地方相连，这样最终会得到一个无向图，两个点能连通代表了两个棋子不能相互吃掉！

最后求一个解使得任意两个棋子都不能相互吃掉！那不就是任意两个点都相互连通吗！

这不就是一个完全图吗！

所以这个问题转换成了求一个最大的完全图的数量！

最大团模板

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 100 + 10;
int g[maxn][maxn];
int List[maxn][maxn];
int len[maxn];
int ans;
bool found;
int n;
int mc[maxn];
const int dx[] = {1,-1,0,0,1,-1,-1,1};
const int dy[] = {0,0,1,-1,1,1,-1,-1};
bool init(int x,int y){
    return x >= 0 && x < n && y < n && y >= 0;
}
void dfs(int Size){
    int i,j,k;
    if (len[Size] == 0){
        if (Size > ans){
            ans = Size;
            found = true;
        }
        return;
    }
    for (k = 0; k < len[Size] && !found; ++k){
        if (Size+len[Size]-k<=ans)
            break;
        i = List[Size][k];
        if (Size+mc[i]<=ans)
            break;
        for (j = k+1, len[Size+1] = 0; j < len[Size]; ++j)
            if (g[i][List[Size][j]])
                List[Size+1][len[Size+1]++] = List[Size][j];
        dfs(Size+1);
    }
}
void max_cluster(){
    int i, j;
    mc[n] = ans = 1;
    for (i=n-1; i; --i){
        found = false;
        len[1] = 0;
        for (j = i+1;j <= n; ++j)
            if (g[i][j])
                List[1][len[1]++] = j;
        dfs(1);
        mc[i] = ans;
    }
}

int id[maxn][maxn];
int vis[maxn][maxn];
int a[maxn][maxn];
int cnt = 0;
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        cnt = 0;
        memset(len,0,sizeof len);
        memset(List,0,sizeof List);
        memset(mc,0,sizeof mc);
        memset(g,0,sizeof g);
        for (int i = 0; i < n; ++i){
            for (int j = 0; j < n; ++j){
                scanf("%d",&a[i][j]);
                id[i][j] = ++cnt;
            }
        }
        for (int i = 0; i < n; ++i){
            for (int j = 0; j < n; ++j){
                if (a[i][j] == 1)continue;
                memset(vis,0,sizeof vis);
                for (int k = 0; k < 8; ++k){
                    for (int l = 1;;++l){
                        int xx = dx[k]*l + i;
                        int yy = dy[k]*l + j;
                        if (!init(xx,yy))break;
                        if (a[xx][yy] == 1)break;
                        vis[xx][yy] = 1;
                    }
                }
                for (int o = 0; o < n; ++o){
                    for (int p = 0; p < n; ++p){
                        if (o == i && p == j)continue;
                        if (vis[o][p] || a[o][p] == 1 || g[id[i][j]][id[o][p]])continue;
                        g[id[i][j]][id[o][p]] = 1;
                        g[id[o][p]][id[i][j]] = 1;
//                        printf("%d - %d\n",id[i][j],id[o][p]);
                    }
                }
            }
        }
        n*=n;
        max_cluster();
        printf("%d\n",ans);

    }
    return 0;
}