最大团 HDU-1530

　传送门：　洛谷　　Vjudge    (题目略有不同)

题目描述
　　• 给定一个图 tt = (V, E)
　　• 求一个点集 S ,使得对于任意 x ≠ y ∈ S ,x 和 y 都有一条边
　　• |V | ≤ 50
输入格式
　　第一行两个数,n, m 分别表示图的点数、边数。 接下
　　来 m 行,每行两个整数 x, y 表示一条边 x ↔ y 。
输出格式
　　输出最大团的大小以及最大团的数目。
样例输入
　　4 5
　　1 2
　　2 3
　　3 1
　　1 4
　　2 4
样例输出
　　3 2

1. 搜索 　2. BornKerbosch算法 3.取反图求最大独立集 meet in the middle


1. 　DFS　

　　就是从每一个点出发找最大团

　　从u点出发　枚举和u相连的点　check一下它是不是和现在找到的团一起构成完全图　

　　如果是　就继续往下搜　不是　就继续找下一个点

　　最重要的是找相连的点的顺序！！！

　　这一步处理不好的话　既会找到重复的点　而且循环也是没完没了

　　这里的方法是　只要找标号比 u 大的与之相连的点即可

　　这样就有了一定的顺序性　而且也不会遗漏　

　　因为假如最大的完全图中 有 u 还有比 u 小的点 v　

　　即使在搜 u 时搜不到这个图　但是搜此图中标号最小的点时是一定搜得到的

　　但是　这仍然不是最优秀的搜索　还有别的剪枝

　　　　f [i] :从第 i , i+1, i+2 ,…,n 点中选出的最大团所含的点数　

　　　　nw为现在选到的点　st为现在已经选出的点数+1　

　　　　ans1 为最大团点数　ans2 为最大团的数量

　　所谓"正难则反"　我们从 f [n] 求到 f[1]

　　发现 f[i] 最大也只能为 f[i-1]+1

　　所以 if ( st + f [nw+1] <ans1) 就直接 return 了　(最优性剪枝)

　　However  这样子只能过掉HDU-1530 洛谷还是TLE

 

小结一下：　　　　

　　　　搜索的顺序可以解决很多问题啊　

　　　　但是不要乱了　可以把问题一一列举出来　

　　　　每想到一个方案的时候仔细想是不是可以解决这些问题

　　　　想清楚　不要轻易否决了

　　　　多想想要求的量之间的关系　有可能可以用于优化

#include<iostream>
#include<cstdio>
#define go(i,a,b) for(register int i=a;i<=b;i++)
#define yes(i,a,b) for(register int i=a;i>=b;i--)
#define fre(x) freopen("x.in","r",stdin) freopen("x.out","w",stdout)
using namespace std;
int read()
{
    int x=0,y=1;char c=getchar();
    while(c<'0'||c>'9') {if(c=='-') y=-1;c=getchar();}
    while(c>='0'&&c<='9') {x=(x<<1)+(x<<3)+c-'0';c=getchar();}
    return x*y;
}
int n,m,x,y,ans1,ans2;
int tmp[100],f[100];
bool mp[100][100];
bool ck(int x,int y)
{
    go(i,1,y) {if(!mp[x][tmp[i]]) return 0;}
    return 1;
}
int dfs(int nw,int st)
{
    if(st+f[nw+1]<ans1) return ans1; 
    if(st>ans1) {ans1=st;ans2=1;return ans1;}
    else if(st==ans1) ans2++;
    tmp[st]=nw;
    go(i,nw+1,n) {if(ck(i,st)) dfs(i,st+1);}
    return ans1;
}
int main()
{
    //fre(1);
    n=read();m=read();
    go(i,1,m) {x=read();y=read();mp[x][y]=mp[y][x]=1;}
    yes(i,n,1) {f[i]=dfs(i,1);}
    printf("%d %d",ans1,ans2);
    return 0;
}

法1 洛谷 90pts View Code

