题目
题意
有 n n 个城市, 条道路,问可删去多少条道路,使得删去后的图上,从 s1 s 1 到 t1 t 1 时间花费小于等于 l1 l 1 ,从 s2 s 2 到 t2 t 2 时间花费小于等于 l2 l 2 。其中通过任意一条连接两个城市的道路的时间花费都为1
思路
要想删去的边尽可能多,其实也就是使得满足条件:“从
s1
s
1
到
t1
t
1
时间花费小于等于
l1
l
1
,从
s2
s
2
到
t2
t
2
时间花费小于等于
l2
l
2
” 的两条路上的总节点数尽可能的少。
我们可以使用堆优化的
dijkstra
d
i
j
k
s
t
r
a
算法,预处理出图的最短路的邻接矩阵,然后枚举两条路可能重复的部分,计算每段重复部分对应的两条路的总长度。
其中处理出邻接矩阵的时间复杂度为
O(n2log n)
O
(
n
2
log
n
)
,枚举重复部分的复杂度为
O(n2)
O
(
n
2
)
,所以总复杂度为
O(n2 + n2log n)
O
(
n
2
+
n
2
log
n
)
代码
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
b
f
s
在
O(n2)
O
(
n
2
)
的时间里处理出最短路的邻接矩阵,少掉了一个
log
l
o
g
的时间。(学习自王聚聚)
而枚举重复部分的思想则来自于 “可使一条边的边权为0的最短路算法”