Fools and Foolproof Roads CodeForces - 362D（并查集+优先队列）

最新推荐文章于 2020-02-04 19:02:54 发布

原创最新推荐文章于 2020-02-04 19:02:54 发布 · 293 阅读

0 ·

CC 4.0 BY-SA版权

并查集同时被 2 个专栏收录

8 篇文章

订阅专栏

优先队列

7 篇文章

订阅专栏

Fools and Foolproof Roads

CodeForces - 362D

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 l_i.

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(10⁹, 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.

Input

The first line contains four integers n (1 ≤ n ≤ 10⁵), m (0 ≤ m ≤ 10⁵), p (0 ≤ p ≤ 10⁵), 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 x_i, y_i, l_i: x_i, y_i — the numbers of the cities connected by this road (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i), l_i — length of the road (1 ≤ l_i ≤ 10⁹). Note that one pair of cities can be connected with multiple roads.

Output

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.

Examples

Input

Output

YES
9 5
1 9

Input

2 0 1 2

Output

NO

Input

2 0 0 2

Output

YES

Note

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个连通块.
并使得所加边的权值和最小.
所加的边权值为min(1e9, S+1).
S是两个连通块的权值和(连通块的权值为所包含的边的权值和).

解题思路:
用并查集维护连通块, 用优先队列维护每个连通块的权值, 每次要减小连通块的数量(在两个连通块之间加边)的时候就从优先队列里面拿两个最小的连通块.

权值用long long啊！！！！

code：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
typedef long long ll;
const int maxn = 5e5+5;
const ll INF = 1e9;
struct node{
    int id;
    ll sum;
    bool operator < (const node& other)const{
        return sum > other.sum;
    }
};
int pre[maxn],num[maxn];
ll sum[maxn];
int vis[maxn];
vector<pair<int,int> >res;
priority_queue<node>que;

void init(int n){
    for(int i = 1; i <= n; i++){
        pre[i] = i;
        sum[i] = 0ll;
        num[i] = 1;
        vis[i] = 0;
    }
}
int Find(int x){
    if(x == pre[x])
        return x;
    else return pre[x] = Find(pre[x]);
}
void Union(int x,int y,ll w){
    int fx = Find(x),fy = Find(y);
    if(fx != fy){
        pre[fy] = fx;
        sum[fx] += sum[fy];
        num[fx] += num[fy];
    }
    sum[fx] += w;
    return;
}
int main(){
    int n,m,p,q;
    scanf("%d%d%d%d",&n,&m,&p,&q);
    init(n);
    while(m--){
        int x,y;
        ll w;
        scanf("%d%d%lld",&x,&y,&w);
        Union(x,y,w);
    }
    int region = 0;
    for(int i = 1; i <= n; i++){
        if(Find(i) == i)
            region++;//算算几个连通分量
    }
    region -= q;
    if(region < 0){
        printf("NO\n");
        return 0;
    }
    for(int i = 1; i <= n; i++){
        int fx = Find(i);
        if(!vis[fx]){//父亲节点入队，相当于把连通分量入队
            node tmp;
            tmp.id = fx;
            tmp.sum = sum[fx];
            que.push(tmp);
            vis[fx] = 1;
        }
    }
    while(!que.empty() && region--){
        node tmp1 = que.top();
        que.pop();
        if(que.empty()) break;
        node tmp2 = que.top();
        que.pop();
        res.push_back(make_pair(tmp1.id,tmp2.id));//连接两个连通分量存在答案数组中
        //连接后更新
        sum[tmp1.id] += (sum[tmp2.id] + min(INF,sum[tmp1.id]+sum[tmp2.id]+1ll));
        num[tmp1.id] += num[tmp2.id];
        pre[tmp2.id] = tmp1.id;
        tmp1.sum = sum[tmp1.id];
        que.push(tmp1);//更改后重新入队
        p--;
    }
    if(p < 0){//边不够
        printf("NO\n");
        return 0;
    }
    if(p > 0){
        int flag = 0;
        for(int i = 1; i <= n; i++){
            int fx = Find(i);
            if(num[fx] > 1){
                flag = fx;//记录下该连通分量的父亲
                break;
            }
        }
        if(!flag){//每个连通分量只有一个点，那么只能出现自连边但是题目不允许
            printf("NO\n");
            return 0;
        }
        int id = 0;
        for(int i = 1; i <= n; i++){
            if(Find(i) == flag && i != flag){
                id = i;
                break;//找到连通分量重除父亲外的另一个点
            }
        }
        while(p--){
            res.push_back(make_pair(flag,id));//一个连通分量中加边
        }
    }
    printf("YES\n");
    for(int i = 0; i < res.size(); i++){
        printf("%d %d\n",res[i].first,res[i].second);
    }
    return 0;
}