（Til the Cows Come Home ）链式前向星存图，优先队列，dijkstra算法

题目链接  USACO 2004 November

下面只是介绍模板，对于这道题还要注意边和顶点的输入顺序，下面的模板都是按照先顶点后边的顺序处理的，直接复制

提交会wa的，所以最好是自己理解着做，要是偷懒直接复制wa了别怪我

常规易于理解的方法

#include 
#include 
#include 
using namespace std;

// <2> djk求单源最短路,邻接矩阵存图 时间复杂度o(n^2)

const int N = (int) 1000 + 11; // 最大点数
const int INF = (int) 0x3f3f3f3f;

int n, m; // n是点的个数，m是边的个数
int mp[N][N];
void init(int n){// 初始化
	for(int i = 0; i < n; i++){
		for(int j = 0; j < n; j++){
			if(i == j) mp[i][j] = 0;
			else mp[i][j] = mp[j][i] = INF; 
		}
	}
}
void getmap(int m){ // 建图
	int u, v, val;
	while(m--){
		scanf("%d%d%d", &u, &v, &val);
		u--; v--;
		mp[u][v] = mp[v][u] = min(mp[u][v], val); // 如果是双向图写这句
		// mp[u][v] = min(mp[u][v], val); // 如果是单向图写这句
	}
}
bool vis[N]; int dis[N];
void djk(int st, int ed){ // 核心代码,点的序号是从0-(n-1)
	for(int i = 0; i < n; i++){
		vis[i] = false;
		dis[i] = mp[st][i];
	} 
	vis[st] = true;
	for(int i = 1; i < n; i++){
		int mn = INF, id = -1;   //找到离起点最近的未访问过得点
		for(int j = 0; j < n; j++){
			if(!vis[j] && dis[j] < mn) {
				mn = dis[j]; id = j;
			}
		}
		if(id == -1) break;
		vis[id] = true; // 标记
		for(int j = 0; j < n; j++){
			if(!vis[j] && mp[id][j] != INF) { // 如果未访问且 id->
				if(dis[j] > dis[id] + mp[id][j])  // 是否可以松弛j有边
					dis[j] = dis[id] + mp[id][j];
			}
		}
	}
	printf("%d\n", (dis[ed] == INF) ? -1 : dis[ed]);
}
int main(){
	int t; scanf("%d%d", &t, &n);
	init(n);
	getmap(t);
	djk(n - 1, 0);
	return 0;
}

这个是最优化的代码。

//使用链式前向星实现dijkstra,使用链式前向星也可避免图中重边的问题
#include 
#include
#include
#include
using namespace std;
typedef pair pp;
const int maxv = 1005;
const int maxe = 10005;
const int INF = 0x3f3f3f3f;

struct Edge
{
     int next,to,length;
}edge[maxe];
	
int d[maxv],head[maxv];
int v,e,cnt,en;
bool vis[maxv];

void add(int u,int vv,int dis)//链式前向星存图 
{
	edge[++cnt].next = head[u];
	edge[cnt].to = vv;
	edge[cnt].length = dis;
	head[u] = cnt;
}

void dijkstra()
{
	int st = 1;
	memset(vis,0,sizeof(vis));
	memset(d,INF,sizeof(d));
	d[st] = 0;
	priority_queue,greater > pa;
	while (!pa.empty())
		pa.pop();
	pa.push(pp(d[st],st));
	while (!pa.empty())
	{
		pp k = pa.top();
		pa.pop();
		if (en==k.second) return;
		if (vis[k.second]) continue;
		vis[k.second] = true;
		for (int i=head[k.second];i!=0;i=edge[i].next)
			if (k.first + edge[i].length < d[edge[i].to])
			{
				d[edge[i].to] = k.first + edge[i].length;
				pa.push(pp(d[edge[i].to],edge[i].to));
			}
	}
}

