【生成树趣题】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=,x=;char c=getchar();
     while(c<''||''<c){if(c=='-')f=-f;c=getchar();}
     while(''<=c&&c<='') x=(x<<)+(x<<)+(c^),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=;i<=n;i++)
         f[i]=i;
 }
 int main()
 {
     n=rd(),m=rd();
     for(int i=;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=;u<=n;u++)
     {
         if(u==s||u==t) continue;
         for(int i=;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=;i<G[s].size();i++)
         if(G[s][i]!=t)
         {
             int x=Find(G[s][i]);
             ls[x]=G[s][i];
         }
     for(int i=;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=;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<||dt<)
         {
             puts("No");
             return ;
         }
     }
     //处理和s,t都相连的集合 第一个会和s,t都连 s,t连通之后就只会连一个
     for(int i=;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 ;
             }
         }
     if(Find(s)!=Find(t))//s,t还没有连通
     {
         bool f=;
         for(int i=;i<G[s].size();i++)
             if(G[s][i]==t)
             {
                 f=;
                 break;
             }
         if(ds&&dt&&f)
             ans.push_back(make_pair(s,t));
         if(!f)
         {
             puts("No");
             return ;
         }
     }
     if(ans.size()!=n-)
     {//满足是一棵生成树
         puts("No");
         return ;
     }
     puts("Yes");
     for(int i=;i<ans.size();i++)
         printf("%d %d\n",ans[i].first,ans[i].second);
     return ;
 }

Code