[codevs1021]玛丽卡

[codevs1021]玛丽卡

试题描述

麦克找了个新女朋友，玛丽卡对他非常恼火并伺机报复。

    因为她和他们不住在同一个城市，因此她开始准备她的长途旅行。

    在这个国家中每两个城市之间最多只有一条路相通，并且我们知道从一个城市到另一个城市路上所需花费的时间。

    麦克在车中无意中听到有一条路正在维修，并且那儿正堵车，但没听清楚到底是哪一条路。无论哪一条路正在维修，从玛丽卡所在的城市都能到达麦克所在的城市。

    玛丽卡将只从不堵车的路上通过，并且她将按最短路线行车。麦克希望知道在最糟糕的情况下玛丽卡到达他所在的城市需要多长时间，这样他就能保证他的女朋友离开该城市足够远。

编写程序，帮助麦克找出玛丽卡按最短路线通过不堵车道路到达他所在城市所需的最长时间(用分钟表示)。

输入

第一行有两个用空格隔开的数N和M，分别表示城市的数量以及城市间道路的数量。1≤N≤1000，1≤M≤N*(N-1)/2。城市用数字1至N标识，麦克在城市1中，玛丽卡在城市N中。

接下来的M行中每行包含三个用空格隔开的数A，B和V。其中1≤A，B≤N，1≤V≤1000。这些数字表示在A和城市B中间有一条双行道，并且在V分钟内是就能通过。

输出

输出文件的第一行中写出用分钟表示的最长时间，在这段时间中，无论哪条路在堵车，玛丽卡应该能够到达麦克处，如果少于这个时间的话，则必定存在一条路，该条路一旦堵车，玛丽卡就不能够赶到麦克处。

输入示例

5 7
1 2 8
1 4 10
2 3 9
2 4 10
2 5 1
3 4 7
3 5 10

输出示例

27

数据规模及约定

见“输入”

题解

从 n 开始跑一边最短路，然后再从 1 开始往回找“最短路图”，即走最短路必须经过的边和点。然后在这个“最短路图”上面找到“桥”，即一条边满足删去它，“最短路图”就会变成两个连通分量，显然只有在原图中删掉桥才可能让最短路变长，那么我们依次枚举删除哪个桥，再跑一边最短路，最终取最大值就好了。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <stack>
#include <vector>
#include <queue>
#include <cstring>
#include <string>
#include <map>
#include <set>
using namespace std;

const int BufferSize = 1 << 16;
char buffer[BufferSize], *Head, *Tail;
inline char Getchar() {
    if(Head == Tail) {
        int l = fread(buffer, 1, BufferSize, stdin);
        Tail = (Head = buffer) + l;
    }
    return *Head++;
}
int read() {
    int x = 0, f = 1; char c = Getchar();
    while(!isdigit(c)){ if(c == '-') f = -1; c = Getchar(); }
    while(isdigit(c)){ x = x * 10 + c - '0'; c = Getchar(); }
    return x * f;
}

#define maxn 1010
#define maxm 1000010
#define oo 2147483647
int n, m, head[maxn], next[maxm], to[maxm], dist[maxm];

void AddEdge(int a, int b, int c) {
	to[++m] = b; dist[m] = c; next[m] = head[a]; head[a] = m;
	swap(a, b);
	to[++m] = b; dist[m] = c; next[m] = head[a]; head[a] = m;
	return ;
}

struct Node {
	int u, d;
	Node() {}
	Node(int _, int __): u(_), d(__) {}
	bool operator < (const Node& t) const { return d > t.d; }
} ;
priority_queue <Node> Q;
bool vis[maxn], cant[maxm];
int d[maxn];
void Dijkstra(int s) {
	for(int i = 1; i <= n; i++) d[i] = oo;
	memset(vis, 0, sizeof(vis));
	d[s] = 0; Q.push(Node(s, 0));
	while(!Q.empty()) {
		int u = Q.top().u; Q.pop();
		if(vis[u]) continue;
		vis[u] = 1;
		for(int e = head[u]; e; e = next[e]) if(!cant[e] && d[to[e]] > d[u] + dist[e]) {
			d[to[e]] = d[u] + dist[e];
			if(!vis[to[e]]) Q.push(Node(to[e], d[to[e]]));
		}
	}
	return ;
}

bool on[maxm], vis2[maxn];
queue <int> q;
void Get(int s) {
	q.push(s); vis2[s] = 1;
	while(!q.empty()) {
		int u = q.front(); q.pop();
		for(int e = head[u]; e; e = next[e])
			if(d[to[e]] + dist[e] == d[u] && !vis2[to[e]]) {
				vis2[to[e]] = 1;
				on[e] = on[e+((e&1)?1:-1)] = 1;
				q.push(to[e]);
			}
	}
	return ;
}

int clo, pre[maxn], low[maxn], bri[maxn], cb;
void build(int u, int fa, int eid) {
	low[u] = pre[u] = ++clo;
	for(int e = head[u]; e; e = next[e]) if(on[e] && to[e] != fa) {
		if(!pre[to[e]]) {
			build(to[e], u, e);
			low[u] = min(low[u], low[to[e]]);
		}
		else low[u] = min(low[u], pre[to[e]]);
	}
	if(low[u] == pre[u] && eid) bri[++cb] = eid;
	return ;
}

int main() {
	n = read(); int m = read();
	for(int i = 1; i <= m; i++) {
		int a = read(), b = read(), c = read();
		AddEdge(a, b, c);
	}
	
	Dijkstra(n);
	Get(1);
	build(1, 0, 0);
	int ans = 0;
	for(int i = 1; i <= cb; i++) {
		int t = (bri[i] & 1) ? 1 : -1;
		cant[bri[i]] = cant[bri[i]+t] = 1;
		Dijkstra(n);
		ans = max(ans, d[1]);
		cant[bri[i]] = cant[bri[i]+t] = 0;
	}
	
	printf("%d\n", ans);
	
	return 0;
}

 

转载于:https://www.cnblogs.com/xiao-ju-ruo-xjr/p/6034735.html