int main()
{
	cnt = 0;
	scanf("%d %d",&v,&e);//v 是图中的点数，e是图中的边数
	memset(head,0,sizeof(head));
	for (int i=0;i

 SPFA模板

#include 
#include 
#include 
using namespace std;

// <1> spfa求单源最短路,链式前向星存图 时间复杂度o(kE) k是常数，大多数情况下为2

const int N = (int) 1e5 + 11; // 最大点数
const int M = (int) 1e6 + 11; // 最大边数
const int INF = (int) 0x3f3f3f3f;

struct Edge{ // 边的定义
	int to, val, next;
	Edge(){}
	Edge(int _to, int _val, int _next){
		to = _to; val = _val; next = _next;
	}
}edge[M << 1]; // !!如果是双向图的话，边的数量是题目中描述的二倍

int n, m; // n 是图中的点数，m是图中的边数
int head[N], top;
void init(int n){ // 初始化
	memset(head, -1, sizeof(int) * (n + 1));
	top = 0;
}
void Add(int u, int v, int val){ // 加单向边
	edge[top] = Edge(v, val, head[u]);
	head[u] = top++;
}
void getmap(int m){ // 建图
	int u, v, val;
	while(m--){
		scanf("%d%d%d",&u , &v, &val); // u->v有边
		Add(u, v, val);  
		Add(v, u, val); // 如果是双向图，加上这个代码
	}
}

bool vis[N]; int dis[N]; 
void spfa(int st, int ed){ // 核心代码,点序号从0-(n-1)或者1-n都可以
	memset(dis, 0x3f, sizeof(int) * (n + 1));
	memset(vis, false, sizeof(bool) * (n + 1)); // 清空和初始化
	queueque; que.push(st); 
	vis[st] = true; dis[st] = 0;
	while(!que.empty()){
		int u = que.front(); que.pop(); vis[u] = false;
		for(int i = head[u]; ~i; i = edge[i].next){
			Edge e = edge[i];
			if(dis[e.to] > dis[u] + e.val) {//是否可以进行松弛
				dis[e.to] = dis[u] + e.val;
				if(!vis[e.to]){ // 是否在队列中，如果在可以跳过
					que.push(e.to);
					vis[e.to] = true;
				}
			}

		}
	} 
	printf("%d\n", dis[ed] == INF ? -1 : dis[ed]); // st到不了ed输出-1
}

int main(){
	int t; scanf("%d%d", &t, &n);
	init(n);
	getmap(t);
	spfa(n, 1);
	return 0;
}

 floyd模板

 

#include 
#include 
#include 
using namespace std;

// <4> floyd求多源最短路,邻接矩阵存图 时间复杂度o(n^3)，可求得任意两个点之间的最短距离

const int N = (int) 1000 + 11;
const int INF = (int) 0x3f3f3f3f;

int n, m;
int mp[N][N];
void init(int n){ // 初始化
	for(int i = 0; i < n; i++){
		for(int j = 0; j < n; j++){
			if(i == j) mp[i][j] = 0;
			else mp[i][j] = mp[j][i] = INF;
		}
	}
}
void getmap(int m){ // 建图
	int u, v, val;
	while(m--){
		scanf("%d%d%d", &u, &v, &val); u--; v--;
		mp[u][v] = mp[v][u] = min(mp[u][v], val); // 双向图写这行
		//mp[u][v] = min(mp[u][v], val); // 单向图写着行
	}
}
void floyd(int n){ // 核心代码，点的序号为0-n-1
	for(int k = 0; k < n; k++){ 
		for(int i = 0; i < n; i++){
			for(int j = 0; j < n; j++){
				mp[i][j] = min(mp[i][j], mp[i][k] + mp[k][j]); // dp
			}
		}
	}
}

int main(){
	int t; scanf("%d%d", &t, &n);
	init(n);
	getmap(t);
	floyd(n);
	printf("%d\n", mp[n - 1][0] == INF ? -1 : mp[n - 1][0]);
	return 0;
}