POJ-1511 Invitation Cards (SPFA+邻接表)

最新推荐文章于 2020-08-01 15:06:44 发布

Accsc

最新推荐文章于 2020-08-01 15:06:44 发布

阅读量240

点赞数 1

分类专栏：最短路

本文链接：https://blog.csdn.net/Accsc/article/details/82501413

版权

最短路专栏收录该内容

3 篇文章 0 订阅

订阅专栏

这个题主要的点在于数据量过大（以及题目废话过多），然后就带来了储存上的不便，用刘汝佳紫书上喜欢用的vector那样会因为直接超时，然后简单的邻接矩阵在VS中直接提示数组过大....所以一个好的方案是数组模拟链表实现邻接表。这样做比直接使用链表的好处在于节省了反复申请释放内存所消耗的可观的时间。

然后对于这种百万级别的数据，简单的bellman-ford或者dijkstra应该会超时，所以这里选择了队列优化Bellman-Ford(即SPFA），堆优化dij应该也可以。

这是一个来回最短路问题，所以需要以1为源点进行两次SPFA，分别对来回的最短路进行计算。其中一次是顺着有向边的方向进行（计算从源点出发的最短路），另一次逆着有向边进行（计算从其他点回到源点的最短路）。

代码如下

#include<cstdio>
#include<cstring>
#include<queue>
#define maxn 1000001
#define maxm 1000001
using namespace std;
typedef long long ll;
struct Edge
{
	int u, v, w;
} edge[maxm];
int head[2][maxn], nxt[2][maxm];
ll d[2][maxn],ans;
//上面的head表示头节点指针，nxt表示对应位置的下一节点
//d储存最短路长度，edge储存边
//head，nxt，d都是二维的，便于计算来回路径
queue<int> q;
bool inq[maxn];
int n, m;
void spfa(int dir)
{
	memset(inq + 1, 0, sizeof(bool)*n);
	memset(d[dir]+ 1, 0x3f, sizeof(ll)*n);
	d[dir][1] = 0;
	inq[1] = true;
	q.push(1);
	while (!q.empty())
	{
		int t = q.front(); q.pop();
		inq[t] = false;
		for (int cur = head[dir][t]; cur != -1; cur = nxt[dir][cur])
		{
			Edge& e = edge[cur];
			int v = t == e.u ? e.v : e.u;//表示该边的另一个顶点
			if (d[dir][v] > d[dir][t] + e.w)
			{
				d[dir][v] = d[dir][t] + e.w;
				if (!inq[v])
				{
					inq[v] = true;
					q.push(v);
				}
			}
		}
	}
}
int main()
{
	int T;
	scanf("%d", &T);
	while (T--)
	{
		scanf("%d%d", &n, &m);
		memset(head[0] + 1, -1, sizeof(int)*n);
		memset(head[1] + 1, -1, sizeof(int)*n);
		for (int i = 0,u,v; i < m; i++)
		{
			scanf("%d%d%d", &u, &v,&edge[i].w);
			edge[i].u = u; edge[i].v = v;
                    //头插法插入新节点
			nxt[0][i] = head[0][u];
			nxt[1][i] = head[1][v];
			head[0][u] = head[1][v] = i;
		}
		spfa(0);//出发
		spfa(1);//归来
		ans = 0;
		for (int i = 1; i <= n; i++) ans += d[0][i] + d[1][i];
		printf("%lld\n", ans);
	}
	return 0;
}