最短路

DJ算法：

 基本概念； 

    贪心+bfs 

    通过缩短每一个点（当前距离最小的点）的距离来达到最短距离。

　不过不能解决有负权边的问题（会无线循环）。

DJ的优化：

优先队列： //相当于stack 不是vector 虽然要用 vector

 基本操作：

 empty() 　　   如果队列为空，则返回真

 pop()　　　　删除对顶元素，删除第一个元素

 push() 　　     加入一个元素

 size() 　　　  返回优先队列中拥有的元素个数

 top() 　　　　返回优先队列对顶元素，返回优先队列中有最高优先级的元素 不是最高优先级 是最低优先级  是宅

 在默认的优先队列中，优先级高的先出队。在默认的int型中先出队的为较大的数。

  定义：

  priority_queue  cmp> mqy;

　　cmp:

struct cmp{
bool operator ()(const int a,const int b)const
{
return dis[a]>dis[b];    // 这个可以 直接 a>b ,这种形式前面是引入了数组来弄其他东西   // 最后面的那个是 优先级最低的 top 就是最后面的那个 可以想想一个倒下的stack
}
};
priority_queue,cmp> q;

优化代码：

void dj(int s)
{
    memset(dis,0x3f,sizeof dis);
    dis[s]=0;
    q.push(s);
    while(!q.empty())
    {
        while(!q.empty()&&vis[q.top()]) q.pop();
        int trmp=q.top();
        if(trmp==t) break;
        q.pop();
        vis[trmp]=1;
        for(ri i=head[trmp];i;i=bian[i].net)
        {
            int v=bian[i].to;
            if(dis[v]>dis[trmp]+bian[i].val)
            {
                dis[v]=dis[trmp]+bian[i].val;
                q.push(v);
            }
        }
    }
}

spa算法：

优化板的暴力枚举，每个点最多进3次。

时间复杂度 O(E）；

代码：

void spa1(int s)
{
    dfs1[s]=0;
    l=1;r=2;
    que1[r]=s;
    while(l<r)
    {
        int trmp=que1[++l];
        vis[trmp]=0;
        for(ri i=head1[trmp];i;i=bian[i].net)
        {
            int v=bian[i].to,w=bian[i].zhi;
            if(dfs1[trmp]+w<dfs1[v])
            {
                dfs1[v]=dfs1[trmp]+w;
                if(vis[v]==0) que1[++r]=v,vis[v]=1;
            }
        }
    }
}

 Floyd算法

 通过中间点更新两点间的距离。

用矩阵 arr 不能直接到达的点无穷大

代码

for(int k=0;k//k为中间节点
 {
for(int i=0;i//i为起点
    for(int j=0;j//j为终点
     if(i!=k&&i!=j&&k!=j)
         if(arr[i][k]+arr[k][j]<arr[i][j])
             arr[i][j]=arr[i][k]+arr[k][j];
}