题意：有T组测试数据，每组第一行先输入N，M，C表示有N个点和N层建筑，有M条双向边，你可以从x层的任意一个点到达x+1层和x-1层的任意一个点，但是需要C的花费。第二行输入N个数，表示第i个点在第l[i]层。然后输入这M条双向边，u，v，w表示u~v有一条权值为w的双向边。求1~N点的最短路。（0 <= N, M <= 10^5)
注意：你可以从x层的任意一个点到达x+1层和x-1层的任意一个点，但是这两层得有点才可以。比如有三个点三层建筑，0条双向边，第一个点在1层，第二个点在第二层，第三个点在第三层。 那么1点是无法到达3点得因为第二层没有点，1点也是无法到达2点得，因为第二层没有点作为中转，使1点到第二层得某一个点，在上到2点。
思路：建图跑一边Dijkstra即可，难在建图！我们正常想建图，M条双向边不用管直接添加即可，相邻层之间的点建立关系比较麻烦，直接能想到一定是把点在第几层都存一下，然后相邻两层之间的点建花费为C的双向边，但是这样会TLE，因为如果N=1e5，那么就有1e5个点和1e5层，假设有一半的点在第一层，一半的点在第二层，那么建图的时间复杂度为5e4*5e4=2.5e9，超时。所以我们得想办法把这个复杂度降下来，我想了半天也不会，看了看题解才明白。
M条边直接加就行可以了，就没在图上画出，相邻层之间点的关系建立有两种做法：
A做法：每层虚拟建立两个点，一个点使该层的点出去（左点），另一个点使其他层的点入到该层的点（右点）。那么该层的点到相邻层去只需要把该层虚拟出来的左点连接到相邻层的右点即可。我做了张图大家结合图理解。
圆表示建的虚拟点，长方形表示点，空心箭头花费为0，黑实线箭头和红实线箭头花费为C
B做法：每层虚拟建一个点，使相邻层入到该层。
圆表示建的虚拟点，长方形表示点，空心箭头花费为0，黑实线箭头和红实线箭头花费为C
A做法：多建了2*N个点，多建了4*N条边
B做法：多建了N个点，多建了5*N条边
PS：这个方法好像叫做拆点，不太清楚。。。
A代码：
#include<bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
const int INF = 0x3f3f3f3f;
struct Edge
{
int from, to, dist; //起点,终点,距离
Edge(int u, int v, int w):from(u), to(v), dist(w) {}
};
struct Dijkstra
{
int n, m; //结点数,边数(包括反向弧)
vector<Edge> edges; //边表。edges[e]和edges[e^1]互为反向弧
vector<int> G[MAXN]; //邻接表，G[i][j]表示结点i的第j条边在edges数组中的序号
int vis[MAXN]; //标记数组
int d[MAXN]; //s到各个点的最短路
int pre[MAXN]; //上一条弧
void init(int n)
{
this->n = n;
edges.clear();
for (int i = 0; i <= n; i++) G[i].clear();
}
void add_edge(int from, int to, int dist)
{
edges.push_back(Edge(from, to, dist));
m = edges.size();
G[from].push_back(m - 1);
}
struct HeapNode
{
int from, dist;
bool operator < (const HeapNode& rhs) const
{
return rhs.dist < dist;
}
HeapNode(int u, int w): from(u), dist(w) {}
};
void dijkstra(int s)
{
priority_queue<HeapNode> Q;
for (int i = 0; i <= n; i++) d[i] = INF;
d[s] = 0;
memset(vis, 0, sizeof(vis));
Q.push(HeapNode(s, 0));
while (!Q.empty())
{
HeapNode x = Q.top(); Q.pop();
int u = x.from;
if (vis[u]) continue;
vis[u] = true;
for (int i = 0; i < G[u].size(); i++)
{
Edge& e = edges[G[u][i]];
if (d[e.to] > d[u] + e.dist)
{
d[e.to] = d[u] + e.dist;
pre[e.to] = G[u][i];
Q.push(HeapNode(e.to, d[e.to]));
}
}
}
}
};
Dijkstra solve;
int layer[MAXN];
int main()
{
int T, n, m, c, CASE = 1;
scanf("%d", &T);
while (T--)
{
scanf("%d%d%d", &n, &m, &c);
solve.init(n * 3);
for (int i = 1; i <= n; i++)
{
int u; scanf("%d", &u);//第i个点在第u层
solve.add_edge(i, n + u, 0);//点与左虚拟点建单向边
solve.add_edge(2 * n + u, i, 0);//右虚拟点与点建单向边
}
for (int i = 1; i <= n; i++)
{
if (i != n) solve.add_edge(n + i, 2 * n + i + 1, c);//第i层左虚拟点与i+1层右虚拟点建单向边
if (i != 1) solve.add_edge(n + i, 2 * n + i - 1, c);//第i层左虚拟点与i-1层右虚拟点建单向边
}
while (m--)
{
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
//点与点之间的双向边
solve.add_edge(u, v, w);
solve.add_edge(v, u, w);
}
solve.dijkstra(1);
printf("Case #%d: ", CASE++);
int ans = solve.d[n];
if (ans != INF) printf("%d\n", ans);
else printf("-1\n");
}
return 0;
}
/*
2
3 3 3
1 3 2
1 2 1
2 3 1
1 3 3
3 3 3
1 3 2
1 2 2
2 3 2
1 3 4
*/B代码：
#include<bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
const int INF = 0x3f3f3f3f;
struct Edge
{
int from, to, dist; //起点,终点,距离
Edge(int u, int v, int w):from(u), to(v), dist(w) {}
};
struct Dijkstra
{
int n, m; //结点数,边数(包括反向弧)
vector<Edge> edges; //边表。edges[e]和edges[e^1]互为反向弧
vector<int> G[MAXN]; //邻接表，G[i][j]表示结点i的第j条边在edges数组中的序号
int vis[MAXN]; //标记数组
int d[MAXN]; //s到各个点的最短路
int pre[MAXN]; //上一条弧
void init(int n)
{
this->n = n;
edges.clear();
for (int i = 0; i <= n; i++) G[i].clear();
}
void add_edge(int from, int to, int dist)
{
edges.push_back(Edge(from, to, dist));
m = edges.size();
G[from].push_back(m - 1);
}
struct HeapNode
{
int from, dist;
bool operator < (const HeapNode& rhs) const
{
return rhs.dist < dist;
}
HeapNode(int u, int w): from(u), dist(w) {}
};
void dijkstra(int s)
{
priority_queue<HeapNode> Q;
for (int i = 0; i <= n; i++) d[i] = INF;
d[s] = 0;
memset(vis, 0, sizeof(vis));
Q.push(HeapNode(s, 0));
while (!Q.empty())
{
HeapNode x = Q.top(); Q.pop();
int u = x.from;
if (vis[u]) continue;
vis[u] = true;
for (int i = 0; i < G[u].size(); i++)
{
Edge& e = edges[G[u][i]];
if (d[e.to] > d[u] + e.dist)
{
d[e.to] = d[u] + e.dist;
pre[e.to] = G[u][i];
Q.push(HeapNode(e.to, d[e.to]));
}
}
}
}
};
Dijkstra solve;
int layer[MAXN];
bool v[MAXN];
int main()
{
int T, n, m, c, CASE = 1;
scanf("%d", &T);
while (T--)
{
memset(v, 0, sizeof(v));
scanf("%d%d%d", &n, &m, &c);
solve.init(n * 2);
for (int i = 1; i <= n; i++)
{
int u; scanf("%d", &layer[i]);//第i个点在第layer[i]层
v[layer[i]] = true;
}
for (int i = 1; i < n; i++)//层与层之间的虚拟点建边
{
if (v[i] && v[i + 1])//i和i+1层有点
{
solve.add_edge(n + i, n + i + 1, c);//第i层虚拟点与i+1层虚拟点建单向边
solve.add_edge(n + i + 1, n + i, c);//第i+1层虚拟点与i层虚拟点建单向边
}
}
for (int i = 1; i <= n; i++)//i号点与相邻层虚拟点之间建边
{
solve.add_edge(n + layer[i], i, 0);//左虚拟点与点建单向边
if (layer[i] != n) solve.add_edge(i, n + layer[i] + 1, c);//i号点与layer[i+1]层虚拟点建单向边
if (layer[i] != 1) solve.add_edge(i, n + layer[i] - 1, c);//i号点与layer[i-1]层虚拟点建单向边
}
while (m--)
{
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
//点与点之间的双向边
solve.add_edge(u, v, w);
solve.add_edge(v, u, w);
}
solve.dijkstra(1);
printf("Case #%d: ", CASE++);
int ans = solve.d[n];
if (ans != INF) printf("%d\n", ans);
else printf("-1\n");
}
return 0;
}
/*
2
3 3 3
1 3 2
1 2 1
2 3 1
1 3 3
3 3 3
1 3 2
1 2 2
2 3 2
1 3 4
*/
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
