Dijkstra(求最短路)

时间复杂是 O(n2+m) ，n 表示点数，m 表示边数

模板(朴素法一般m等于n^2的时候使用)

#include
#include
using namespace std;
const int N=510;
int g[N][N];    //为稠密阵所以用邻接矩阵存储
int dist[N];    //用于记录每一个点距离第一个点的距离
bool st[N];     //用于记录该点的最短距离是否已经确定

int Dijkstra()
{
    memset(dist, 0x3f,sizeof dist); //初始化距离  0x3f代表无限大

    dist[1]=0;                      //第一个点到自身的距离为0

    for(int i=0;idist[j]))     
                t=j;

        st[t]=true;   
    //找到了距离最小的点t，并用最小的点t去更新其他的点到起点的距离
        for(int j=1;j<=n;j++)
            dist[j]=min(dist[j],dist[t]+g[t][j]);
    }

    if(dist[n]==0x3f3f3f3f) return -1;  //如果第n个点路径为无穷大即不存在最低路径
    return dist[n];
}
int main()
{
    cin>>n>>m;

    memset(g,0x3f,sizeof g);    //初始化图 因为是求最短路径
                                //所以每个点初始为无限大

    while(m--)
    {
        int x,y,z;
        cin>>x>>y>>z;
        g[x][y]=min(g[x][y],z);     //如果发生重边的情况则保留最短的一条边
    }

    cout<

模板(堆优化版一般在m等于n的时候使用)

#include
#include
#include
#include
using namespace std;
typedef pairPII;   //堆里储存距离和编号
const int N=1e6+10;
int n,m;
int h[N],w[N],e[N],ne[N],idx;  //对于每个点k，开一个单链表，存储K所有可以走到的点，h[k]存储这个单链表的头节点 
int dist[N];  //存储距离
bool st[N];    //储存状态

//添加一条a到b的边 
void add(int a,int b,int c){
	e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++; 
	
}

int Dijkstra()
{
	memset(dist,0x3f,sizeof dist);  //距离初始化为最大值
	dist[1]=0;
	priority_queue,greater>heap; //小根堆
	heap.push({0,1}); //插入距离和节点编号
	
	while(heap.size()){
		auto t=heap.top();  //取距离原点最近的点
		heap.pop();
		int ver=t.second,distance=t.first; 
		if(st[ver])continue; //如果该点已经确定，则跳过该点
		st[ver]=true;
		for(int i=h[ver];i!=-1;i=ne[i])//更新ver所指向的节点距离
		{
			int j=e[i];
			if(dist[j]>dist[ver]+w[i]){
				dist[j]=dist[ver]+w[i];
				heap.push({dist[j],j});   //最小距离入堆 
			} 
		 } 
	} 
	if(dist[n]==0x3f3f3f3f)return -1;
	return dist[n]; 
}

int main(){
	cin>>n>>m;
	memset(h,-1,sizeof h);
	while(m--){
		int x,y,z;
		cin>>x>>y>>z;
		add(x,y,z);
	}
	cout<