CodeForces - 920E Connected Components?

这题刚开始想用并查集，因为具体只要点的合并，不需要知道每条边的权值，所以给了个错误答案：

//I(并查集--wa了)
#include<stdio.h>
#include<string.h>
#include<map>
#include<algorithm>
using namespace std;
#define MAXN 200010

map<int,int>R;
int vis[MAXN];
int res[MAXN];
int pre[MAXN];

int Find(int x)
{
    if(pre[x]!=x)
        pre[x]=Find(pre[x]);
    return pre[x];
}

void Union(int x,int y)
{
    int fx=Find(x);
    int fy=Find(y);
    if(fx!=fy)
        pre[fy]=fx;
}

int main()
{
    int i,j;
    int n,m;
    int x,y;
    int cnt,ans,Count;
    int fx,fy;

    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(i=1;i<=m;i++)
        {
            scanf("%d%d",&x,&y);
            R[x]=y;
            R[y]=x;
        }
        for(i=1;i<=n;i++)
            pre[i]=i;
        for(i=1,cnt=0;i<=n&&cnt<n;i++)//建图
        {
            cnt++;
            for(j=i+1;j<=n;j++)
            {
                if(R[i]!=j&&R[j]!=i)
                {
                    fx=pre[i];
                    fy=pre[j];
                    if(fx!=fy)
                    {
                        Union(i,j);
                        cnt++;
                    }
                }
            }
        }
        for(i=1,ans=Count=0;Count<n&&i<=n;i++)
        {
            if(!vis[i])
            {
                vis[i]=cnt=1;
                ans++;
                Count++;
                for(j=i+1;j<=n;j++)
                {
                    fx=pre[i];
                    fy=pre[j];
                    if(fx==fy)
                    {
                        cnt++;
                        Count++;
                        vis[j]=1;
                    }
                }
                res[ans]=cnt;
            }
        }
        sort(res+1,res+1+ans);
        printf("%d\n",ans);
        printf("%d",res[1]);
        for(i=2;i<=ans;i++)
            printf(" %d",res[i]);
        printf("\n");
    }
    return 0;
}

仔细分析一下，其实是错在：

比如1和2可以有边，2和4可以有边，虽然最后确实是放在一个集合里面了，但是这里却记录了2个连通分量。。。。

 

正确思路网上有很多种，参考了一个大佬的：

https://blog.youkuaiyun.com/a664607530/article/details/79284648

 

讲几个晦涩点：

（1）

这里加进去的时候不能是标记vis，因为这些点是后来还要用的（毕竟是要算补图的，和只算原图的全部都反过来了）

 

（2）

因为ss是记录还未找到连通分量的（就在补图中），而删去ops的原因是：

也是swap的原因。

 

请记住，补图的操作一切都和原图中的相反，在原图中是将已经遍历过的点加入队列，即：

这些点，但是补图反过来，就是没有被遍历过的点，就是删除ops中有的点剩下来的点。

还有，最后要swap，因为在for里面被遍历到的点，在原图中是有边相连的，但是在补图中反过来，就没有边相连了，所以ss要和ops进行swap操作。

 

还有：

如果没有这一步，就会MLE，这时将外面的ops或者ss拿到主函数里面就可以过，

但是更好的方法是加一个清空，因为这个还有一个原因，就是使得

这一步更加容易理解，也更加没有争议。

（但是听说一般set用的是栈内存，和放在哪里没有关系，那么调整位置就AC的原因不详。。。）

代码：

//I
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<set>
#include<vector>
#include<queue>
using namespace std;
#define MAXN 200001

vector<int>V[MAXN];//储存每个点的临边（原图中的）
set<int>ss,ops;//分别表示在原图中是独立的连通分量（即在补图中是整体连通的）和在原图中是整体（在补图中是独立的）
queue<int>q;
int ans[MAXN];//记录每个连通分量中的点的个数
bool vis[MAXN];

int main()
{
    int i,j;
    int n,m;
    int u,v;
    int cnt;

    scanf("%d%d",&n,&m);

        memset(V,0,sizeof(V));
        for(i=1;i<=m;i++)
        {
            scanf("%d%d",&u,&v);
            V[u].push_back(v);
            V[v].push_back(u);
        }
        for(i=1;i<=n;i++)
            ss.insert(i);//ss的初始化
        cnt=0;
        memset(vis,0,sizeof(vis));
        memset(ans,0,sizeof(ans));
        while(!q.empty())
            q.pop();
        for(i=1;i<=n;i++)
        {
            if(vis[i])
                continue;
            q.push(i);
            cnt++;
            while(!q.empty())
            {
                u=q.front();
                q.pop();
                if(vis[u])
                    continue;
                vis[u]=true;
                ans[cnt]++;
                //set<int>ops;
                for(j=0;j<V[u].size();j++)
                {
                    if(!vis[V[u][j]])
                        ops.insert(V[u][j]);
                }
                set<int>::iterator it;
                for(it=ops.begin();it!=ops.end();it++)
                    ss.erase(*it);
                for(it=ss.begin();it!=ss.end();it++)
                    q.push(*it);
                swap(ss,ops);//ss是还未连通的点的集合,因为删去ops中的点后剩余的点已经与点u连通了（在一个集合中，但是他们内部可能不是两两有直接连边）
                ops.clear();
            }
        }
        sort(ans+1,ans+1+cnt);
        printf("%d\n",cnt);
        printf("%d",ans[1]);
        for(i=2;i<=cnt;i++)
            printf(" %d",ans[i]);
        printf("\n");

    return 0;
}