HDU 4786 最小生成树变形 kruscal（13成都区域赛F）

Fibonacci Tree

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 4136    Accepted Submission(s): 1283

Problem Description

　　Coach Pang is interested in Fibonacci numbers while Uncle Yang wants him to do some research on Spanning Tree. So Coach Pang decides to solve the following problem:
　　Consider a bidirectional graph G with N vertices and M edges. All edges are painted into either white or black. Can we find a Spanning Tree with some positive Fibonacci number of white edges?
(Fibonacci number is defined as 1, 2, 3, 5, 8, ... )

 

Input

　　The first line of the input contains an integer T, the number of test cases.
　　For each test case, the first line contains two integers N(1 <= N <= 10⁵) and M(0 <= M <= 10⁵).
　　Then M lines follow, each contains three integers u, v (1 <= u,v <= N, u<> v) and c (0 <= c <= 1), indicating an edge between u and v with a color c (1 for white and 0 for black).

 

Output

　　For each test case, output a line “Case #x: s”. x is the case number and s is either “Yes” or “No” (without quotes) representing the answer to the problem.

 

Sample Input

2

4 4

1 2 1

2 3 1

3 4 1

1 4 0

5 6

1 2 1

1 3 1

1 4 1

1 5 1

3 5 1

4 2 1

 

Sample Output

Case #1: Yes

Case #2: No

 

Source

2013 Asia Chengdu Regional Contest

 

题意：N个顶点,M条边，每条边或为白色或为黑色（ 1 or 0 ），问有没有用是斐波那契数的数目的白色边构成一棵生成树

题解：N个顶点构成的生成树有N-1条边 ，首先判断能否能构成生成树,图是否是联通的，无法构成则输出No

先使用所有的黑边 不断加边，看最多能使用多少条黑边使得不形成环 求得白边的使用的数量的下界

然后再使用所有的白边，不断的加边，看最多能使用多少条白边使得不形成环，求得白边使用的数量的上界

然后是否存在斐波那契数载这个区间

我们等于是要证明对于所有在min和max之间的白边数我们都能够达到。

考虑从最小的min开始，我总可以找到一条黑边，使得将它去掉在补上一条白边保持图联通。为什么呢，如果在某一个状态（设白边数为x）下，不存在一条黑边可以被白边代替，那么现在我们把所有黑边去掉，剩下x条白边，那我们知道，x一定等于max，因为若x<max，那么我们在算max的那个步骤中，先将这x条白边加入，还可以在加入max-x条白边使得不存在环，那么这与没有一条黑边可以被白边代替矛盾，所以这就证明了从min到max我都可以达到

 

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 using namespace std;
 struct node
 {
     int u,v,c;
 } N[];
 int fib[];
 int fa[];
 int t;
 int n,m;
 int coun;
 int find(int root)
 {
     if(root==fa[root])
         return root;
     else
         return fa[root]=find(fa[root]);
 }
 void unin(int a,int b)
 {
     int aa=find(a);
     int bb=find(b);
     if(aa!=bb)
         fa[aa]=bb;
 }
 void init()
 {
     for(int i=; i<=n; i++)
         fa[i]=i;
 }
 void fi()
 {
     fib[]=;
     fib[]=;
     for(int i=;; i++)
     {
         fib[i]=fib[i-]+fib[i-];
         if(fib[i]>)
         {
             coun=i;
             break;
         }
     }
 }
 int kruscal(int exm)
 {
     init();
     int k=;
     for(int i=; i<=m; i++)
     {
         if(N[i].c!=exm)
         {
             if(find(N[i].u)!=find(N[i].v))
             {
                 k++;
                 unin(N[i].u,N[i].v);
             }
         }
     }
     return k;
 }
 int main()
 {
     fi();
     while(scanf("%d",&t)!=EOF)
     {
         for(int j=; j<=t; j++)
         {
             scanf("%d %d",&n,&m);
             for(int i=; i<=m; i++)
             scanf("%d %d %d",&N[i].u,&N[i].v,&N[i].c);
             printf("Case #%d: ",j);
             int zha;
             zha=kruscal();//可以使用白边和黑边
             if(zha!=(n-))//判环
             {
                 printf("No\n");
                 continue;
             }
             int l=n--kruscal();//构成生成树的白边数量的下限
             int r=kruscal();// 构成生成树的白边数量的上限
             int flag=;
             for(int i=; i<coun; i++)//判断是否存在满足条件的fib
             {
                 if(fib[i]>=l&&fib[i]<=r)
                 {
                     printf("Yes\n");
                     flag=;
                     break;

                 }
             }
             if(flag==)
                 printf("No\n");
         }
     }
     return ;
 }