CF731C Socks并查集(森林),连边，贪心，森林遍历方式，动态开点释放内存

http://codeforces.com/problemset/problem/731/C

这个题的题意是。。小明的妈妈给小明留下了n只袜子，给你一个大小为n的颜色序列c

代表第i只袜子的颜色，小明的妈妈在以后的m天要求小明每天穿编号为l[i],r[i]所组成的一双袜子

小明觉得如果颜色不一样的话很丢人。。想一次把袜子的颜色全部改好。。使得。。既按照妈妈的指令去做

又能使每天穿的一双袜子颜色相同，问，最少改变几只袜子的颜色(能满足条件)

因为这个题是水题嘛，所以说我考虑了三种实现的方式

之前没有认真分析题的时候我去线性地遍历这个序列。。然后去乱搞。。瞎猜。。反证都没有

线性遍历是无法保证题目条件的

事实证明这样的做法是最费力不讨好的

那么如果我们深入这个题的话。。会观察得到一个性质。。小明每天穿的两只袜子颜色必然相同

那么这就相当于建立了一种联系，即给题目中的变量建立了联系，于是我们如何来维护这个联系呢

第一我们可以把他们都放到一个集合里面。。(我们找集合里面出现次数最多的颜色就好了)这个得实现方法，标记每个点的所属集合。。。vis数组

还可以用并查集(不过这个题没有查询操作不必强行并查集)，还可以直接连边（这样连边连在一起的一颗森林，他们的颜色必定相同）

你用并查集可以非常容易地把那些点放到一个集合里去，当我们放进去之后。。问题来了。。

我一开始想的是。。如果你使用了并查集的路径压缩，那么你可以在很短的时间内找到一个点的所属集合的标号

我们只要扫一遍所有的元素就能遍历所有的集合。。但是如何分开统计呢。。我想到的是cnt[maxn][maxn]

第一维集合编号。。第二维。。记录每种颜色的个数。。集合编号最多2e5,颜色最多2e5,4e10的空间。。你怕不怕

但是这都是不经过仔细思考的结果。。然后我因为空间上这点事放弃了通过点找集合的遍历方法

但是如果你要通过集合编号要找所属的元素的话。。首先你不知道有哪些集合编号。。其次你也不知道集合里放了哪些元素

经典的并查集结构只能判定点的集合编号。。通过集合很难找到点。。需要枚举。。

第一枚举集合，第二枚举元素，2e5的两层循环，加了vis访问数组都超时了。。（即遍历过的元素不再跑）

而且如果你仍然用cnt[颜色值]++来统计的话。。每次遍历完一个集合。。你就要清空。。（这里的清空是重新赋值，应当与STL的clear不同）

那么这样你是铁定n^2复杂度了，T的你连妈妈都不认识哦

那么接下来我们怎么走呢？我们是一定需要记得之前的矛盾的。。

矛盾1，cnt[maxn][maxn]开不下。。首先有一点我们要清楚。。第一维是一定要开满的。。不遍历完你永远不知道

有几个集合，那第二维统计颜色，颜色值的数量与集合数量并不能同时取到最大。。具体来说。。如果你第二维开满

很多时候很多的颜色值将是空的。。这就造成了空间上的浪费。。因为第二维最多一共需要maxn个位置，而不是maxn*maxn

所以我们想到了动态开点释放内存。。这个还是不那么好写的。。我们可以用map<int,int>数组啊！！，然后统计完遍历map数组统计答案

这样我们就能通过点找集合的方式快速统计。。下面贴上代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <map>
using namespace std;
const int maxn=2e5+;
int n,m,k;
int c[maxn];
int l,r;
int fa[maxn];
bool vis[maxn];
map<int,int> mp[maxn];
void init(){
    int i;
    for(i=;i<=n;++i){
        fa[i]=i;
    }
}
int getFa(int v){
    if(v==fa[v]) return v;
    return fa[v]=getFa(fa[v]);
}
void Mix(int a,int b){
    int af=getFa(a);
    int bf=getFa(b);
    if(af!=bf){
        fa[bf]=af;
    }
}
int main(){
    scanf("%d%d%d",&n,&m,&k);
    int i,j;
    for(i=;i<=n;++i){
        scanf("%d",&c[i]);
    }
    init();
    for(i=;i<=m;++i){
        scanf("%d%d",&l,&r);
        Mix(l,r);
    }
    int sum=;int all,mx;
    for(i=;i<=n;++i){
        int father=getFa(i);
        mp[father][c[i]]++;
    }
    for(i=;i<=n;++i){
        int cnt=,mx=;
        for(map<int,int>::iterator it=mp[i].begin();it!=mp[i].end();++it){
            if(it->second>mx) mx=it->second;
            cnt+=it->second;
        }
        sum+=cnt-mx;
    }
    printf("%d\n",sum);
    return ;
}

第二种方法我们仍然使用并查集。。我们还可以采用集合遍历元素的方法来遍历并查集森林

但是我们并查集的原始结构可是不支持的。。你要是按这样的映射方式去统计的话。。仍然是要

第一维枚举集合编号。。第二维枚举所有元素。。两重循环爆炸(某些情况两重循环可并不一定是n^2的复杂度哦)

然后这时候其实一个通常的普遍的想法不容易想到。。那就是空间换时间。。因为它最普遍所以它也最不容易被想到

那么又出现了上面那个问题二维数组行吗？由于二维数组非常地死板。。所以一定会在空间上就爆炸

那么我们仍然选择用STL容器数组，动态开点，释放内存(clear()),由于我们只需要取元素。。vector就可以满足我们的需求

我们每次合并的时候，如果是不同集合的东西。。(相同集合就不要管了。。免得重复统计)，那么我们就选择把数量小的森林

