cf Fix a Tree

每个点,跟一个点一定连边(有可能是他本身),当然,这样给出的一组数据,不一定是一颗完美的树(有且只有一个点是连他本身,当然不存在环),要你进行最少的修改,使其变成一个树.
首先,这显然是一个类似森林的定义,我们可以dfs出一个联通块,然后对他的性质进行判定
1.一旦出现一个点指向自己,那这一块一定是一颗正常树.
2.一旦出现一个点指向的那个点指向的是他自己(互相指向),那他是一棵树,只是存在一些问题,即树根没有正确指向.
3.一个环,当然,每个环边有可能接着树枝.(根据定义,这个环最多一个.)
以上3点,建立在每个点最多只能确立一条新边的事实上.
然后问题就是,找出每一个联通块的性质,他们应当被改变的那个点(根),最终连接即可.
1的根是容易找到的.
2的根也可以直接更改.
3的根需要对每个点的入度进行剥离,最后剥出那个环.

#include <iostream>
#include <vector>
#include <set>
using namespace std;
#define debug(x) std::cerr << #x << " = " << (x) << std::endl
typedef long long LL;
const int MAXN = 2e5+17;
int a[MAXN],vis[MAXN],ind[MAXN];
vector<int > G[MAXN];
vector<int > dap;
void dfs(int u)
{
    vis[u] = 1;
    dap.push_back(u);
    for (int i = 0; i < G[u].size(); ++i)
    {
        if(!vis[G[u][i]])
            dfs(G[u][i]);
    }
}
int main(int argc ,char const *argv[])
{
    #ifdef noob
    freopen("Input.txt","r",stdin);freopen("Output.txt","w",stdout);
    #endif  
    int n;
    cin>>n;
    for (int i = 1; i <= n; ++i)
    {
        cin>>a[i];
        ind[i]++,ind[a[i]]++;
        G[i].push_back(a[i]);
        G[a[i]].push_back(i);
    }
    vector<int > ts,rs,itr;
    int ans = 0;
    bool tre = false,ill = false;
    int cg = -1;
    for (int i = 1; i <= n; ++i)
    {
        if(!vis[i])
        {
            dap.clear();
            dfs(i);
            tre = false,ill = false;
            cg = -1;
            set<pair<int,int > > s;
            for(auto i : dap)
            {
                if(a[i]==i)
                {
                    tre = true;
                    cg = i;
                }
            }
            for(auto i : dap)
            {
                if(tre) break;
                if(i==a[a[i]])
                {
                    ill = true;
                    cg = i;
                    break;
                }
                s.insert({ind[i],i});
            }
            while(1)
            {
                if(!s.size()) break;
                if(tre||ill||(*s.begin()).first!=1) break;
                pair<int,int > now = *s.begin();
                s.erase(s.begin());
                for(auto i : G[now.second])
                {
                    if(s.find({ind[i],i})!=s.end()) 
                    {
                        s.erase(s.find({ind[i],i}));
                        ind[i]--;
                        s.insert({ind[i],i});
                    }
                }
            }
            if(ill)
                itr.push_back(cg);
            else if(tre)
                ts.push_back(cg);
            else
                rs.push_back((*s.begin()).second);
        }
    }
    if(ts.size())
    {
        for (int i = 1; i < ts.size(); ++i)
        {
            a[ts[i]] = ts[0];
            ans++;
        }
        for (int i = 0; i < rs.size(); ++i)
        {
            a[rs[i]] = ts[0];
            ans++;
        }
        for (int i = 0; i < itr.size(); ++i)
        {
            a[itr[i]] = ts[0];
            ans++;
        }
    }
    else if(itr.size())
    {
        for (int i = 0; i < itr.size(); ++i)
        {
            a[itr[i]] = itr[0];
            ans++;
        }
        for (int i = 0; i < rs.size(); ++i)
        {
            a[rs[i]] = itr[0];
            ans++;
        }
    }
    else
    {
        for (int i = 0; i < rs.size(); ++i)
        {
            a[rs[i]] = rs[0];
            ans++;
        }
    }   
    cout<<ans<<endl;
    for (int i = 1; i <= n ; ++i)
        cout<<a[i]<<" ";
    cout<<endl;
    return 0;
}