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
= 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;
}