CodeForces - 543B Destroying Roads (Dijkstra + 堆优化 + 枚举重复部分)

题目

题意

有 $n$ 个城市，$m$ 条道路，问可删去多少条道路，使得删去后的图上，从 $s_1$ 到 $t_1$ 时间花费小于等于 $l_1$，从 $s_2$ 到 $t_2$ 时间花费小于等于 $l_2$。其中通过任意一条连接两个城市的道路的时间花费都为1

思路

要想删去的边尽可能多，其实也就是使得满足条件：“从 $s_1$ 到 $t_1$ 时间花费小于等于 $l_1$，从 $s_2$ 到 $t_2$ 时间花费小于等于 $l_2$” 的两条路上的总节点数尽可能的少。
我们可以使用堆优化的 $dijkstra$ 算法，预处理出图的最短路的邻接矩阵，然后枚举两条路可能重复的部分，计算每段重复部分对应的两条路的总长度。
其中处理出邻接矩阵的时间复杂度为$O\left( n^2\log\ n\right)$，枚举重复部分的复杂度为$O\left( n^2\right)$，所以总复杂度为$O\left(n^2\ + \ n^2\log\ n \right)$

代码

struct A{
    int u, v, w, next;
    bool operator < (const A & b) const{
        return w > b.w;
    }
}star[maxn<<2];

int u,v,w;
int dis[maxn][maxn], vis[maxn], head[maxn], eg;

void Init(){
    memset(vis, 0, sizeof vis);
    memset(head, -1, sizeof head);
    mm(dis, inf);
    eg = 0;
}

void Addedge(int u, int v, int w) {
    star[eg] = A {u, v, w, head[u]}, head[u] = eg++;
    u ^= v, v ^= u, u ^= v;
    star[eg] = A {u, v, w, head[u]}, head[u] = eg++;
}

void Dijkstra(int s) {
    mm(vis, 0);
    priority_queue<A>P;
    A t1, t2;
    t1.v = s;
    P.push(t1);
    dis[s][s] = 0;
    while(!P.empty()) {
        t1 = P.top();
        P.pop();
        int u = t1.v;
        if(vis[u]) continue;
        vis[u] = 1;
        for(int i=head[u]; ~i; i=star[i].next) {
            int v = star[i].v;
            if(!vis[v] && dis[s][v] > dis[s][u] + star[i].w){
                dis[s][v] = star[i].w + dis[s][u];
                t2.u = u;
                t2.v = v;
                t2.w = dis[s][v];
                P.push(t2);
            }
        }
    }
}


int main()
{
    int n, m, u, v, ans;
    int s1, t1, l1, s2, t2, l2;
    Init();
    sdd(n, m);
    rep(i, 0, m){
        sdd(u, v);
        Addedge(u, v, 1);
    }
    sddd(s1, t1, l1);
    sddd(s2, t2, l2);
    rep(i, 1, n+1){
        Dijkstra(i);
    }

    if(dis[s1][t1]>l1 || dis[s2][t2]>l2) ans = -1;
    else ans = dis[s1][t1] + dis[s2][t2];

    rep(i, 1, n+1){
        rep(j, 1, n+1){
            int ll1 = min(dis[s1][i]+dis[i][j]+dis[j][t1], dis[t1][i]+dis[i][j]+dis[j][s1]);
            int ll2 = min(dis[s2][i]+dis[i][j]+dis[j][t2], dis[t2][i]+dis[i][j]+dis[j][s2]);
            if(ll1>l1 || ll2>l2) continue;
            ans = min(ans, ll1+ll2-dis[i][j]);
        }
    }
    if(ans == -1) puts("-1");
    else pd(m-ans);
}

思考

由于本题说的是每条道路的花费均为1，所以可以使用 $bfs$ 在 $O(n^2)$ 的时间里处理出最短路的邻接矩阵，少掉了一个 $log$ 的时间。（学习自王聚聚）
而枚举重复部分的思想则来自于 “可使一条边的边权为0的最短路算法”