Codeforces 1494D Dogeforces 并查集+构造

Dogeforces
题意 老板和员工，老板至少有两个员工，员工不会有下级员工，但是老板可能有自己的老板，那么公司的创始人自然就是树上的顶点 为最大的老板
nn的矩阵每个值 Ai,j 代表 i 员工与 j 员工 LCA(他们共同老板)的薪水，那么显然 Ai,i 代表第i个员工的薪水 给你薪水矩阵 构造出公司组织结构
Trick：我们发现创始人也就是最大的老板 他是可以连无数条边到自己的下属 于是我们将其单独抽出来 为第 n+1 个公司的人 也为公司创始人 这个矩阵是角平分线对称的 所以我们只需要考虑右上的情况 那么最大有 500500/2(角平分线/2)个情况 按照薪水少的关系去维护 总共有如下4个情况：
用并查集维护这图 并查集的fa数组代表集合中的老板ID
A B自己为员工，那么我们需要将这俩人连到一个老板，特判如果当前薪水为创始人薪水，则连到创始人
A B都不为员工，我们要将这俩人连到一个老板，但是如果这俩人其中一人是对方老板 特判连接即可,特判如果当前薪水为创始人薪水，则连到创始人(但是可能其中一个人是创始人 还得特判)
A B其中一位为员工，我们判断一下A,B中的老板薪水是不是当前枚举到的薪水，如果是 则将员工连向另一个老板 否则将他们连到一个新老板 工资为创始人工资时连接到创始人

新老板我们用一个变量k表示 k初始值为n+2(n+1为创始人)

#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>
#include<set>
using namespace std;
 
#define dbg(x) cout<<#x<<" = "<< (x)<< endl
#define dbg2(x1,x2) cout<<#x1<<" = "<<x1<<" "<<#x2<<" = "<<x2<<endl
#define dbg3(x1,x2,x3) cout<<#x1<<" = "<<x1<<" "<<#x2<<" = "<<x2<<" "<<#x3<<" = "<<x3<<endl
 
#define ll long long
#define fi first
#define se second
#define pr pair<int,int>
 
const int MAX_N = 505;
const int MAX_M = MAX_N*MAX_N/2;
int arr[MAX_N][MAX_N];
int ans[MAX_M],fa[MAX_M];
priority_queue<pair<int,pair<int,int> > > q;
vector<pair<int,int> > vt;
 
int Find(int x)
{
    if(fa[x]==x) return x;
    return fa[x] = Find(fa[x]);
}
 
void Merge(int x,int y)
{
    x = Find(x), y = Find(y);
    if(x!=y) fa[x] = y;
}
 
int main()
{
    int n,k,maxx = 0;
    scanf("%d",&n);
    for(int i = 1;i<MAX_M;++i) fa[i] = i;
    for(int i = 1;i<=n;++i)
    {
        for(int j = 1;j<=n;++j)
        {
            scanf("%d",&arr[i][j]);
            maxx = max(maxx,arr[i][j]);
            if(i==j) ans[i] = arr[i][j];
            else if(j>i)
            {
                q.push(make_pair(-arr[i][j],make_pair(i,j)));
            }
        }
    }
    ans[n+1] = maxx;
    k = n+2;
    while(!q.empty())
    {
        pair<int,pair<int,int> > top = q.top();
        q.pop();
        int x = top.second.first, y = top.second.second;
        if(Find(x)==x&&Find(y)==y)
        {
            if(-top.first==maxx)
            {
                vt.push_back(make_pair(x,n+1));
                vt.push_back(make_pair(y,n+1));
                Merge(x,n+1);
                Merge(y,n+1);
            }
            else
            {
                vt.push_back(make_pair(x,k));
                vt.push_back(make_pair(y,k));
                ans[k] = -top.first;
                Merge(x,k);
                Merge(y,k);
                k++;
            }
        }
        else if(Find(x)!=x&&Find(y)!=y)
        {
            int fa_x = Find(x),fa_y = Find(y);
            if(fa_x==fa_y) continue;
            if(maxx==-top.first)
            {
                if(fa_x!=n+1) vt.push_back(make_pair(fa_x,n+1));
                if(fa_y!=n+1) vt.push_back(make_pair(fa_y,n+1));
                if(fa_x!=n+1) Merge(fa_x,n+1);
                if(fa_y!=n+1) Merge(fa_y,n+1);
            }
            else
            {
                if(ans[fa_x]==-top.first)
                {
                    vt.push_back(make_pair(fa_y,fa_x));
                    Merge(fa_y,fa_x);
                }
                else if(ans[fa_y]==-top.first)
                {
                    vt.push_back(make_pair(fa_x,fa_y));
                    Merge(fa_x,fa_y);
                }
                else
                {
                    vt.push_back(make_pair(fa_x,k));
                    vt.push_back(make_pair(fa_y,k));
                    ans[k] = -top.first;
                    Merge(fa_x,k);
                    Merge(fa_y,k);
                    k++;
                }
            }
        }
        else if(Find(x)!=x)
        {
            int fa_x = Find(x);
            if(ans[fa_x] == -top.first)
            {
                vt.push_back(make_pair(y,fa_x));
                Merge(y,fa_x);
            }
            else
            {
                if(-top.first==maxx)
                {
                    vt.push_back(make_pair(fa_x,n+1));
                    vt.push_back(make_pair(y,n+1));
                    Merge(fa_x,n+1);
                    Merge(y,n+1);
                }
                else
                {
                    vt.push_back(make_pair(fa_x,k));
                    vt.push_back(make_pair(y,k));
                    ans[k] = -top.first;
                    Merge(fa_x,k);
                    Merge(y,k);
                    k++;
                }
            }
        }
        else if(Find(y)!=y)
        {
            int fa_y = Find(y);
            if(ans[fa_y] == -top.first)
            {
                vt.push_back(make_pair(x,fa_y));
                Merge(x,fa_y);
            }
            else
            {
                if(-top.first==maxx)
                {
                    vt.push_back(make_pair(fa_y,n+1));
                    vt.push_back(make_pair(x,n+1));
                    Merge(fa_y,n+1);
                    Merge(x,n+1);
                }
                else
                {
                    vt.push_back(make_pair(fa_y,k));
                    vt.push_back(make_pair(x,k));
                    ans[k] = -top.first;
                    Merge(fa_y,k);
                    Merge(x,k);
                    k++;
                }
            }
        }
    }
    k--;
    printf("%d\n",k);
    for(int i = 1;i<=k;++i) i==k?printf("%d\n",ans[i]):printf("%d ",ans[i]);
    printf("%d\n",n+1);
    for(int i = 0;i<vt.size();++i)
    {
        printf("%d %d\n",vt[i].first,vt[i].second);
    }
    return 0;
}