【生成树趣题】CF723F st-Spanning Tree

 

题目传送门

题意：

 

给定一个n个点m条边的无向联通图，没有重边和自环。给定s和t，求一棵生成树，使得s,t的度数不超过ds,dt。若有解，输出“Yes”和方案（多组方案输出任意一组），若无解，输出“No”。

数据范围：

 

2 ≤ n ≤ 200 000

分析：

首先，可以把边分成两类：一类是端点含s或t的，另一类是和s,t没有任何关系的。第二类边可以随便乱连，而第一类边不可以。

所以，就先把第二类边乱连，随便连，反正没有边权连就是了，用一个并查集，相当于搞一个生成树森林出来，这样我们就有了很多很多块集合（相当于被缩成一个点，要注意细节）和s,t两个点。

 

 

集合中只与s,t的其中一个点有边的，只能连那个边，否则就不联通了。一边连一边判断s,t的度数，如果超过了就判定无解。

集合中和s,t都有边相连的，选一个和s,t都连一条边，这样可以使s,t联通的同时尽量最小化度数。（s,t直接相连，度数各增加1，某一个集合再和s,t中的一个相连，s,t中的一个度数会增加1）

 

剩下的和s,t都有边相连的集合，随便连s,t都可以。（如果一个点的度数被连完了，就连另外那个）

最后，如果没有和s,t都有边相连的集合，那么此时s,t还没有被连起来，那么还要在s,t之间直接连一条边。

 

注意还要判断它是不是一棵生成树的形态（边数为n-1）

 

#include<cstdio>
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
#define ll long long
#define N 200005
int n,m,s,t,ds,dt;
vector<int>G[N];
vector<pair<int,int> >ans;
int f[N];//并查集
int ls[N],lt[N];//编号为i的集合通过ls[i]/lt[i]和s/t相连 
inline int rd()
{
    int f=1,x=0;char c=getchar();
    while(c<'0'||'9'<c){if(c=='-')f=-f;c=getchar();}
    while('0'<=c&&c<='9') x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return f*x;
}
int Find(int x)
{
    if(f[x]==x) return x;
    return f[x]=Find(f[x]);
}
bool Union(int u,int v)
{
    int x=Find(u),y=Find(v);
    if(x==y) return false;
    if(x<y) f[y]=x;
    else f[x]=y;
    return true; 
}
void Init()
{
    for(int i=1;i<=n;i++)
        f[i]=i;
} 
int main()
{
    n=rd(),m=rd();
    for(int i=1;i<=m;i++)
    {
        int u=rd(),v=rd();
        G[u].push_back(v);
        G[v].push_back(u);
    }
    s=rd(),t=rd(),ds=rd(),dt=rd();
    Init();
    //乱连不含s,t的边 
    for(int u=1;u<=n;u++)
    {
        if(u==s||u==t) continue;
        for(int i=0;i<G[u].size();i++)
        {
            int v=G[u][i];
            if(v==s||v==t) continue;
            if(Union(u,v)) ans.push_back(make_pair(u,v));
        }
    }
    //处理集合的哪些边和s,t相连的情况 
    for(int i=0;i<G[s].size();i++)
        if(G[s][i]!=t)
        {
            int x=Find(G[s][i]);
            ls[x]=G[s][i];
        }
    for(int i=0;i<G[t].size();i++)
        if(G[t][i]!=s)
        {
            int x=Find(G[t][i]);
            lt[x]=G[t][i];
        }
    //处理只和s,t中的一个相连的集合 
    for(int i=1;i<=n;i++)
    {
        if(ls[i]&&!lt[i])
        {
            ds--;
            Union(s,i);
            ans.push_back(make_pair(s,ls[i]));
        }
        else if(!ls[i]&&lt[i])
        {
            dt--;
            Union(t,i);
            ans.push_back(make_pair(t,lt[i]));
        }
        if(ds<0||dt<0)
        {
            puts("No");
            return 0;
        }
    }
    //处理和s,t都相连的集合 第一个会和s,t都连 s,t连通之后就只会连一个 
    for(int i=1;i<=n;i++)
        if(ls[i]&&lt[i])
        {
            if(ds&&Union(s,i))
            {/*短路运算符 Union不能写在前面 或者也可以用find()判断 Union写在里面*/
                ds--;
                ans.push_back(make_pair(s,ls[i]));
            }
            if(dt&&Union(t,i))
            {
                dt--;
                ans.push_back(make_pair(t,lt[i]));
            }
            if(Find(s)!=Find(i)||Find(t)!=Find(i)) //说明前面没有办法连 度数都用完了 
            {
                puts("No");
                return 0;
            }
        }
    if(Find(s)!=Find(t))//s,t还没有连通
    {
        bool f=0;
        for(int i=0;i<G[s].size();i++)
            if(G[s][i]==t)
            {
                f=1;
                break;
            }
        if(ds&&dt&&f)
            ans.push_back(make_pair(s,t));
        if(!f)
        {
            puts("No");
            return 0;
        }
    }
    if(ans.size()!=n-1)
    {//满足是一棵生成树 
        puts("No");
        return 0;
    }
    puts("Yes");
    for(int i=0;i<ans.size();i++)
        printf("%d %d\n",ans[i].first,ans[i].second);
    return 0;
}