图论-最短路问题(Dijkstra算法)

最短路问题

单源最短路
1.Dijkstra算法
POJ2387
Dijkstra模板题
主要注意存图方式，其实这个题数据量不大用邻接矩阵完全可以存下，我这里使用vector存图主要是保险（没看见数据量这么小，，）。
然后这个是个无向图需要判断重边（我第一次就是在这里wa的，，）对于重复的边应该取最小的边权。
这种裸题主要考察细节（我就wa在这上边）。
对于Dijkstra算法本身不难，主要就是一个贪心+BFS的思想。
显然算法里有两重for循环，所以复杂度为O（n^2）对于某些点特别多的图就会TLE（大于1e5？）所以就需要优化算法，对于这个算法，遍历所有点是不可避免的所以只能优化掉寻找最小值的那个for循环，可以用优先队列（priority_queue）来优化寻找最小值，这样复杂度就会优化成O（nlogn）。
优化前：

#include<iostream>
#include<vector>
#include<cstring>
#define inf 1<<29
#define max 1500
using namespace std;
struct h{
	int e;
	int v;
};
vector<h> p[max];//邻接表存图
int d[max];//记录起点到各点的最小距离
bool book[max];//标记点有没有走过
int t,n;
int Dijkstra(){
	//memset(d,inf,sizeof(d));//尽量少用这个，容易出问题，不如自己写个循环
	for(int i=1;i<=n;i++){
		d[i]=inf;
		book[i]=0;
	}
	for(int i=0;i<p[1].size();i++)
	d[p[1][i].e]=p[1][i].v;
	d[1]=0;
	book[1]=1;
	for(int i=1;i<=n;i++){
		int minn=inf;
	    int u;
		for(int j=1;j<=n;j++){
			if(d[j]<minn&&book[j]==0){//寻找最小值
				minn=d[j];
				u=j;
			}
		}
		book[u]=1;
		if(minn==inf)
		break;
		for(int j=0;j<p[u].size();j++){
			int v=p[u][j].e;
			int w=p[u][j].v;
			if(book[v]==0&&d[v]>d[u]+w)
			d[v]=d[u]+w;
		}
	}
	return d[n];
}
int ss(int a,int b){//搜索，主要是为了判断重边（邻接表存图的坏处，，）
	for(int i=0;i<p[a].size();i++)
	if(p[a][i].e==b)
	return i;
	return -1;
}
int main(){
	while(cin>>t>>n){
	while(t--){
		int a,b,c;
		cin>>a>>b>>c;
		int l=ss(a,b);
		if(l==-1){
		   p[a].push_back(h{b,c});
		   p[b].push_back(h{a,c});	
		}	
		else if(p[a][l].v>c){
			p[a][l].v=c;
			p[b][ss(b,a)].v=c;
		}	
	}
	cout<<Dijkstra()<<endl;
	for(int i=1;i<=n;i++)
	p[i].clear();
    }
	return 0;
} 

优先队列优化后：

#include<iostream>
#include<vector>
#include<cstring>
#include<queue>
#define inf 1<<29
#define max 1500
using namespace std;
struct h{
	int e;
	int v;
	bool operator < (const h&a)const{//重载运算符使距离最短的优先级最高
	     return v>a.v;
	}
};
vector<h> p[max];
int d[max];
bool book[max];
int t,n;
int Dijkstra(){	
	priority_queue <h> q;
	for(int i=1;i<=n;i++){
		d[i]=inf;
		book[i]=0;
	}
	for(int i=0;i<p[1].size();i++){
		d[p[1][i].e]=p[1][i].v;
		q.push(h{p[1][i].e,p[1][i].v});
	}
	d[1]=0;
	while(!q.empty()){
		h a=q.top();
		q.pop();
		if(book[a.e]==1)
		continue;
		book[a.e]=1;
		for(int i=0;i<p[a.e].size();i++){
			int v=p[a.e][i].e;
			int w=p[a.e][i].v;
			if(book[v]==0&&d[v]>a.v+w){
			d[v]=a.v+w;	
			q.push(h{v,d[v]});
			}	
		}
	}
	return d[n];
}
int ss(int a,int b){
	for(int i=0;i<p[a].size();i++)
	if(p[a][i].e==b)
	return i;
	return -1;
}
int main(){
	while(cin>>t>>n){
	while(t--){
		int a,b,c;
		cin>>a>>b>>c;
		int l=ss(a,b);
		if(l==-1){
		   p[a].push_back(h{b,c});
		   p[b].push_back(h{a,c});	
		}	
		else if(p[a][l].v>c){
			p[a][l].v=c;
			p[b][ss(b,a)].v=c;
		}	
	}
	cout<<Dijkstra()<<endl;
	for(int i=1;i<=n;i++)
	p[i].clear();
    }
	return 0;
} 

优化之后很显然比优化前快了不少，，
POJ3037
Dijkstra算法+优先队列优化

#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <queue>
#define inf 1<<28
using namespace std;
struct h{
	int x;
	int y;
	double l;
	bool operator <(const h&a)const{
		return l>a.l;
	}
};
const int maxn=200;
int p[maxn][maxn];
double dis[maxn][maxn];
bool book[maxn][maxn];
double v;
int r,c;
int ne[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
int main(){
    cin>>v>>r>>c;
    for(int i=0;i<r;i++){
    	for(int j=0;j<c;j++){
    		cin>>p[i][j];
    	}
    }
    priority_queue <h> a;
    a.push(h{0,0,0});
    while(!a.empty()){
    	h b=a.top();
    	a.pop();
    	if(book[b.x][b.y])
    	continue;
    	book[b.x][b.y]=1;
    	for(int i=0;i<4;i++){
    		int px=b.x+ne[i][0];
    		int py=b.y+ne[i][1];
    		if(px<0||px>=r||py<0||py>=c)
    		continue;
    		if(book[px][py])
    		continue;
    		double t=b.l+1.0/(pow(2,p[0][0]-p[b.x][b.y])*v);
    		if(dis[px][py]==0)
    		dis[px][py]=t;
    		else
    		dis[px][py]=min(dis[px][py],t);
    		a.push(h{px,py,dis[px][py]});
    	}
    }
    printf("%.2f\n",dis[r-1][c-1]);
	return 0;
}