CDQZ_Training 2012-5-24 笨笨的电话网络

题目OJ地址：http://cdqz.openjudge.cn/noip/1011/

 

摘要：

时间限制: 

10000ms

 

内存限制: 

128000kB

描述:

　　多年以后，笨笨长大了，成为了电话线布置帅。由于地震使得某市的电话线全部损坏，笨笨是负责接到震中市的负责人、该市周围分布着N(1≤N≤1000)根据1..n顺序编号的废弃的电话线杆，任意两根线杆之间没有电话线连接，一共有p(1≤P≤10000)对电话杆可以拉电话线．其他的由于地震使得无法连接。

 

　　第i对电线杆的两个端点分别是ai，bi，它们的距离为li(1≤li≤1000000)。数据中每对(ai，bi)只出现一次。编号为l的电话杆已经接入了全国的电话网络，整个市的电话线全都连到了编号N的电话线杆上。电就是说，笨笨的任务仅仅是找一条将1号和N号电线杆连起来的路径，其余的电话杆并不一定要连入电话网络。

 

　　电信公司决定支援灾区免费为此市连接k(0≤k≤n)对由笨笨指定的电话线杆，对于此外的那些电话线，需要为它们付费，总费用决定于其中最长的电话线的长度(每根电话线仅连接一对电话线杆)。如果需要连接的电话线杆不超过k对，那么支出为0。

 

　　请你计算一下，将电话线引到震中市最少需要在电话线上花多少钱?

 

【输入】

 

输入文件的第一行包含三个数字n，P，k；

第二行到第p+1行，每行分别都为三个整数al，bi，li。

 

【输出】

 

一个整数，表示陔项工程的最小支出，如果不可能完成则输出一1。

 

【样例输入】

 　　5 7 1

 　　1 2 5

 　　3 1 4

 　　2 4 8

 　　3 2 3

 　　5 2 9

 　　3 4 7

　　 4 5 6

【样例输出】

　　4

 

 

　　本题应该说还是不难，只是很难写。话说我写了三节晚自习，终于调通了。这也是我第一次写SPFA，之前以为多长的，后来发现其实很短十几行就可以解决。

　　关于SPFA，参考：http://www.nocow.cn/index.php/SPFA

 

 

　　本题的做法是：先SPFA找到起点到终点的最短边数，判断它是否小于k，如果小于就直接输出0，否则开始下面的计算。

 

 

　　我们知道事实上费用为本条路径上第k+1大的边的权。也就是说，如果费用为P，那么路径上一定经过k条权值大于P的边。设s[i]表示到i号节点所需经过的大于P的边的数量的最小值，则可以证明s[i]关于P是单调递减的，故思路就很明显了——二分答案。

 

 

　　二分P，每次SPFA找出到n点所需经过大于P的边的数量的最小值（具体方法和最短路差不多，可以参考代码），然后与k进行比较：如果s[n]>k，说明必须经过大于k条边权大于P的边，即总费用高于P，将P提升；如果s[n]<=k，说明有可能经过小于k条边权小于P的边，即总费用可能小于等于P，将P下调。

 

 

　　应该注意的是之前要先DFS或BFS一遍看看n是否能达到，如果不能直接输出-1。

 

　　参考我的代码：

#include<iostream>
#include<queue>
#include<vector>
#include<fstream>
#include<set>

using namespace std;

struct node
{
    int val,end;
};

ifstream fin("phone.in");
ofstream fout("phone.out");

#define INF 0x7fffffff

vector<node> graph[2001];
set<int> se;
int val[2001],qual[2001],n,m,whcissb,k,K,mark[2001];

inline int min(int a,int b)
{
    return a<b?a:b;
}

bool bfs()
{
    queue<int> q;
    while(!q.empty()) q.pop();
    q.push(1);mark[1]=1;
    while(!q.empty())
    {
        int t=q.front();
        q.pop();

        for(int i=0;i<graph[t].size();i++)
        {
            if(mark[graph[t][i].end]==0) q.push(graph[t][i].end);
            mark[graph[t][i].end]=1;
        }
    }

    return mark[n]==1;
}

void find(int p)
{
    queue<int> q;
    while(!q.empty()) q.pop();
    q.push(1);
    for(int i=1;i<=n;i++)
        val[i]=INF;
    val[1]=0;

    while(!q.empty())
    {
        int t=q.front();
        q.pop();

        for(int i=0;i<graph[t].size();i++)
            if(val[t]+1<val[graph[t][i].end])
            {
                val[graph[t][i].end]=val[t]+1;
                q.push(graph[t][i].end);
            }
    }
}

void find2(int p)
{
    queue<int> q;
    while(!q.empty()) q.pop();
    q.push(1);
    for(int i=1;i<=n;i++)
        val[i]=INF,qual[i]=INF;
    val[1]=0;qual[1]=0;

    while(!q.empty())
    {
        int t=q.front();
        q.pop();

        for(int i=0;i<graph[t].size();i++)
            if(graph[t][i].val>p)
            {
                if(qual[t]+1<qual[graph[t][i].end])
                {
                    qual[graph[t][i].end]=qual[t]+1;
                    q.push(graph[t][i].end);
                }
            }
            else
            {
                if(qual[t]<qual[graph[t][i].end])
                {
                    qual[graph[t][i].end]=qual[t];
                    q.push(graph[t][i].end);
                }
            }
    }
}

void solve()
{
    int s=1,t=whcissb;
    while(t-s>1)
    {
        int mid=(s+t)>>1;
        find2(mid);
        if(qual[n]<=k) t=mid;
        else s=mid+1;
    }
    find2(s);
    if(qual[n]<=k) fout<<s<<endl;
    else fout<<t<<endl;
}

int main()
{
    fin>>n>>m>>k;

    for(int i=1;i<=m;i++)
    {
        node p;int s,e,v;
        fin>>s>>e>>v;
        p.end=e;
        p.val=v;
        graph[s].push_back(p);
        p.end=s;
        graph[e].push_back(p);

        if(v>whcissb) whcissb=v;
    }

    if(!bfs()) 
    {
        fout<<-1<<endl;
        return 0;
    }

    find(INF);
    K=val[n];
    if(K<k) fout<<0<<endl;
    else solve();

    return 0;
}