You must have heard all about the Foolland on your Geography lessons. Specifically, you must know that federal structure of this country has been the same for many centuries. The country consists of n cities, some pairs of cities are connected by bidirectional roads, each road is described by its length li.
The fools lived in their land joyfully, but a recent revolution changed the king. Now the king is Vasily the Bear. Vasily divided the country cities into regions, so that any two cities of the same region have a path along the roads between them and any two cities of different regions don't have such path. Then Vasily decided to upgrade the road network and construct exactly p new roads in the country. Constructing a road goes like this:
- We choose a pair of distinct cities u, v that will be connected by a new road (at that, it is possible that there already is a road between these cities).
- We define the length of the new road: if cities u, v belong to distinct regions, then the length is calculated as min(109, S + 1) (S — the total length of all roads that exist in the linked regions), otherwise we assume that the length equals 1000.
- We build a road of the specified length between the chosen cities. If the new road connects two distinct regions, after construction of the road these regions are combined into one new region.
Vasily wants the road constructing process to result in the country that consists exactly of q regions. Your task is to come up with such road constructing plan for Vasily that it meets the requirement and minimizes the total length of the built roads.
The first line contains four integers n (1 ≤ n ≤ 105), m (0 ≤ m ≤ 105), p (0 ≤ p ≤ 105), q (1 ≤ q ≤ n) — the number of cities in the Foolland, the number of existing roads, the number of roads that are planned to construct and the required number of regions.
Next m lines describe the roads that exist by the moment upgrading of the roads begun. Each of these lines contains three integers xi, yi, li: xi, yi — the numbers of the cities connected by this road (1 ≤ xi, yi ≤ n, xi ≠ yi), li — length of the road (1 ≤ li ≤ 109). Note that one pair of cities can be connected with multiple roads.
If constructing the roads in the required way is impossible, print a single string "NO" (without the quotes). Otherwise, in the first line print word "YES" (without the quotes), and in the next p lines print the road construction plan. Each line of the plan must consist of two distinct integers, giving the numbers of the cities connected by a road. The road must occur in the plan in the order they need to be constructed. If there are multiple optimal solutions, you can print any of them.
9 6 2 2 1 2 2 3 2 1 4 6 20 1 3 8 7 8 3 5 7 2
YES 9 5 1 9
2 0 1 2
NO
2 0 0 2
YES
Consider the first sample. Before the reform the Foolland consists of four regions. The first region includes cities 1, 2, 3, the second region has cities 4 and 6, the third region has cities 5, 7, 8, the fourth region has city 9. The total length of the roads in these cities is 11, 20, 5 and 0, correspondingly. According to the plan, we first build the road of length 6 between cities 5 and 9, then the road of length 23 between cities 1 and 9. Thus, the total length of the built roads equals 29.
题目大意：
给你N个点，M条无向边，此时想要建立p条边，使得联通块个数最终为q个（不能多也不能少）。
建立一条新边的规则：
1、如果两个点不是一个联通块，那么对应边的权值为min（1e9，S+1），这里S表示两个联通块的边权和。
2、如果两个点是一个联通块，那么对应边的权值就是1000.
如果能够达到目标，那么输出最小边权花费的方案。
否则输出NO.
思路：
1、无向图判联通块个数，直接用并查集来维护即可。
对应一个联通块的边权值和我们可以设定为sum【i】，表示以i为根的联通块边权值总和。
那么就有：
①find（a）！=find（b）：sum【find（a）】+=sum【find（b）】+w；
②find（a）==find（b）：sum【find（a）】+=w；
2、接下来贪心考虑，如何建边能够使得总花费最小呢？
我们肯定每一次都找到最小权值和的两个联通块进行连接是最优的。
那么如果此时联通块个数大于q个，那么每次取出两个联通块，让两个联通块的两个代表点相连即可。合并成一个集合、
那么这个过程我们每一次取完之后都需要排序，显然优先队列维护是最好的选择。
那么建立一个优先队列，每次取出两个联通块进行连接，直到此时联通块个数==q个为止。
3、那么对于剩余的需要建边的数量p.我们找到任意一个联通块，任意取两点进行连接即可、
Ac代码：
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
#define ll __int64
struct node
{
ll val;
int root;
friend bool operator <(node a,node b)
{
return a.val>b.val;
}
}now,u,v;
int ans[1000050][2];
int f[100050];
ll sum[100056];
int find(int a)
{
int r=a;
while(f[r]!=r)
r=f[r];
int i=a;
int j;
while(i!=r)
{
j=f[i];
f[i]=r;
i=j;
}
return r;
}
int merge(int a,int b,ll w)
{
int A,B;
A=find(a);
B=find(b);
if(A!=B)
{
f[B]=A;
sum[A]+=sum[B];
sum[A]+=w;
}
else sum[A]+=w;
}
int main()
{
int n,m,k,q;
while(~scanf("%d%d%d%d",&n,&m,&k,&q))
{
int xx,yy;
xx=-1;yy=-1;
priority_queue<node >s;
for(int i=1;i<=n;i++)f[i]=i,sum[i]=0;
for(int i=0;i<m;i++)
{
int x,y;
ll w;
scanf("%d%d%I64d",&x,&y,&w);xx=x;yy=y;
merge(x,y,w);
}
int sig=0;
for(int i=1;i<=n;i++)
{
if(f[i]==i)
{
sig++;
now.val=sum[i];
now.root=i;
s.push(now);
}
}
int cnt=0;
while(sig>q)
{
if(k>0)
{
u=s.top();s.pop();
v=s.top();s.pop();
merge(u.root,v.root,min(1000000000ll,sum[find(u.root)]+sum[find(v.root)]+1));
ans[cnt][0]=u.root;
ans[cnt][1]=v.root;
xx=u.root;
yy=v.root;
now.root=find(u.root);
now.val=sum[now.root];
s.push(now);
cnt++;sig--;k--;
}
else break;
}
if(sig==q)
{
int pos=1;
while(k>0)
{
if(xx==-1||yy==-1)break;
ans[cnt][0]=xx;
ans[cnt][1]=yy;
cnt++;
k--;
}
if(k==0)
{
printf("YES\n");
for(int i=0;i<cnt;i++)
{
printf("%d %d\n",ans[i][0],ans[i][1]);
}
}
else printf("NO\n");
}
else printf("NO\n");
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
