最短路合集

最短路合集

前言

这里面有最短路的好多好多应用，不要错过啊

dij板子

看这里

拓展

一。分层图

看这里

二。最小路径树

这个不是最小生成树，这个要求的是我们在图上找的这棵树的每一个点到源点的距离都是原原来的最小路的长度，并且这个树的边权和要最小

这个可以用找前驱的方法去处理，也就是我们每一次松弛的时候都去记录是哪个边松弛了这个点，最后用dfs去找这棵树。
注意这里有一个细节就是在松弛的时候if( dis[to[i]]>=dis[g]+val[i]) 这里加上“=”其实就是省略了一次判断，就是看这个图

里面从1—> 5是不是有两条都是最短路，但是我们发现

这一条是4

这一条是5

所以我们是不是就会出现漏洞，所以这里有人就会看看这个val[i] 的值和原来比大小，保留小的作为前驱，但是其实没有必要，我们的dij使用了堆去优化，假如说我们现在新出来了一个点，用这个点去松弛点a的值和之前一样，说明什么，是不是这个边权一定比之前的小，因为是小根堆，所以就可以少一句判断（当然是不过好些了一点）

最后上代码

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
#define re register
const int maxn=3e5+5;
#define INF 0x3f3f3f3f3f3f3f3f

int head[maxn],to[maxn<<1],nxt[maxn<<1],cnt;

ll w[maxn<<1];

inline void add(int u,int v,ll val){
    nxt[++cnt]=head[u];
    to[cnt]=v;
    w[cnt]=val;
    head[u]=cnt;
}

int pre[maxn];

bool vis[maxn];

ll dis[maxn],ans[maxn];

#define P pair<ll,int>
#define mp make_pair

inline void Dijkstra(int s){
    priority_queue <P,vector<P>,greater<P> > q;
    memset(vis,0,sizeof(vis));
    memset(dis,0x3f,sizeof(dis));
    dis[s]=0;
    q.push(mp(0,s));
    while(!q.empty()){
        int x=q.top().second;q.pop();
        if(vis[x])continue;
        vis[x]=true;
        for(re int i=head[x];i;i=nxt[i]){
            int v=to[i];
            if(dis[v]>=dis[x]+w[i]){
                dis[v]=dis[x]+w[i];
                pre[v]=i;
                q.push(mp(dis[v],v));
            }
            //else if(!vis[v]&&dis[v]==dis[x]+w[i]&&w[i]<w[pre[v]])pre[v]=i;这是别的blog上面常常写的
        }
    }
}

int n,m,s;

inline ll read(){
    ll x=0,f=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+(ch^48);ch=getchar();}
    return x*f;
}

int main(){
#ifdef LawrenceSivan
    freopen("aa.in","r",stdin);
    freopen("aa.out","w",stdout);
#endif
    n=read();m=read();
    for(re int i=1,x,y;i<=m;i++){
        ll val;
        x=read();y=read();val=read();
        add(x,y,val);
        add(y,x,val);
    }

    s=read();

    Dijkstra(s);

    ll sum=0,tot=0;
    for(re int i=1;i<=n;i++){
        if(i==s)continue;
        int pos=pre[i];
        sum+=w[pos];
        ans[++tot]=pos;
    }

    printf("%lld\n",sum);

    for(re int i=1;i<=tot;i++){
        printf("%lld ",(ans[i]+1)/2);
    }

    return 0;
}

三。次短路

其实这种次短路有两种，1.是可以和最短路有相同的边 2.是不可以和最短路有相同的边

先来讲一下第二种，首先我们这种算法其实就算是魔改dijk，首先在对于dij进行松弛的时候，我们顺便去维护一个second distance 这个数组的值肯定是要分类讨论去赋值的，之后就是dijk的经典操作了

具体实现看代码就好

之后再来说一说允许有相同的路的，首先在对于松弛操作时，我们假如更新了最短路那么显然是要入堆的，那么假如我们更新了次短路，是不是也要入堆就可以保证之后还会去松弛其他的最短路，这就是这个算法的思想

#include<bits/stdc++.h>
using namespace std;
int n,m;
const int maxn=100005;
int head[2*maxn],to[2*maxn],nex[2*maxn],val[2*maxn],num=0;

void add(int x,int y,int z){
	to[++num]=y;
	nex[num]=head[x];
	head[x]=num;
	val[num]=z;
}

int fds[5005],sds[5005];
const int inf=1e6;
priority_queue<pair<int,int> >q;

int a[6];

void dijk(int x){
	for(int i=1;i<=n;i++) fds[i]=inf,sds[i]=inf;
	fds[x]=0,sds[x]=inf;
	q.push(pair<int,int>(-0,x));
	while(!q.empty()){
		int g = -q.top().first;
		int z = q.top().second;
		q.pop();
		//if(fds[z] < g) continue;
		for(int i=head[z];i;i=nex[i]){
			int u = to[i];
			int x = fds[u];
			a[1] = val[i] + fds[z];
			a[2] = sds[z] + val[i];
			a[3] = fds[u];
			a[4] = sds[u];
			sort(a+1,a+5);
			fds[u] = a[1];
			int fd=1;
			while(a[fd] == a[1])++fd;
			int po = sds[u];
			sds[u] = a[fd];
			if(fds[u] < x)
				q.push(pair<int,int>(-a[1],u));
			else if(sds[u] != po)q.push(pair<int,int>(-a[fd],u));
			//这个是允许有相同的边的代码
		}
	}
}

int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++){
		int a,b,c;
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c);
		add(b,a,c);
	}
	dijk(1);
	cout<<sds[n]<<"\n";
	return 0;
}

spfa

这里有板子，也有差分约束的一些内容

ps
差分约束时，求最小值跑最长路，求最大值跑最小路

floyd

板子+传递闭包

后记

当然还没有完，我还会给这篇博客上继续加东西的。。

杂题一 P6822 [PA2012] Tax。
这是一个经典的套路题，首先就是这个题最短路算法是跑不掉了，但是我们发现，这个题经过每一个点的权值是不确定的，所以我们转化一下，点看为边，边看为点，那么就要建立超级原点和汇点，所有由起点指出去的边都和源点相连，所有进入终点的边都和汇点相连，所以最短路就是dis【汇点】，这样边权就是确定的了，之后就是发现边权过大，所以就用差分优化，最后代码懒得写了。