LA4080 Warfare And Logistics

最新推荐文章于 2021-07-29 06:59:58 发布

原创最新推荐文章于 2021-07-29 06:59:58 发布 · 1.3k 阅读

1 ·

CC 4.0 BY-SA版权

图论专栏收录该内容

25 篇文章

订阅专栏

本文详细介绍了如何使用SPFA和Dijkstra算法解决带权图中的最短路问题，通过实例分析了算法的应用场景及优化策略。

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

微微发亮的传送门

又来一弹白书例题，发现……往往是不看题解我是做不出来题的。。sad……

首先这道题很容易让人一冲动就用floyd来解了，可是，明显folyd的复杂度我们是无法接受的，100个结点加上1000条边，一定会超时的，那么有关最短路的就剩下一个spfa和dijkstra了，其实dijkstra或者spfa对于每一个起点，都能求出来一棵树，暂且称它为最短路树，对于这课树上的结点，如果我们不破坏这棵树上的边，那么就不用重新求任何一条最短路，如果破坏了其中一条边，那只需要对于那条边对应的根结点重新求一次就行了，注意重边的处理就行了。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
const int INF = 0x7fffffff;
const int maxn = 100 + 10;
struct Edge{
	int from, to, dist;
};
struct HeapNode{
	int d, u;
	bool operator < (const HeapNode& rhs) const {
		return d > rhs.d;
	}
};
struct Dijkstra{
	int n, m;
	vector<Edge> edges;
	vector<int> G[maxn];
	bool done[maxn];
	int p[maxn], d[maxn];
	void init(int n){
		this -> n = n;
		for (int i = 0; i < n; i++)
			G[i].clear();
		edges.clear();
	}
	void AddEdge(int from, int to, int dist){
		edges.push_back((Edge){from, to, dist});
		m = edges.size();
		G[from].push_back(m - 1);
	}
	void dijkstra(int s){
		priority_queue<HeapNode> que;
		for (int i = 0; i < n; i++)
			d[i] = INF;
		d[s] = 0;
		memset(done, 0, sizeof(done));
		que.push((HeapNode){0, s});
		while(!que.empty()){
			HeapNode x = que.top(); que.pop();
			int u = x.u;
			if (done[u]) continue;
			done[u] = 1;
			for (int i = 0; i < G[u].size(); i++){
				Edge& e = edges[G[u][i]];
				if (e.dist >= 0 && d[e.to] > d[u] + e.dist){
					d[e.to] = d[u] + e.dist;
					p[e.to] = G[u][i];
					que.push((HeapNode){d[e.to], e.to});
				}
			}
		}
	}
};
Dijkstra solver;
int n, m, L;
vector<int> gr[maxn][maxn];
int used[maxn][maxn][maxn];
int idx[maxn][maxn];
int sum_single[maxn];
int compute_c(){
	int ans = 0;
	memset(used, 0, sizeof(used));
	for (int src = 0; src < n; src++){
		solver.dijkstra(src);
		sum_single[src] = 0;
		for (int i = 0; i < n; i++){
			if (i != src){
				int fa = solver.edges[solver.p[i]].from;
				used[src][fa][i] = used[src][i][fa] = 1;
			}
			sum_single[src] += (solver.d[i] == INF ? L : solver.d[i]);
		}
		ans += sum_single[src];
	}
	return ans;
}
int compute_newc(int a, int b){
	int ans = 0;
	for (int src = 0; src < n; src++)
		if (!used[src][a][b]) ans += sum_single[src];
		else{
			solver.dijkstra(src);
			for (int i = 0; i < n; i++)
				ans += (solver.d[i] == INF ? L : solver.d[i]);
		}
	return ans;
}
int main(){
//	freopen("in.txt", "r", stdin);
	while(~scanf("%d%d%d", &n, &m, &L)){
		solver.init(n);
		for (int i = 0; i < n; i++)
			for (int j = 0; j < n; j++)
				gr[i][j].clear();
		for (int i = 0; i < m; i++){
			int x, y, z;
			scanf("%d%d%d", &x, &y, &z);
			x -= 1; y -= 1;
			gr[x][y].push_back(z);
			gr[y][x].push_back(z);
		}
		for (int i = 0; i < n; i++)
			for (int j = i + 1; j < n; j++)
				if (!gr[i][j].empty()){
					sort(gr[i][j].begin(), gr[i][j].end());
					solver.AddEdge(i, j, gr[i][j][0]);
					idx[i][j] = solver.m - 1;
					solver.AddEdge(j, i, gr[i][j][0]);
					idx[j][i] = solver.m - 1;
				}
		int c = compute_c(), c2 = -1;
		for (int i = 0; i < n; i++)
			for (int j = i + 1; j < n; j++)
				if (!gr[i][j].empty()){
					int& e1 = solver.edges[idx[i][j]].dist;
					int& e2 = solver.edges[idx[j][i]].dist;
					if (gr[i][j].size() == 1) e1 = e2 = -1;
					else e1 = e2 = gr[i][j][1];
					c2 = max(c2, compute_newc(i, j));
					e1 = e2 = gr[i][j][0];
				}
		printf("%d %d\n", c, c2);
	}
	return 0;
}