标签：tmp build 正序 cpp bool a算法 结束 闭包 初始
优先队列版本已经烂大街了，这里就不贴了，而且在下面的分层图里有写
时间和内存均是优先队列优化版本的 $\frac{1}{2}$
int n, m;
struct edge {
int to, w, nxt;
edge() {}
edge(int t, int ww, int nn) {to = t, w = ww, nxt = nn;}
}e[maxn << 1];
int head[maxn], k = 0;
void add(int u, int v, int w) {e[k] = edge(v, w, head[u]); head[u] = k++;}
ll ans[maxn];
struct node {
ll dis; int x;
node() {}
node(ll d, int xx) {dis = d, x = xx;}
}dis[maxn << 2];
//建树初始化，主要是编号也要返回所以要先预处理一下
void build(int p, int l, int r) {
if(l == r) {dis[p].x = l; return;}
int mid = l + r >> 1;
build(p << 1, l, mid); build(p << 1 | 1, mid + 1, r);
dis[p].x = dis[p << 1].x;
}
void change(int p, int l, int r, int x, int y) {
if(l == r) {dis[p].dis = y; return;}
int mid = l + r >> 1;
if(x <= mid) change(p << 1, l, mid, x, y);
else change(p << 1 | 1, mid + 1, r, x, y);//单点修改的板子操作
if(dis[p << 1].dis < dis[p << 1 | 1].dis) dis[p] = dis[p << 1];
else dis[p] = dis[p << 1 | 1];
}
//因为用距离得到最小，但是需要的是编号，所以返回node
node ask(int p, int l, int r, int ls, int rs) {
if(ls <= l && r <= rs) {return dis[p];}
int mid = l + r >> 1; node ans = node(inf, 0), tmp;
if(ls <= mid) ans = ask(p << 1, l, mid, ls, rs);
if(rs > mid) {
node tmp = ask(p << 1 | 1, mid + 1, r, ls, rs);
if(ans.dis > tmp.dis) ans = tmp;
}
return ans;
}
int S;
void dij() {
for(int k = 1; k < n; k++) {//n-1次够用的。虽然我也不知道为什么最后n次跑的比n-1次还要快……
register int u = ask(1, 1, n, 1, n).x;
for(int i = head[u]; ~i; i = e[i].nxt) {
register int v = e[i].to;
if(ans[u] + e[i].w < ans[v]) {//最短路更新
ans[v] = ans[u] + e[i].w, change(1, 1, n, v, ans[v]);//单点修改
}
}
change(1, 1, n, u, inf);//取出来过后要赋值INF，以免再次取用
}
}
int main() {
memset(head, -1, sizeof head);
n = read(), m = read(), S = read();
for(int u, v, w, i = 1; i <= m; i++) u = read(), v = read(), w = read(), add(u, v, w);
//初始化
for(int i = 1; i <= (n << 2); i++) dis[i].dis = inf;
for(int i = 1; i <= n; i++) ans[i] = inf;
//线段树初始化，dis是线段树，ans是答案
build(1, 1, n);
change(1, 1, n, S, 0); ans[S] = 0;
dij();
for(int i = 1; i <= n; i++) printf("%lld ", ans[i]);
return 0;
}
时间和内存均是优先队列优化版本的 $\frac{1}{4}$ %%%
#define rep(I, A, B) for (int I = (A); I <= (B); ++I)
#define dwn(I, A, B) for (int I = (A); I >= (B); --I)
#define erp(I, X) for (int I = head[X]; I; I = next[I])
const int maxn = 1e5 + 207, maxm = 2e5 + 207, inf = INT_MAX;
int v[maxm], w[maxm], head[maxn], next[maxm], tot;
int dist[maxn], mp[maxn << 2], M = 1;
int n, m, s;
template <typename T> inline void read(T& t) {
int f = 0, c = getchar(); t = 0;
while (!isdigit(c)) f |= c == ‘-‘, c = getchar();
while (isdigit(c)) t = t * 10 + c - 48, c = getchar();
if (f) t = -t;
}
template <typename T> void write(T x) {
if (x < 0) x = -x, putchar(‘-‘);
if (x > 9) write(x / 10);
putchar(x % 10 + 48);
}
inline void ae(int x, int y, int z) { v[++tot] = y; w[tot] = z; next[tot] = head[x]; head[x] = tot; }
inline int cmp(int a, int b) { return dist[a] < dist[b] ? a : b; }
inline void build(int n) {
while (M < n + 2) M <<= 1;
mp[0] = n + 1;
}
inline void modify(int x, int nv) {
for (int i = x + M; dist[mp[i]] > nv; i >>= 1)
mp[i] = x;
dist[x] = nv;
}
inline void del(int x) {
for (mp[x += M] = 0, x >>= 1; x; x >>= 1)
mp[x] = cmp(mp[x << 1], mp[x << 1 | 1]);
}
inline void dijkstra(int s) {
rep(i, 0, n) dist[i] = inf;
build(n); modify(s, 0);
rep(t, 1, n - 1) {
int x = mp[1]; del(x);
erp(i, x) if (dist[v[i]] > dist[x] + w[i])
modify(v[i], dist[x] + w[i]);
}
}
int main() {
read(n),read(m),read(s);
rep(i, 1, m) {
int x, y, z; read(x),read(y),read(z); ae(x, y, z);
}
dijkstra(s);
rep(i, 1, n) write(dist[i]), putchar(‘ ‘);
puts("");
return 0;
}
白书上的代码，没有优化是$O(n^2)$，正序输出最短路径
/*如果需要输出路径
可以用一个prev[ j ]来记录最短路上顶点 j 的前驱，
那么在o(|V|)的时间内完成最短路径的恢复。
在d[ j ]被d[ j ] = d[ k ] + cost[ k ][ j ]更新时，
修改prev[ j ] = k，这样就可以求出来prev的数组，
可以在以上算法中用路径前驱标记法来还原出来路径。*/
int cost[MAX_V][MAX_V]; //cost[u][v]表示边e=(u, v)的权值（不存在这条边时设为INF）
int d[MAX_V]; //从顶点s出发的最短距离
bool used[MAX_V]; //已经使用过的图中的点
int V; //顶点数
int prev[MAX_V]; //记录前驱点
//从s出发到各个顶点的距离
void dijkstra(int s)
{
fill(d, d + V, INF); //初始化
fill(used, used + V, false); //初始化
fill(prev, prev + V, -1);
d[s] = 0;
while(true)
{
int v = -1;
for(int u = 0; u < V; u++){
if(!used[u] && (v == -1 || d[u] < d[v])) v = u;
// 从尚未使用过的顶点中选择一个距离最小的顶点
}
if(v == -1) break; //没有可跟新的了，结束
used[v] = true;
for(int u = 0; u < V; u++){
d[u] = min(d[u], d[v] + cost[u][v]); //因为加入了一个点V所以所有的d都要再更新一遍
prev[u] = v;
}
}
}
vector<int> get_path(int t) //到顶点t的最短路
{
vector<int> path;
for(; t != -1; t = prev[t])
path.push_back(t);
reverse(path.begin(), path.end());
return path;
}
SPFA要谨慎使用！
int nex[M],ver[M],head[N],edge[M],tot;
void add(int u,int v,int val){
ver[++tot] = v;
edge[tot] = val;
nex[tot] = head[u];
head[u] = tot;
}
queue<int>q;
bool vis[N];
int d[N];
int n,m;
void spfa(int s){
//memset(d,0x3f,sizeof d);
for(int i = 1; i<= n;++i)
d[i] = 2147483647;
memset(vis,0,sizeof vis);
d[s] = 0;
vis[s] = 1;
q.push(s);
while(q.size()){
int x = q.front();
q.pop();
vis[x] = 0;
//扫描所有出边
for(int i = head[x];i;i = nex[i]){
int y = ver[i];
int z = edge[i];
if(d[y] > d[x] + z){
d[y] = d[x] + z;
if(!vis[y])//不在堆里就入堆并标记一下
q.push(y),vis[y] = 1;
}
}
}
}
int s;
int main()
{
cin>>n>>m>>s;
over(i,1,m){
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
add(x,y,z);
}
spfa(s);
over(i,1,n){
printf("%d ",d[i]);
}
return 0;
}
分成$k+1$层图
const int INF = 0x3f3f3f3f;
const int N = 6e5+7;
int nex[N],ver[N],head[N],edge[N],tot;
int n,m,k,s,t;
int dist[N];
bool vis[N];
void init(){
memset(head,-1,sizeof head);
tot = 0;
memset(dist,0x3f,sizeof dist);
memset(vis,0,sizeof vis);
}
void add(int u,int v,int val){
ver[++tot] = v;
edge[tot] = val;
nex[tot] = head[u];
head[u] = tot;
}
void dijkstra(){
priority_queue<PII,vector<PII>,greater<PII> >q;
dist[1] = 0;
//vis[s] = 1;dijkstra和spfa不一样！这里不用标记，不然就走不动啦
q.push({dist[1],1});
while(q.size()){
PII now = q.top();//这种声明的变量后面不要用逗号运算符！！！
q.pop();
int u = now.second;
if(vis[u])continue;
vis[u] = 1;
for(int i = head[u]; i != -1 ;i = nex[i]){
int v = ver[i],val = edge[i];
if(!vis[v] && dist[v] > dist[u] + val){
dist[v] = dist[u] + val;
q.push({dist[v],v});
}
}
}
}
int main()
{
init();
scanf("%d%d%d",&n,&m,&k);
over(i,1,m){
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
for(int j = 0;j <= k;++j){
add(x + j * n,y + j * n,z);//这一层和这一层连起来
add(y + j * n,x + j * n,z);
if(j != k){//只要还有就这一层和下一层连起来，并且权值为0
add(x + j * n,y + (j + 1) * n,0);
add(y + j * n,x + (j + 1) * n,0);
}
}
}
dijkstra();
int ans = INF;//dijkstra只是更新了一个dis数组，答案需要我们自己找
over(i,0,k)
ans = min(ans,dist[n + i * n]);
printf("%d\n",ans);
return 0;
}
这里是因为题目要求的答案是第k+1的权值最小，所以只求单条路径的权值即可，但是这样的更新并不能满足dijkstra的贪心性质，所以我们要选择SPFA算法。
/*POJ 3662 Telephone Lines*/
const int N = 3e3;
const int M = 5e4+7;//注意这里数据范围要用M
int d[N][N];
int n,m,k;
int nex[M],ver[M],head[N],edge[M],tot;
void add(int u,int v,int val){
ver[++tot] = v;
edge[tot] = val;
nex[tot] = head[u];
head[u] = tot;
}
queue<int>q;
bool vis[N];
void spfa(int s){
memset(d,0x3f,sizeof d);
memset(vis,0,sizeof vis);
d[s][0] = 0;
vis[s] = 0;
q.push(s);
while(q.size()){
int x = q.front();
q.pop();
vis[x] = 0;
for(int i = head[x];i;i = nex[i]){
int y = ver[i],z = edge[i];
int w = max(d[x][0],z);//不同于往常的是每一条路径的 最大边 是这条路径的花费
if(d[y][0]>w){//先算普通的最短路
d[y][0] = w;
if(!vis[y])
q.push(y),vis[y] = 1;
}
//反正就是动规，暴力所有状态转移取最小，状态转移的方式就是可以免费。
//每次对每种路径都取一次最优
for(int p = 1;p <= k;++p){//然后再看免费的，不一定是几条边最优//不管怎么说肯定是从前往后地推出的
int w = min(d[x][p-1],max(d[x][p],z));//使最大边最小//主要这里的答案都是一条边的权值
//当前的状态是从x转移到y，其中这条边免费或者不免费
if(d[y][p] > w){
d[y][p] = w;
if(!vis[y])
q.push(y),vis[y] = 1;
}
}
}
}
}
int main(){
cin>>n>>m>>k;
over(i,1,m){
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
add(x,y,z);
add(y,x,z);
}
spfa(1);
int ans = 1e9+7;
over(i,0,k){//注意是从0开始，因为也可以不选
//就真答案并不在掌握之中
//其实就是分层图，应该是 k + 1 层
ans = min(ans,d[n][i]);
}
if(ans == 1e9+7)
puts("-1");
else printf("%d\n",ans);
return 0;
}
Floyd算法
设$D[k,i,j]$表示“经过若干个编号不超过k的结点”从i到j的最短路长度。
Floyd算法的实质是动态规划。
k是阶段，所以必须放在最外层循环。
i和j是附加状态，应该放置于内层循环。
int dis[1000][1000],n,m;
int main()
{
cin>>n>>m;
memset(dis,0x3f,sizeof dis);
for(int i = 1;i <= n;++i)
dis[i][i] = 0;
for(int i = 1;i <= m;++i){
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
dis[x][y] = min(dis[x][y],z);//可能会重复
}
for(int k = 1;k <= n;++k)
for(int i = 1;i <= n;++i)
for(int j = 1;j <= n;++j)
dis[i][j] = min(dis[i][j],dis[i][k] + dis[k][j]);
for(int i = 1;i <= n;++i)
for(int j = 1;j <= n;++j)
printf("%d ",dis[i][j]);
return 0;
}
使用Floyd实现的传递闭包
int dis[1000][1000],n,m;
int main()
{
cin>>n>>m;
for(int i = 1;i <= n;++i)
dis[i][i] = 1;
for(int i = 1;i <= m;++i){
int x,y;
scanf("%d%d",&x,&y);
dis[x][y] = dis[y][x] = 1;
}
for(int k = 1;k <= n;++k)
for(int i = 1;i <= n;++i)
for(int j = 1;j <= n;++j)
dis[i][j] |= dis[i][k] & dis[k][j];
//把整个关系梳理出来
}
最短路合集（分层图最短路、传递闭包、路径还原、k短路...）
标签：tmp build 正序 cpp bool a算法 结束 闭包 初始
原文地址：https://www.cnblogs.com/m2362/p/13170203.html
