架设电话线 题解

题目描述

原题来自：USACO 2008 Jan. Silver

在郊区有 $N$ 座通信基站，$P$ 条双向电缆，第 $i$ 条电缆连接基站 $A_i$ 和 $B_i$。特别地，$1$ 号基站是通信公司的总站，$N$ 号基站位于一座农场中。现在，农场主希望对通信线路进行升级，其中升级第 $i$ 条电缆需要花费 $L_i$。

电话公司正在举行优惠活动。农场主可以指定一条从 $1$ 号基站到 $N$ 号基站的路径，并指定路径上不超过 $K$ 条电缆，由电话公司免费提供升级服务。农场主只需要支付在该路径上剩余的电缆中，升级价格最贵的那条电缆的花费即可。求至少用多少钱能完成升级。

一句话题意，在加权无向图上求出一条从 $1$ 号结点到 $N$ 号结点的路径，使路径上第 $K+1$ 大的边权尽量小。

输入格式

第一行三个整数 $N,P,K$.

接下来 $P$ 行，每行三个整数 $A_i,B_i,L_i$.

输出格式

若不存在从 $1$ 到 $N$ 的路径，输出 -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

分析

看到最大的最小？那一定是二分。看到第 $K$ 大的最小？显然这还是二分。

我们可以直接二分答案。然后每次 $check$ 答案的时候，将所有的大于这个值的边的权值改为 $1$，其余的改为 $0$。其实就是标记了一下比当前枚举答案大的。

然后跑最短路，如果最短路跑出来小于 $K$ 则说明满足一条路径上二分的这个答案是第 $K+1$ 大的，反之则说明当前枚举的答案不是可行解。继续二分。

接下来我们看看详细复杂，啰嗦，累赘的代码。

AC代码

#include 
#include 
#include 
#include 
using namespace std;

int n, p, k;
struct edge {  // 结构体 边
    int v, cost;
    edge() {}
    edge(int V, int Cost) {
        v = V;
        cost = Cost;
    }
};
const int MAXN = 2005;
const int INF = 0x3f3f3f3f;
vector<edge> graph[MAXN];
int ma = 0;
bool flag = true;
int dist[MAXN];
bool vis[MAXN];
vector<edge> mp[MAXN];

void read(int &x) {  // 读优
    int k = 1;
    x = 0;
    char s = getchar();
    while (s < '0' || s > '9') {
        if (s == '-')
            k = -1;
        s = getchar();
    }
    while (s >= '0' && s <= '9') {
        x = (x << 1) + (x << 3) + (s - '0');
        s = getchar();
    }
    x *= k;
    return;
}

void Add_Edge(int u, int v, int cost) {  // 存边
    graph[u].push_back(edge(v, cost));
    graph[v].push_back(edge(u, cost));
}

void init(int x) {  // 初始化
    for (int i = 1; i <= n; i++) mp[i].clear();
    memset(dist, 0x3f, sizeof dist);
    memset(vis, 0, sizeof vis);
    for (int i = 1; i <= n; i++)
        for (int j = 0; j < graph[i].size(); j++) {
            int V = graph[i][j].v;
            int Cost = graph[i][j].cost;
            if (Cost > x) { // 跑最短路时的"01"图
                mp[i].push_back(edge(V, 1));
                mp[V].push_back(edge(i, 1));
            } else {
                mp[i].push_back(edge(V, 0));
                mp[V].push_back(edge(i, 0));
            }
        }
    //	for(int i = 1; i <= n; i++)
    //		for(int j = 0; j < mp[i].size(); j++)
    //			printf("%d %d %d\n", i, mp[i][j].v, mp[i][j].cost);
    return;
}

int dijkstra(int x) {  // dijkstra
    init(x);
    dist[1] = 0;
    for (int i = 1; i <= n; i++) {
        int k = 0, mi = INF;
        for (int j = 1; j <= n; j++)
            if (!vis[j] && dist[j] < mi) {
                mi = dist[j];
                k = j;
            }
        vis[k] = true;
        for (int j = 0; j < mp[k].size(); j++) {
            int V = mp[k][j].v, Cost = mp[k][j].cost;
            if (dist[k] + Cost < dist[V])
                dist[V] = dist[k] + Cost;
        }
    }
    return dist[n];
}

bool check(int mid) {  // 二分 判断可行性函数
    int t = dijkstra(mid);
    if (t == INF) {
        flag = false;
        return false;
    }
    if (t > k)
        return false;
    return true;
}

int Find() {  // 二分
    int l = 0, r = ma;
    while (l < r) {
        int mid = (l + r) >> 1;
        if (check(mid))
            r = mid;
        else {
            if (flag == false)
                return -1;
            l = mid + 1;
        }
    }
    return l;
}

int main() {
    read(n); read(p); read(k);
    for (int i = 1; i <= p; i++) {
        int u, v, cost;
        read(u); read(v); read(cost);
        Add_Edge(u, v, cost);
        ma = max(ma, cost);
    }
    printf("%d\n", Find());
    return 0;
}