【2019牛客暑期多校训练营第四场 J题】【free】【最短路+DP】

最新推荐文章于 2020-06-28 15:46:42 发布

linbinwu123

最新推荐文章于 2020-06-28 15:46:42 发布

阅读量161

点赞数

CC 4.0 BY-SA版权

分类专栏： DP # 最短路图论文章标签： ACM 多校

本文链接：https://blog.youkuaiyun.com/weixin_44282912/article/details/99871250

DP 同时被 3 个专栏收录

17 篇文章

订阅专栏

图论

2 篇文章

订阅专栏

最短路

1 篇文章

订阅专栏

本文探讨了在无向图中寻找从起点到终点消除K条边的最短路径问题，提供了两种解法：一是使用动态规划，二是先求最短路径再调整。代码实现展示了优先队列和邻接表的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接：
https://ac.nowcoder.com/acm/contest/884/J
题意：
给一个无向图，求从起点S到达终点T最多可以消除K条边的最小路径长度。
题解：
解①：
这显然是一个DP题，设 $f [i] [j]$ 为从S到达 $i$ 点消除 $j$ 条边的最小路径长度，
状态转移方程为： $f [t o] [j] = m i n (f [t o] [j], m i n (f [f r o m] [j] + d i s [f r o m] [t o], f [f r o m] [j - 1]))$
边跑最短路边DP即可

解②:
这里还有种做法是直接跑最短路，然后将去掉最短路径上的K条路，剩下的路径求和即为答案。这个一开始想过，还以为是错的就想用DP来做，没有证明过。
代码：
解法1：

const int MAX = 1e3 + 10;
 
int N, M, S, T, K;
int dis[MAX][MAX];
 
struct edge {
    int nxt, to, w;
}e[MAX * 2];
 
int head[MAX], tot;
 
void add(int u, int v, int w) {
    e[++tot].nxt = head[u];
    e[tot].to = v;
    e[tot].w = w;
    head[u] = tot;
}
 
struct node {
    int u, d, k;
    bool operator <(const node& rhs) const {
        if (d == rhs.d)return k > rhs.k;
        return d > rhs.d;
    }
};
priority_queue<node> q;
 
 
void dijkstra(int s) {
    memset(dis, 0x3f, sz(dis));
    dis[s][0] = 0;
    q.push(node{ s,0,0 });
    while (!q.empty()) {
        node u = q.top(); q.pop();
        int k = u.k, now = u.u;
        for (int i = head[now]; i; i = e[i].nxt) {
            int to = e[i].to, w = e[i].w;
            if (dis[now][k] + w < dis[to][k])
                dis[to][k] = dis[now][k] + w, q.push(node{ to, dis[to][k], k });
            if (k + 1 <= K && dis[now][k] < dis[to][k + 1])
                dis[to][k + 1] = dis[now][k], q.push(node{ to, dis[to][k + 1], k + 1 });
        }
    }
}
 
int main() {
    tot = 0;
    scanf("%d%d%d%d%d", &N, &M, &S, &T, &K);
    for (int i = 1; i <= M; i++) {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        if (u == v)continue;
        add(u, v, w);
        add(v, u, w);
    }
    dijkstra(S);
    int ans = INF;
    for (int i = 0; i <= K; i++)ans = min(ans, dis[T][i]);
    printf("%d\n", ans);
    return 0;
}

解法2：

const int MAX = 1e3 + 10;
 
int N, M, S, T, K;
int dis[MAX], vis[MAX], pre[MAX], cost[MAX];
 
struct edge {
    int nxt, to, w;
}e[MAX * 2];
 
int head[MAX], tot;
 
void add(int u, int v, int w) {
    e[++tot].nxt = head[u];
    e[tot].to = v;
    e[tot].w = w;
    head[u] = tot;
}
 
struct node {
    int u, d;
    bool operator <(const node& rhs) const {
        return d > rhs.d;
    }
};
priority_queue<node> q;
 
 
void dijkstra(int s) {
    memset(dis, 0x3f, sz(dis));
    dis[s] = 0;
    q.push(node{ s,0 });
    while (!q.empty()) {
        node u = q.top(); q.pop();
        int now = u.u;
        if (vis[now])continue;
        vis[now] = 1;
        for (int i = head[now]; i; i = e[i].nxt)
            if (dis[now] + e[i].w < dis[e[i].to]) {
                dis[e[i].to] = dis[now] + e[i].w;
                pre[e[i].to] = now;
                cost[e[i].to] = e[i].w;
                if (!vis[e[i].to])
                    q.push(node{ e[i].to, dis[e[i].to] });
            }
    }
}
 
priority_queue<int, vector<int>, greater<int> > qq;
 
int main() {
    tot = 0;
    scanf("%d%d%d%d%d", &N, &M, &S, &T, &K);
    for (int i = 1; i <= M; i++) {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        if (u == v)continue;
        add(u, v, w);
        add(v, u, w);
    }
    dijkstra(S);
    for (int i = T; i != S; i = pre[i])qq.push(cost[i]);
    int cnt = max(0, (int)qq.size() - K), ans = 0;
    while (cnt--) {
        ans += qq.top(); qq.pop();
    }
    printf("%d\n", ans);
    return 0;
}