kuangbin最短路 模板

kuangbin最短路 模板

//floyd
//复杂度O(N^2)
#include<iostream>
#include<cstdio>

using namespace std;

const int INF=0x3f3f3f3f;
const int MAXN=1e3+50;

int mapp[MAXN][MAXN];
int N,M;

int main()
{
	scanf("%d%d",&N,&M);
	for(int i=1;i<=N;i++){
		for(int j=1;j<=M;j++){
			if(i==j){
				mapp[i][j]=0;
			}else{
				mapp[i][j]=INF;
			}
		}
	}
	int u,v,w;
	for(int i=1;i<=M;i++){
		scanf("%d%d%d",&u,&v,&w);
		mapp[u][v]=w;
	}
	for(int k=1;k<=N;k++){
		for(int i=1;i<=N;i++){
			for(int j=1;j<=N;j++){
				if(mapp[i][j]>mapp[i][k]+mapp[k][j]){
					mapp[i][j]=mapp[i][k]+mapp[k][j];
				}
			}
		}
	}
	for(int i=1;i<=N;i++){
		for(int j=1;j<=N;j++){
			printf("%10d",mapp[i][j]);
		}
		printf("\n");
	}
	return 0;
}

 

//Dijkstra单源最短路+路径输出
//邻接矩阵复杂度O(N^2)
#include<iostream>
#include<cstdio>
#include<algorithm>
 
using namespace std;
 
const int maxn=1010;
 
const int inf=0x3f3f3f3f;
 
int cost[maxn][maxn];
int lowcost[maxn];
bool vis[maxn];
int pre[maxn];
int n,m,beg;
 
void dijkstra()
{
    for(int i=0;i<n;i++){
        lowcost[i]=inf;
        vis[i]=false;
        pre[i]=-1;
    }
    lowcost[beg]=0;
    for(int j=0;j<n;j++){
        int k=-1;
        int Min=inf;
        for(int i=0;i<n;i++){
            if(!vis[i]&&lowcost[i]<Min){
                Min=lowcost[i];
                k=i;
            }
        }
        if(k==-1){
            break;
        }
        vis[k]=true;
        for(int i=0;i<n;i++){
            if(!vis[i]&&lowcost[k]+cost[k][i]<lowcost[i]){
                lowcost[i]=lowcost[k]+cost[k][i];
                pre[i]=k;
            }
        }
    }
}
 
int main()
{
    scanf("%d%d",&n,&m);
    int a,b,c;
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            if(i!=j){
                cost[i][j]=inf;
            }
        }
    }
    for(int i=0;i<m;i++){
        scanf("%d%d%d",&a,&b,&c);
        cost[a][b]=c;
        cost[b][a]=c;
    }
    beg=0;
    dijkstra();
    for(int i=0;i<n;i++){
        cout<<lowcost[i]<<" ";
    }
    cout<<endl;
    int node=n-1;
    cout<<node<<" ";
    while(pre[node]!=-1){
        cout<<pre[node]<<" ";
        node=pre[node];
    }
    cout<<endl;
    return 0;
}

 

//Dijkstra+堆优化
//邻接表复杂度(eloge)
#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#include<queue>

using namespace std;

const int INF=0x3f3f3f3f;
const int MAXN=1000010;

struct qnode{
    int v,c;
    qnode(int _v=0,int _c=0):v(_v),c(_c){}
    friend bool operator < (qnode a,qnode b){
        return a.c>b.c;
    }
};

struct edge{
    int v,cost;
    edge(int _v=0,int _cost=0):v(_v),cost(_cost){}
};
vector<edge>E[MAXN];

void add_edge(int u,int v,int w)
{
    E[u].push_back(edge(v,w));
}

int N,M;
bool vis[MAXN];
int dist[MAXN];