合并到大的森林里去。。然后把小森林的vector clear掉，

那么我一开始想的是这个事情很难实现。。原因是我考虑了这样一种情况。。如果合并的两颗森林里。。某一颗森林还包含了链向其他

编号的森林（因为会合并嘛），那你用vector怎么合并呢。。这个问题第一不好存储。。第二不好合并。。

但是你仔细想一下。。如果你从第一次开始。。每次都合并。。那么在vector里面这个就是线性的结构。集合里每个元素的父亲都严格

相等，那么每次都是线性的。。后面就不会有这种情况啊

Tips：我经常会问自己这样的问题。。那么以后在想的时候一定还记得要思考。。我思考的这个样例在什么条件下成立。。条件有可能被满足吗

在当前想法的前提下。。是否会出现这种状况。。走什么样的流程会导致这样的样例。。这个流程合法吗

不符合题意。。不符合条件的样例毫无意义。。会把你困死。。所以每当困惑的时候我们要找出出现困惑样例的前提条件，周遭的主要联系和关键

不要老是复杂化一个问题

Tips：实现在Mix里的vector合并有一个经典的错误。。通过size是否等于0来判断它是不是一个新的没计算过的集合。。，那么我们还要考虑有没有

相同的情况，但是当你第一次写下这个判断的时候当前发生的语句还真没有歧义。。当你合并完。。集合。。每一个集合clear了。。那么它的size就变

成了0，但是它并不是新的没有计算过的集合。。那么你应该马上意识到这一点。。并重新考虑判断条件。。并且你引入的新的辅助判断条件仍然不能有

歧义。。并且你还要时刻小心后面新加的操作仍然对判断语句造成歧义

合并之后我们就可以按照一个集合一个集合的顺序来统计答案，那么遍历的时候如何统计呢。。如果用cnt[maxn]。。每次都要情况。。

这样就又是n方了。。那么这里又有一个技巧。。

Tips:clear是要比memset快的。。（这个题来说），当我们发现有类似的矛盾可以尝试用clear或者其他动态开点的手段来解决

所以我们用一个map来统计颜色。。每统计完一个我们就清空map..因为map只需要清空很少的值。。而cnt不管如何都要强行全部清零

不过在这里我又想到了一种方法。。那就是记录一下都用到了哪些颜色。。我们只对这些元素进行清零。。(但是还是clear稳一点感觉)

下面贴上代码

#include <iostream>
#include <cstdio>
#include <vector>
#include <map>

using namespace std;
int n,m,k;
const int maxn=2e5+;
int c[maxn],fa[maxn];
vector<int> Set[maxn];
map<int,int> mp;
void init(){
    int i;
    for(i=;i<=n;++i){
        fa[i]=i;
    }
}
int getFa(int v){
    return (v==fa[v])?v:(fa[v]=getFa(fa[v]));
}
void Mix(int x,int y){
    int a=getFa(x);
    int b=getFa(y);
    if(a!=b){
        int sz1=Set[a].size();
        int sz2=Set[b].size();
        if(sz2>sz1) swap(a,b);
        if(Set[a].size()==) Set[a].push_back(a);
        if(Set[b].size()==) Set[a].push_back(b);
        for(int i=;i<Set[b].size();++i){
            Set[a].push_back(Set[b][i]);
        }
        Set[b].clear();
        fa[b]=a;
    }
}
int main(){
    scanf("%d%d%d",&n,&m,&k);
    int i,j;
    for(i=;i<=n;++i){
        scanf("%d",&c[i]);
    }
    int l,r;
    init();
    for(i=;i<=m;++i){
        scanf("%d%d",&l,&r);
        Mix(l,r);
    }
    int sum=;
    for(i=;i<=n;++i){
        int mx=;
        for(j=;j<Set[i].size();++j){
            int t=Set[i][j];
            // printf("I:%d t:%d\n",i,t);
            mp[c[t]]++;
            mx=max(mx,mp[c[t]]);
        }
        sum+=Set[i].size()-mx;
        mp.clear();
    }
    printf("%d\n",sum);
    return ;
}

下面是直接利用邻接表连边。。构造出森林。。然后直接dfs遍历关系的集合森林。。dfs的先序过程中即可统计答案

这也算是并查集的另外一种实实在在的结构。。并查集能转化为邻接表的树。。那么森林也是可以表示并查集的。。相互转化

下面贴上代码

#include <iostream>
#include <cstdio>
#include <map>
#include <vector>
using namespace std;
const int maxn=2e5+;
int n,m,k;
int c[maxn];
map<int,int> mp;
vector<int> edge[maxn];
bool vis[maxn];
int mx,all;
void dfs(int v){
    int i;
    mp[c[v]]++;all++;mx=max(mx,mp[c[v]]);
    for(i=;i<edge[v].size();++i){
        int t=edge[v][i];
        if(!vis[t]){
            vis[t]=true;
            dfs(t);
        }
    }
}
int main(){
    scanf("%d%d%d",&n,&m,&k);
    int i;
    for(i=;i<=n;++i){
        scanf("%d",&c[i]);
    }
    int l,r;
    for(i=;i<=m;++i){
        scanf("%d%d",&l,&r);
        edge[l].push_back(r);
        edge[r].push_back(l);
    }
    int sum=;
    for(i=;i<=n;++i){
        if(vis[i]) continue;
        vis[i]=true;
        all=;mx=;
        dfs(i);
        sum+=all-mx;
        mp.clear();
    }
    printf("%d\n",sum);
    return ;
}

按这种写法在dfs(i)之前我们就应该vis[i]=true;

如果仅仅是为了防止死循环。。那我们可以判断！=fa来防止dfs死循环