[简单路径] Useful Decomposition

Ramesses knows a lot about problems involving trees (undirected connected graphs without cycles)!

He created a new useful tree decomposition, but he does not know how to construct it, so he asked you for help!

The decomposition is the splitting the edges of the tree in some simple paths in such a way that each two paths have at least one common vertex. Each edge of the tree should be in exactly one path.

Help Remesses, find such a decomposition of the tree or derermine that there is no such decomposition.

Input

The first line contains a single integer n

(2≤n≤105

) the number of nodes in the tree.

Each of the next n − 1

lines contains two integers ai and bi (1≤ai,bi≤n, ai≠bi

) — the edges of the tree. It is guaranteed that the given edges form a tree.

Output

If there are no decompositions, print the only line containing "No".

Otherwise in the first line print "Yes", and in the second line print the number of paths in the decomposition m

.

Each of the next m

lines should contain two integers ui, vi (1≤ui,vi≤n, ui≠vi) denoting that one of the paths in the decomposition is the simple path between nodes ui and vi

.

Each pair of paths in the decomposition should have at least one
common vertex, and each edge of the tree should be presented in exactly
one path. You can print the paths and the ends of each path in arbitrary
order.

If there are multiple decompositions, print any.

Examples

Input

4
1 2
2 3
3 4

Output

Yes
1
1 4

Input

6
1 2
2 3
3 4
2 5
3 6

Output

No

Input

5
1 2
1 3
1 4
1 5

Output

Yes
4
1 2
1 3
1 4
1 5

Note

The tree from the first example is shown on the picture below: The number next to each edge corresponds to the path number in the decomposition. It is easy to see that this decomposition suits the required conditions.

The tree from the second example is shown on the picture below: We can show that there are no valid decompositions of this tree.

The tree from the third example is shown on the picture below: The number next to each edge corresponds to the path number in the decomposition. It is easy to see that this decomposition suits the required conditions.

 

题意:给出n个结点成一颗树,问是否存在一些过一个公共结点的简单路径,如果存在则输出Yes并输出这些路径,否则输出No
思路:简单路径就是在一个路径中同一个边只能出现一次.如果存在一些过一个公共结点的简单路径则最多只能有一个结点的度数大于2
我们选一个度数最大的结点作为根结点,根结点到叶子结点的简单路径就是合法的简单路径,dfs求一下就完事了,然后就test5超时了.
其实我们要输出根结点和叶子结点,而叶子结点是度数为1的结点,所以我们统计所有度数为1的结点,把它和根节点一起输出就好了

 #include<cstdio>
 #include<cstring>
 #include<iostream>
 #include<queue>
 #include<algorithm>
 using namespace std;
 typedef long long ll;
 const int amn=1e5+;
 int n,ans,idx[amn],root;
 vector<int> eg[amn];
 struct node{
     int i,val;
 }cnt[amn];
 bool cmp(node a,node b){
     if(a.val==b.val)return a.i<b.i;
     return a.val>b.val;
 }
 int main(){
     scanf("%d",&n);
     int x,y;
     for(int i=;i<=n-;i++){
         scanf("%d%d",&x,&y);
         eg[x].push_back(y);
         eg[y].push_back(x);
     }
     for(int i=;i<=n;i++){
         cnt[i].val=eg[i].size();
         cnt[i].i=i;
     }
     sort(cnt+,cnt++n,cmp);
     if(cnt[].val>&&cnt[].val>){
         printf("No\n");
     }
     else{
         if(cnt[].val>)root=cnt[].i;
         else{
             for(int i=;i<=n;i++){
                 if(cnt[i].val<){
                     root=cnt[i].i;
                     break;
                 }
             }
         }
         memset(idx,,sizeof idx);
         printf("Yes\n%d\n",eg[root].size());
         int st;
         for(int i=n;i>=;i--){
             if(cnt[i].val>)break;
             st=i;
         }
         for(int i=st;i<=n;i++){
             if(cnt[i].i==root)continue;
             printf("%d ",root);
             printf("%d\n",cnt[i].i);
         }
     }
 }
 /**
 题意:给出n个结点成一颗树,问是否存在一些过一个公共结点的简单路径,如果存在则输出Yes并输出这些路径,否则输出No
 思路:简单路径就是在一个路径中同一个边只能出现一次.如果存在一些过一个公共结点的简单路径则最多只能有一个结点的度数大于2
 我们选一个度数最大的结点作为根结点,根结点到叶子结点的简单路径就是合法的简单路径,dfs求一下就完事了,然后就test5超时了.
 其实我们要输出根结点和叶子结点,而叶子结点是度数为1的结点,所以我们统计所有度数为1的结点,把它和根节点一起输出就好了
 **/