void Dijkstra(int n,int start)
{
    memset(vis,false,sizeof(vis));
    for(int i=1;i<=n;i++){
        dist[i]=INF;
    }
    priority_queue<qnode>que;
    while(!que.empty()){
        que.pop();
    }
    dist[start]=0;
    que.push(qnode(start,0));
    qnode tmp;
    while(!que.empty()){
        tmp=que.top();
        que.pop();
        int u=tmp.v;
        if(vis[u]){
            continue;
        }
        vis[u]=true;
        for(int i=0;i<E[u].size();i++){
            int v=E[tmp.v][i].v;
            int cost=E[u][i].cost;
            if(!vis[v]&&dist[v]>dist[u]+cost){
                dist[v]=dist[u]+cost;
                que.push(qnode(v,dist[v]));
            }
        }
    }
}

int main()
{
    scanf("%d%d",&N,&M);
    int u,v,w;
    for(int i=0;i<M;i++){
        scanf("%d%d%d",&u,&v,&w);
        add_edge(u,v,w);
    }
    Dijkstra(N,1);
    for(int i=1;i<=N;i++){
        cout<<dist[i]<<" ";
    }
    cout<<endl;
    return 0;
}

 

//Dijkstra+堆优化
//邻接表复杂度(eloge)
#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#include<queue>

using namespace std;

const int INF=0x3f3f3f3f;
const int MAXN=1000010;

struct qnode{
    int v,c;
    qnode(int _v=0,int _c=0):v(_v),c(_c){}
    friend bool operator < (qnode a,qnode b){
        return a.c>b.c;
    }
};

struct edge{
    int v,cost;
    edge(int _v=0,int _cost=0):v(_v),cost(_cost){}
};
vector<edge>E[MAXN];

void add_edge(int u,int v,int w)
{
    E[u].push_back(edge(v,w));
}

int N,M;
bool vis[MAXN];
int dist[MAXN];

void Dijkstra(int n,int start)
{
    memset(vis,false,sizeof(vis));
    for(int i=1;i<=n;i++){
        dist[i]=INF;
    }
    priority_queue<qnode>que;
    while(!que.empty()){
        que.pop();
    }
    dist[start]=0;
    que.push(qnode(start,0));
    qnode tmp;
    while(!que.empty()){
        tmp=que.top();
        que.pop();
        int u=tmp.v;
        if(vis[u]){
            continue;
        }
        vis[u]=true;
        for(int i=0;i<E[u].size();i++){
            int v=E[tmp.v][i].v;
            int cost=E[u][i].cost;
            if(!vis[v]&&dist[v]>dist[u]+cost){
                dist[v]=dist[u]+cost;
                que.push(qnode(v,dist[v]));
            }
        }
    }
}

int main()
{
    scanf("%d%d",&N,&M);
    int u,v,w;
    for(int i=0;i<M;i++){
        scanf("%d%d%d",&u,&v,&w);
        add_edge(u,v,w);
    }
    Dijkstra(N,1);
    for(int i=1;i<=N;i++){
        cout<<dist[i]<<" ";
    }
    cout<<endl;
    return 0;
}

 

//spafa
//复杂度O(KE)
#include<iostream>
#include<cstdio>
#include<queue>
#include<queue>
#include<cstring>

using namespace std;

const int MAXN=1010;
const int INF=0x3f3f3f3f;

struct edge{
    int v,cost;
    edge(int _v,int _cost):v(_v),cost(_cost){}
};
vector<edge>E[MAXN];

void add_edge(int u,int v,int w)
{
    E[u].push_back(edge(v,w));
}

bool vis[MAXN];
int cnt[MAXN];
int dist[MAXN];

bool spfa(int start,int n)
{
    memset(vis,false,sizeof(vis));
    for(int i=1;i<=n;i++){
        dist[i]=INF;
    }
    vis[start]=true;
    dist[start]=0;
    queue<int>que;
    while(!que.empty()){
        que.pop();
    }
    que.push(start);
    memset(cnt,0,sizeof(cnt));
    cnt[start]=1;
    while(!que.empty()){
        int u=que.front();
        que.pop();
        vis[u]=false;
        for(int i=0;i<E[u].size();i++){
            int v=E[u][i].v;
            if(dist[v]>dist[u]+E[u][i].cost){
                dist[v]=dist[u]+E[u][i].cost;
                if(!vis[v]){
                    vis[v]=true;
                    que.push(v);
                    if(++cnt[v]>n){
                        return false;
                    }
                }
            }
        }
    }
    return true;
}

int main()
{

    return 0;
}