关于最短路径算法的理解

最短路径的算法主要是解决两个问题：

1.单源最短路

2.任意两点间的最短路

主要有三个算法来解决这两个问题：

1.单源最短路：dijkstra算法，spfa算法

2.任意两点间的最短路：floyd算法

----------------------------------------dijkstra单源最短路算法----------------------------------------------------------------

应用范围：边权非负的有向图和无向图均可

算法思想：

1.因为边权非负，所以任意两条边相加的和一定不小于其中任意一条边，我们设源点为s，那么要求所有点到达s的最短路径，那么我们定义一个点集S，定义一个数组dis[],表示某个点只与点集中的点连接的情况到达源点的最短距离，如果暂时不能到达，记为INF,初始情况下点集中只有源点s，那么与源点直接相连的点中边权最小的点一定是最短路径，设最小边连接的点为v，u为除s和v外的任意一点，因为dis[v] < dis[u]且边权非负,所以dis[v]<dis[u]+一条或多条边的边权，所以当前的决策一定是最短路，且之后一定不能更新出更短的路径。

2.那么点v的最短路径已经得到，我们可以把它添加到S点集，然后还要继续维护dis[]数组的性质，也就是如果当前的v点与S点集外的一点u相连，如果dis[v]+edge[v,u] < dis[u]，那么点u可以dis[u]就应该更新，因为定义中是定义的经过点集中的点得到的最短的路径，然后这个S点集我们就可以缩点为一个点了，然后又变为了1的情况，知道处理的所有点都计入S点集，也就是整个图缩成了一个点，那么整个图到达s点的最短路径就处理出来了

下面给出O(n^2)的实现方法

邻接矩阵的实现方法：

void dijkstra(int s){       memset(vis , 0 , sizeof(vis));       memset(father , 0 , sizeof(father));       /*初始化dis数组*/       for(int i = 1 ; i<= n ; i++)            dis[i] = INF;       dis[s] = 0;       for(int i = 1 ; i <= n ; i++){/*枚举n个顶点*/          int pos;          pos = -1;          for(int j = 1 ; j <= n ;j++){/*找到未加入集合的最短路点*/             if(!vis[j] && (pos == -1 || dis[j] < dis[pos]))                pos = j;          }          vis[pos] = 1;/*把这个点加入最短路径集合*/          for(int j = 1 ; j <= n ; j++){/*更新dis数组*/             if(!vis[j] && (dis[j] > dis[pos] + value[pos][j])){               dis[j] = dis[pos] + value[pos][j];               father[j] = pos;             }          }       }  }  

主要是两个操作：

1.找出当前S集外的dis[v]最小的点v（可以利用堆优化）

2.将v加入点集S，然后更新dis数组

下面是利用堆优化的O(n*loge)

struct cmp  {      bool operator ( ) ( const int&a , const int&b ) const       {          return dis[a] > dis[b];      }  };    void dijkstra ( )  {      memset ( dis , 0x3f , sizeof ( dis ) );      memset ( used , 0 , sizeof ( used ) );      priority_queue<int , vector<int> , cmp > q;      dis[s] = 0;      q.push ( s );      while ( !q.empty( ) )      {          int u = q.top();          q.pop();          used[u] = true;          for ( int v = 1 ; v <= n ; v++ )              if ( !used[v]&&dis[v] > dis[u] + mp[u][v] )              {                  dis[v] = dis[u] + mp[u][v];                  q.push ( v );              }      }  }  

---------------------------------------------spfa求单源最短路-------------------------------------------------------

适用范围：有负权的图,可以判断负环，如果某个点松弛次数大于等于n，那么说明有负环

算法思想：很直观的宽搜的思想，近似于暴力，复杂度O(ke)，k是每个点平均入队次数，可以证明出K<=2

dis数组，记录到源点的最短路径，如果当前不是最短，那么一定能够被某个点点松弛，相反，如果当前点不能够被松弛，那么它就一定是最短路径了

首先科普一个操作：就是松弛操作，这个操作就是利用当前的点的的dis值取更新它能够到达的点的dis值

在宽搜的过程中我们维护一个队列，这个队列中存放的刚刚被松弛过路径的点，初始的时候将源点放入队列中，因为当一个点松弛过后，它的最短路径变短，可能会导致其他点能够被松弛，所以当前点入队，当队列为空也就是没有点能够松弛其他点了，也就是说一个点最多直接间接地被其他n-1个点松弛一遍，所以当松弛数大于等于n的时候证明出现了负环，因为负环能够不断的松弛一条最短路径

代码如下：

struct Edge  {      int v,w,next;  }e[MAX*MAX];    int head[MAX];  int cc;    void add ( int u , int v , int w )  {      e[cc].v = v;      e[cc].w = w;      e[cc].next = head[u];      head[u] = cc++;  }    bool used[MAX];  int dis[MAX];  int cnt[MAX];    bool spfa ( int s , int d )  {      memset ( used , false , sizeof ( used ) );      memset ( dis , -1 , sizeof ( dis ) );      memset ( cnt , 0 ,sizeof ( cnt ) );      queue<int> q;      q.push ( s );      cnt[s]++;      used[s] = true;      dis[s] = 0;      while ( !q.empty())      {          int u = q.front();          q.pop ( );          used[u] = false;          for ( int i = head[u] ; ~i ; i = e[i].next )          {              int v = e[i].v;              if ( dis[v] != -1 && dis[v] <= dis[u] + e[i].w ) continue;              dis[v] = dis[u] + e[i].w;              if ( used[v] ) continue;              used[v] = true;              q.push ( v );              if ( ++cnt[v] > n ) return false;          }      }      return true;  }  

---------------------------------------------floyd求任意两点间的最短路-----------------------------------------------

适用范围：存在负权的图不能用

算法思想：n^3的复杂度不算优秀，但是容易实现。

首先floyd是一个传递闭包的思想，比如A，B，C三个点，A和B存在边，B和C存在边，那么A和C也可以推出直接相连的边

我们枚举这个n个点，然后对于每个点，枚举任意两点，然后更新dis[i][j]，就相当于传递闭包当中利用两条边去推导出第三条边，但是floyd求最短时，每两点之间只保留一条边，最小那条，也就是如果本身存在边，那么新添的边与其进行比较，大的那条边被覆盖。整个floyd过程下来相当于整个传递闭包求了一遍，然后所有的边保留下来均是在每次覆盖操作后留下来的最小的，可能有的人会问？如果当前利用k点更新了dis[i][j] = dis[i][k] + dis[k][j]，之后又出现了一个v更新了dis[i][k]，还是最短的吗？其实是这样的，因为k在更新dis[i][j]的同时一定也会更新dis[v][j],那么到枚举v的时候dis[i][v]和dis[v][j]更新dis[i][j],就相当于用更小的dis[i][k]进行了松弛。

代码如下：

 for ( int k = 0 ; k < n ; k++ )            for ( int i = 0 ; i < n ; i++ )                for  ( int j = 0 ; j < n ; j++ )                        dis[i][j] = max ( dis[i][j] , dis[i][k] + dis[k][j] );