Divide and conquer:Telephone Lines(POJ 3662)

　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　电话线

　　题目大意：一堆电话线要你接，现在有N个接口，总线已经在1端，要你想办法接到N端去，电话公司发好心免费送你几段不用拉网线，剩下的费用等于剩余最长电话线的长度，要你求出最小的费用。

　　这一看又是一个最小化最大值的问题（也可以看成是最大化最小值的问题），常规方法一样的就是把这个费用二分就好，但是这道题是道图论题，不一定经过所有的点，那我们就以二分基准长度为界限，把小于基准长度的那一部分看成是0，大于等于基准长度的看成是1，这样我们只用SPFA算法算最短路径就可以了，非常的巧妙

　　参考：http://poj.org/showmessage?message_id=181794

　　PS：好久没写SPFA了，都忘记是怎么写了，重新定义长度的时候又忘记乘以2了WA一个晚上真是日了

　　

 #include <iostream>
 #include <algorithm>
 #include <functional>
 #define SIZE 1010

 using namespace std;
 typedef int Position;

 struct _set
 {
     Position ed;
     int next;
     int length;
 }Path[];
 struct _head
 {
     int point;
 }Heads[SIZE];
 static int dist[SIZE];
 static bool visit[SIZE], oep[];
 static Position que[(SIZE + ) * ];

 void solve(const int, const int, const int, const int);
 bool SPFA(const int, const int, const int, const int);

 int main(void)
 {
     int Sum_Poles, Free_Cables, Sum_Path, length, L_Max;
     Position st, ed;

     while (~scanf("%d%d%d", &Sum_Poles, &Sum_Path, &Free_Cables))
     {
         L_Max = -;
         for (int i = ; i <= Sum_Poles; i++)
             Heads[i].point = -;
         for (int i = ; i <  * Sum_Path;)
         {
             scanf("%d%d%d", &st, &ed, &length);
             //无向图，两边都要存
             Path[i].ed = ed; Path[i].length = length; Path[i].next = Heads[st].point;
             Heads[st].point = i++;

             Path[i].ed = st; Path[i].length = length; Path[i].next = Heads[ed].point;
             Heads[ed].point = i++;

             L_Max = max(L_Max, length);
         }
         solve(Sum_Poles, Sum_Path, Free_Cables, L_Max);
     }
     return ;
 }

 void solve(const int Sum_Poles, const int Sum_Path, const int Free_Cables, const int L_Max)
 {
     int lb = , rb = L_Max + , mid;

     while (rb - lb > )//对距离二分
     {
         mid = (lb + rb) >> ;
         if (SPFA(mid, Sum_Path, Sum_Poles, Free_Cables)) lb = mid;
         else rb = mid;
         if (dist[Sum_Poles] == 0x3fffffff)
             //任何一次寻找过后，如果图能到N点，那么N的dist值一定不是0x3fffffff
             //否则，一定是不联通
         {
             printf("-1\n");
             return;
         }
     }
     printf("%d\n", lb);
 }

 bool SPFA(const int x, const int Sum_Path, const int Sum_Poles, const int Free_Cables)
 {
     int head = , back = , out, to;

     que[head] = ;    //开始是从1开始的    

     for (int i = ; i <  * Sum_Path; i++)
         oep[i] = Path[i].length < x ?  : ;

     fill(dist, dist + Sum_Poles + , 0x3fffffff);
     memset(visit, , sizeof(visit));
     dist[] = ;

     while (head != back)
     {
         out = que[head]; head = (head + ) % ( * SIZE);
         visit[out] = ;

         for (int k = Heads[out].point; k != -; k = Path[k].next)
         {
             to = Path[k].ed;
             if (dist[out] + oep[k] < dist[to])
             {
                 dist[to] = dist[out] + oep[k];
                 if (!visit[to])
                 {
                     visit[to] = ;
                     que[back] = to; back = (back + ) % ( * SIZE);
                 }
             }
         }
     }
     return dist[Sum_Poles] > Free_Cables;
 }