最短路总结

// Floyd多源最短路算法 O(n^3)

#include <iostream>

#include <cmath>

#include <cstring>

#include<algorithm>

using namespace std;

const int N = 101;

int g[N][N];

void Floyd(int n) {

for(int i=1; i<=n; i++){

for(int j=1; j<=n; j++){

for(int k=1; k<=n; k++){

g[j][k]=min(g[j][k],g[j][i]+g[i][k]);

}

}

}

}

int main() {

memset(g, 0x3f, sizeof(g));

for (int i = 0; i < N; i++) {

g[i][i] = 0;

}

int n, m;

int u, v, w;

cin >> n >> m;

for (int i = 0; i < m; i++) {

cin >> u >> v >> w;

g[u][v] = g[v][u] = w;

}

Floyd(n);

for (int i = 1; i <= n; i++) {

for (int j = 1; j <= n; j++) {

cout << g[i][j] << " ";

}

cout << endl;

}

return 0;

}

//朴素的Dijkstra算法（单源最短路 正环）O(n^2)适用于稠密图

#include<iostream>

#include<algorithm>

#include<cstdio>

#include<cstring>

#include<cmath>

#include<vector>

#include<queue>

#include<set>

using namespace std;

const int inf=0x7fffffff;

bool vis[1005];

int d[1005];

struct node{

int v,w;

node(){

}

node(int v2,int w2){

v=v2;

w=w2;

}

};

vector<node> g[1005];

int n,m,s;

int main(){

cin>>n>>m>>s;

for(int i=1; i<=n; i++){

int u,v,w;

cin>>u>>v>>w;

g[u].push_back(node(v,w));

g[v].push_back(node(u,w));

}

memset(d,0x3f,sizeof(d));

d[s]=0;

for(int i=1; i<=n; i++){

int minn=inf;int v=0;

for(int j=1; j<=n; j++){

if(!vis[i]&&d[j]<minn)

{

minn=d[j];

v=j;

}

}

if(minn==inf){

break;

}

vis[v]=true;

for(int j=0; j<g[v].size(); j++){

d[g[v][j].v]=min(d[g[v][j].v],g[v][j].w+d[v]);

}

}

for(int i=1; i<=n; i++){

cout<<d[i]<<" ";

}

return 0;

}

//堆优化的Dijkstra算法（单源最短路 正环）O(m logn)适用于稀疏图

#include<iostream>

#include<algorithm>

#include<cstdio>

#include<cstring>

#include<cmath>

#include<vector>

#include<queue>

#include<set>

using namespace std;

struct node{

int v,w;

node(){

}

node(int v2,int w2){

v=v2;

w=w2;

}

};

set <pair<int,int>> minn;

vector <node> g[1005];

int d[1005];

int main(){

int n,m,s;

cin>>n>>m>>s;

for(int i=1; i<=n; i++){

int u,v,w;

cin>>u>>v>>w;

g[u].push_back(node(v,w));

g[v].push_back(node(u,w));

}

memset(d,0x3f,sizeof(d));

d[s]=0;

minn.insert(make_pair(0,s));

while(minn.size()){

int mind=minn.begin()->first;

int v=minn.begin()->second;

minn.erase(minn.begin());

for(int i=0; i<g[v].size(); i++){

if(d[g[v][i].v]>g[v][i].w+d[v]){

minn.erase(make_pair(d[g[v][i].v],g[v][i].v));

d[g[v][i].v]=d[v]+g[v][i].w;

minn.insert(make_pair(d[g[v][i].v],g[v][i].v));

}

}

}

for(int i=1; i<=n; i++){

cout<<d[i]<<" ";

}

return 0;

}

//SPFA算法（多源最短路 正负环）一般O(m),最坏O(nm)

#include<iostream>

#include<algorithm>

#include<cstdio>

#include<cstring>

#include<cmath>

#include<vector>

#include<queue>

#include<set>

using namespace std;

struct node{

int v,w;

node(){

}

node(int vv,int ww){

w=ww;

v=vv;

}

};

vector <node>g[1005];

bool f[1005];

queue<int > q;

int d[1005];

signed main(){

int n,m,s;

cin>>n>>m>>s;

for(int i=1; i<=n ; i++){

int u,v,w;

cin>>u>>v>>w;

g[u].push_back(node(v,w));

g[v].push_back(node(u,w));

}

memset(d,0x3f,sizeof(d));

d[s]=0;

f[s]=1;

q.push(s);

while(!q.empty()){

int now=q.front();

f[now]=0;

q.pop();

for(int i=0; i<g[now].size(); i++){

int x=g[now][i].v;

if(d[x]>d[now]+g[now][i].w){

d[x]=d[now]+g[now][i].w;

if(!f[x]){

f[x]=1;

q.push(x);

}

}

}

}

for(int i=1; i<=n; i++){

cout<<d[i]<<" ";

}

return 0;

}

//SPFA判断负环

#include<iostream>

#include<algorithm>

#include<cstdio>

#include<cstring>

#include<cmath>

#include<vector>

#include<queue>

#include<set>

using namespace std;

struct node{

int v,w;

node(){

}

node(int vv,int ww){

v=vv;

w=ww;

}

};

queue<int> q;

int d[1005],cnt[1005];

vector<node> g[1005];

bool f[1005];

int main(){

int n,m,s,u,v,w;

cin>>n>>m>>s;

for(int i=1; i<=n; i++){

cin>>u>>v>>w;

g[u].push_back(node(v,w));

g[v].push_back(node(u,w));

}

memset(d,0,sizeof(d));

d[s]=0;

f[s]=1;

q.push(s);

cnt[s]++;

while(!q.empty()){

int now=q.front();

q.pop();

f[now]=0;

if(cnt[now]>n){

cout<<"YES";

return 0;

}

for(int i=0; i<g[now].size(); i++){

int x=g[now][i].v;

if(d[x]>d[now]+g[now][i].w){

d[x]=d[now]+g[now][i].w;

if(!f[x]){

q.push(x);

cnt[x]++;

f[x]=1;

}

}

}

}

cout<<"NO";

return 0;

}