[POJ 3662] Telephone Lines （二分答案+SPFA）

POJ - 3662
有一张图，要求修一条路径使得 1和 N相连
电话公司可以免去路径上 K条边的花费，FJ 需要额外花费路径上剩余边中最大的边权
问花费最小是多少
其实问的就是如何找一条路径连接 1和 N，使得路径上 K+1大的边最小
看起来像个最小生成树之类的，但很容易证明做法不对

正确做法是二分答案 ans，确定花费，然后在图上跑 SPFA
跑的时候，其中大于 ans的边肯定让电话公司修，所以置边权为 1，其余为 0
这样跑完一遍，dist[N] 即为路径上大于 ans的边最少有多少条，看是否满足条件
时间复杂度 (log(ans)*kE)

有一个 trick就是要判一下图是否连通

#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <map>
#include <set>
#include <queue>
using namespace std;
typedef pair<int,int> Pii;
typedef long long LL;
typedef unsigned long long ULL;
#define MST(a,b) memset(a,b,sizeof(a))
#define CLR(a) MST(a,0)
#define Pow2(a) a*a
int maxx(int a,int b){return a>b?a:b;}
int minn(int a,int b){return a<b?a:b;}
int abss(int a){return a<0?(-a):a;}

const int maxn=1e3+10,maxp=1e4+10,maxl=1e6+10,INF=0x3f3f3f3f;
struct Edge
{
    int u,v,w,nxt;
};
int N,P,K;
int edn;
Edge edge[2*maxp];
int last[maxn];
int dist[maxn];
bool inq[maxn];

void adde(int,int,int);
int spfa(int,int,int);

int main()
{
    while(~scanf("%d%d%d", &N, &P, &K))
    {
        edn=0;
        MST(last,-1);
        for(int i=0; i<P; i++)
        {
            int u,v,w;
            scanf("%d%d%d", &u, &v, &w);
            adde(u,v,w);adde(v,u,w);
        }
        if(spfa(1,N,0)>=INF){puts("-1");continue;}
        int l=0,r=maxl;
        while(l<r)
        {
            int mid=(l+r)>>1;
            if(spfa(1,N,mid)<=K) r=mid;
            else l=mid+1;
        }
        printf("%d\n", l);
    }
    return 0;
}

void adde(int u, int v, int w)
{
    edge[edn].u=u;
    edge[edn].v=v;
    edge[edn].w=w;
    edge[edn].nxt=last[u];
    last[u]=edn++;
}

int spfa(int s, int t, int k)
{
    MST(dist,0x3f);CLR(inq);
    queue<int> que;
    que.push(s);
    inq[s]=1;
    dist[s]=0;
    while(!que.empty())
    {
        int u=que.front();que.pop();
        for(int i=last[u]; ~i; i=edge[i].nxt)
        {
            int v=edge[i].v;
            int w=edge[i].w>k?1:0;
            if(dist[u]+w<dist[v])
            {
                dist[v]=dist[u]+w;
                if(!inq[v]) {que.push(v);inq[v]=1;}
            }
        }
        inq[u]=0;
    }
    return dist[t];
}