What a find! Anna Locke has just bought several links of chain some of which may be connected. They are made from zorkium, a material that was frequently used to manufacture jewelry in the last century, but is not used for that purpose anymore. It has its very own shine, incomparable to gold or silver, and impossible to describe to anyone who has not seen it first hand. Anna wants the pieces joined into a single end-to-end strand of chain. She takes the links to a jeweler who tells her that the cost of joining them depends on the number of chain links that must be opened and closed. In order to minimize the cost, she carefully calculates the minimum number of links that have to be opened to rejoin all the links into a single sequence. This turns out to be more difficult than she at first thought. You must solve this problem for her.

The input consists of descriptions of sets of chain links, one set per line. Each set is a list of integers delimited by one or more spaces. Every description starts with an integer n, which is the number of chain links in the set, where 1 ≤ n ≤ 15. We will label the links 1, 2, ..., n. The integers following n describe which links are connected to each other. Every connection is specified by a pair of integers i,j where 1 ≤ i,j ≤ n and i ̸= j, indicating that chain links i and j are connected, i.e., one passes through the other. The description for each set is terminated by the pair ‘-1 -1’, which should not be processed. The input is terminated by a description starting with n = 0. This description should not be processed and will not contain data for connected links.

For each set of chain links in the input, output a single line which reads
Set N: Minimum links to open is M
where N is the set number and M is the minimal number of links that have to be opened and closed such that all links can be joined into one single chain.

 Sample Input

 Sample Ouput

Set 1: Minimum links to open is 1

Set 2: Minimum links to open is 2

Set 3: Minimum links to open is 1

Set 4: Minimum links to open is 1

Set 5: Minimum links to open is 1

题解：一看到n不超过15，向二进制的方向想是很自然的，顺着思路就出来了，暴力枚举情况，关键在于如何判断一个情况是成立的首先判环是肯定的，然后就是判断断开的个数是否大于等于连通分支的个数-1。这两点都很好想，容易忽略的就是如果一个环的分支数大于2也是不行的。这个虽然不太容易一下想到，但是样例有提示（良心样例），也不是什么困难的问题，代码都是套路。

 #include <iostream>

 #include <cstring>

 #include <cstdlib>

 #include <cstdio>

 #include <algorithm>

 #define INF 0x3f3f3f3f

 using namespace std;

 const int maxn = ;

 int n;

 int gra[maxn][maxn];

 int vis[maxn];

 bool dfs(const int sit,int fa,int u){

     vis[u] = -;

     for(int v = ;v < n;v++){

         if(!gra[u][v] || vis[v]== || v==fa || !(sit&(<<v))) continue;

         if(vis[v] < ) return false;

         if(!vis[v] && !dfs(sit,u,v)) return false;

     }

     vis[u] = ;

     return true;

 }

 bool check(const int sit,int &res){

     memset(vis,,sizeof(vis));

     for(int u = ;u < n;u++){

         if(!(sit&(<<u))) continue;

         if(!vis[u]){

             if(!dfs(sit,u,u)) return false;

             res++;

         }

     }

     for(int u = ;u < n;u++){

         if(!(sit&(<<u))) continue;

         int cnt = ;

         for(int v = ;v < n;v++){

             if(gra[u][v] && sit&(<<v)) cnt++;

             if(cnt > ) return false;

         }

     }

     return true;

 }

 int iCase = ;

 int main()

 {

     while(~scanf("%d",&n) && n){

         int x,y;

         memset(gra,,sizeof(gra));

         while(scanf("%d%d",&x,&y) && (x!=- && y!=-)){

             x--,y--;

             gra[x][y] = gra[y][x] = ;

         }

         int Min = INF;

         for(int i = (<<n)-;i >= ;i--){

             int res = ;

             if(check(i,res)){

                 int cnt = ;

                 for(int j = ;j < n;j++){

                     if(!(i&(<<j))) cnt++;

                 }

                 if(res- <= cnt) Min = min(Min,cnt);

                 if(Min == ) break;

             }

         }

         printf("Set %d: Minimum links to open is %d\n",iCase++,Min);

     }

     return ;

 }