BZOJ 4289 PA2012 Tax 差分优化最短路建边

原创于 2018-09-11 21:30:13 发布 · 213 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

图论-最短路

本文介绍了一道 NOIP 2018 的最短路径问题，通过将点转化为边、边转化为点的方法，优化原始问题，采用排序和 Dijkstra 算法求解，最终实现 Θ(mlogm) 的复杂度。

题目链接戳我

首先可以看一下这篇博客… 讲的非常详细

首先发现边权并不是直接与边有关

有个比较显然的转化考虑把点当做边，边看成点

在新的图跑最短路那么就是最后的答案

这样做复杂度最坏到达 $\Theta(m^2)$ 一个菊花图就可以卡满复杂度

考虑优化建边首先考虑对于一个点的出边按照边权排序

从小到大往前连边，边权为两条边差值，这样子在新图中走的一条链恰好就是在原图中的选择两条边，并且边权累加起来也满足题目限制

大的边往小的连边权为0的因为大的边最大值显然就是它的边权了就不用去累其他的了

每一条边还要向自己对应的反向边连一条权值为自身的边这样子跑 $Dijkstra$ 就可以过了

复杂度 $\Theta(mlogm)$

Codes

#include<bits/stdc++.h>

#define mp make_pair
#define pb push_back
#define x first
#define y second

using namespace std;

typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, int> PLI;

const int N = 1e5 + 10;
const int M = 4e5 + 10;

int to[M], head[N], nxt[M], v[M], e = 1;
int n, m, s, t;

vector<PII> G[M]; PII tmp[M]; ll dis[M];

template<class T>inline bool chkmin(T &_, T __) {return _ > __ ? _ = __, 1 : 0;}

void add(int x, int y, int z) {
    to[++ e] = y; nxt[e] = head[x]; head[x] = e; v[e] = z;
}

ll Dijkstra() {
    priority_queue<PLI, vector<PLI>, greater<PLI>> q;
    for(int i = 1; i <= t; ++ i) dis[i] = 1e18;
    q.push(mp(dis[s] = 0, s));
    while(!q.empty()) {
        PLI k = q.top(); q.pop();
        if(k.x > dis[k.y]) continue;
        for(auto v : G[k.y]) {
            if(chkmin(dis[v.y], k.x + v.x))
                q.push(mp(dis[v.y], v.y));
        }
    }
    return dis[t];
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("illness.in", "r", stdin);
    freopen("illness.out", "w", stdout);
#endif
    int x, y, z, cnt = 0;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= m; ++ i) {
        scanf("%d%d%d", &x, &y, &z);
        add(x, y, z), add(y, x, z);
        // ziji lian ziji
        G[e].pb(mp(z, e ^ 1));
        G[e ^ 1].pb(mp(z, e));
    }
    s = e + 1, t = s + 1;
    for(int i = head[1]; i; i = nxt[i])
        G[s].pb(mp(v[i], i)); // qidian
    for(int i = head[n]; i; i = nxt[i])
        G[i ^ 1].pb(mp(v[i], t)); //zhongdian
    for(int k = 1; k <= n; ++ k, cnt = 0) {
        for(int i = head[k]; i; i = nxt[i])
            tmp[++ cnt] = mp(v[i], i);
        sort(tmp + 1, tmp + cnt + 1);
        for(int i = 1; i < cnt; ++ i) {
            G[tmp[i].y].pb(mp(tmp[i + 1].x - tmp[i].x, tmp[i + 1].y));
            G[tmp[i + 1].y].pb(mp(0, tmp[i].y));
        }
    }
    printf("%lld\n", Dijkstra());
    return 0;
}