最短路问题是图论中比较常见的一类问题，其中最简单易懂的就是Floyd算法，这里模板未总结。

然后就是比较经典的Dijkstra算法，这里的Dijkstra是用邻接表和优先队列优化后的。

需要注意的问题在注释里

***此算法只适用于边权不为负值的时候，算法的复杂度为O(Elog(V))

#include<bits/stdc++.h>
using namespace std;
const int maxv=1e5+10;
const int inf=1e9+7;
struct edge
{
    int to;
    int cost;
};
typedef pair<int,int> P;//frist 是最短距离，second是顶点编号
int V,E;//定义顶点总数和边的总数
vector<edge>G[maxv];//vector的类型为egde
int d[maxv];

void dijkstra(int s)
{
    priority_queue<P,vector<P>,greater<P> >que;//这个地方只是固定的格式，这个vector和上边的那个vector没有半毛钱的关系
    fill(d,d+V+1,inf);//这个+1很关键
    d[s]=0;
    que.push(P(0,s));

    while(!que.empty()){ //整个过程类似于bfs，一层一层的很好理解
        P p = que.top();que.pop();
        int v = p.second;
        if(d[v]<p.first) continue;
        for(int i=0;i<G[v].size();i++){
            edge e=G[v][i];
            if(d[e.to]>d[v]+e.cost){
                d[e.to] = d[v]+e.cost;
                que.push(P(d[e.to],e.to));
            }
        }
    }
}

//建立邻接表的函数
//建立邻接表
void build()
{
    scanf("%d%d",&V,&E);
    for(int i=0;i<E;i++){
        int s,t,cos;
        scanf("%d%d%d",&s,&t,&cos);
        edge e;e.to=t,e.cost=cos;
        G[s].push_back(e);  e.to=s;G[t].push_back(e);//无向图分为两个方向，所以a->b b->都要存储
    }
}

int main()
{
}

当边权为负值的时候，采用Bellman-Ford算法（博主实在是太懒了，遇到题目时再整理模板吧）