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[20005];
struct _head
{
    int point;
}Heads[SIZE];
static int dist[SIZE];
static bool visit[SIZE], oep[20005];
static Position que[(SIZE + 1) * 2];

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 = -1;
        for (int i = 0; i <= Sum_Poles; i++)
            Heads[i].point = -1;
        for (int i = 0; i < 2 * 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 0;
}

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

    while (rb - lb > 1)//对距离二分
    {
        mid = (lb + rb) >> 1;
        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
");
            return;
        }
    }
    printf("%d
", lb);
}

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

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

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

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

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

        for (int k = Heads[out].point; k != -1; 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] = 1;
                    que[back] = to; back = (back + 1) % (2 * SIZE);
                }
            }
        }
    }
    return dist[Sum_Poles] > Free_Cables;
}