#include<iostream>
#include<cstdio>
#define go(i,a,b) for(register int i=a;i<=b;i++)
using namespace std;
int read()
{
    int x=0,y=1;char c=getchar();
    while(c<'0'||c>'9') {if(c=='-') y=-1;c=getchar();}
    while(c>='0'&&c<='9') {x=(x<<1)+(x<<3)+c-'0';c=getchar();}
    return x*y;
}
int n,m,x,y,ans1,ans2;
int tmp[100];
bool mp[100][100];
bool ck(int x,int y)
{
    go(i,1,y) {if(!mp[x][tmp[i]]) return 0;}
    return 1;
}
void dfs(int nw,int st)
{
    if(st>ans1) {ans1=st;ans2=1;}
    else if(st==ans1) ans2++;
    tmp[st]=nw;
    go(i,nw+1,n) {if(ck(i,st)) dfs(i,st+1);}
}
int main()
{
    while(n=read())
   {
       if(!n) break ;
       ans1=ans2=0;
       go(i,1,n) go(j,1,n) mp[i][j]=0;
       go(i,1,n) go(j,1,n) mp[i][j]=read();
       go(i,1,n) dfs(i,1);
       printf("%d
",ans1); 
   }
    return 0;
}

 

2. BornKerbosch算法 

 

　　构造两个数组 P R 

　　R 中存进入当前搜索的团中的点

　　P 中存可能进入R中的点

　　初始化 P里为所有元素 R 为空

　　依次把 P 里的数丢进 R里

　　我们现在把 v 放入 R 中 则要把 P 中不与 v 相连的点全都去掉 然后重复此步骤

        递归实现

　　回溯时 R P 三个数组也要回溯成原来的样子

　　为了方便 这三个数组可以设两个维度

　　第一个维度表示现在所在的层数 第二个维度存元素

　　还有一个优化 在同一层中 取了 v 那么就不必要取和 v 相连的点了 

        我的理解是这样的:

　　　　假如 u 与 v 相连 我们取了 v 后不必要取 u 了

　　　　 u 所在的最大团有两种情况 : 1. 包括 v 那么取 v 时一定可以找到这个团

　　　　　　　　　　　　　　　　　2. 不包括v 那么团里一定有别的点不与 v 相连

　　　　　　　　　　　　　　　　　　那么取那个点是一定可以找到这个团

　　　　综上,没有取 u 的必要

//BornKerbosch算法
#include<bits/stdc++.h>
using namespace std;
#define RI register int
#define LL long long
inline int read()
{
    int res=0,f=1;
    char ch=getchar();
    while(ch!='-'&&(ch>'9'||ch<'0'))
        ch=getchar();
    if(ch=='-')
        f=-1,ch=getchar();
    while(ch>='0'&&ch<='9')
        res=(res<<1)+(res<<3)+(ch^48),ch=getchar();
    return res*f;
}
const int N=100;
int ans,maxn;
int R[N][N],P[N][N],X[N][N];
bool f[55][55];
void dfs(int d,int x,int y)
{
    if(!y)
    {
        if(d-1>maxn)
        {
            maxn=d-1;
            ans=1;
        }
        else
        {
            if(d-1==maxn)
                ans++;
        }
        return;
    }
    int u=P[d][1];
    for(RI i=1;i<=y;++i)
    {
        int v=P[d][i];
        if(f[v][u])continue;
        for(RI j=1;j<=x;++j)
            R[d+1][j]=R[d][j];
        R[d+1][x+1]=v;
        int ty=0,tz=0;
        for(RI j=1;j<=y;++j)
            if(f[v][P[d][j]])
                P[d+1][++ty]=P[d][j];
        dfs(d+1,x+1,ty);
        P[d][i]=0;
    }
}
int main()
{
    int n=read(),m=read();
    for(RI i=1;i<=m;++i)
    {
        int x=read(),y=read();
        f[x][y]=f[y][x]=1;
    }
    for(RI i=1;i<=n;++i)
        P[1][i]=i;
    dfs(1,0,n);
    printf("%d %d",maxn,ans);
    return 0;
}
//Written By Air_Castle

　　then  我发现 根本就不需要 R 数组啊

#include<iostream>
#include<cstdio>
#define go(i,a,b) for(register int i=a;i<=b;i++)
using namespace std;
int read()
{
    int x=0,y=1;char c=getchar();
    while(c<'0'||c>'9') {if(c=='-') y=-1;c=getchar();}
    while(c>='0'&&c<='9') {x=(x<<1)+(x<<3)+c-'0';c=getchar();}
    return x*y;
}
int n,m,ans1,ans2,P[100][100];
bool mp[100][100];
void dfs(int st,int y) //st:step x:R's num y:P's num
{
    if(!y)
    {
        if(st-1>ans1) {ans1=st-1;ans2=1;}
        else if(st-1==ans1) ans2++;
        return ;
    }
    int u=P[st][1];
    go(i,1,y)
    {
        int v=P[st][i];
        if(mp[u][v]) continue ;
        int cnt=0;
        go(j,1,y)
            if(mp[v][P[st][j]]) P[st+1][++cnt]=P[st][j];
        dfs(st+1,cnt);
        P[st][i]=0;
    }
}
int main()
{
    n=read();m=read();
    go(i,1,m) {int x=read(),y=read();mp[x][y]=mp[y][x]=1;}
    go(i,1,n) P[1][i]=i;
    dfs(1,n);
    printf("%d %d",ans1,ans2);
    return 0;
}

 　　

3. 我还不会 ! ! ! qwq