AC之路有笑有泪
AC之路有笑有泪

Dijkstra/ floyd/floyd扩展求最小环/Bellman_Ford(权值可正可负)/SPFA(权值可正可负)判断负环

最短路径问题旨在寻找图中两节点之间的最短路径，常用的算法有以下四种。注意是把图处理成无向还是有向

Dijkstra's (权值非负)
1 Dijkstra's算法解决的是图中单个源点到其它顶点的最短路径。只能解决权值非负
2 Dijkstral只能求出任意点到达源点的最短距离（不能求出任意两点之间的最短距离），同时适用于有向图和无向图，复杂度为O(n^2).
3算法的过程： 
1设置顶点集合S并不断的作贪心选择来选择扩充这个集合。一个顶点属于集合S当且仅当从源点到该点的最短路径长度已知
2 初始时，S中仅含有源。设U是G的某一个顶点，把从源到U且中间只经过S中的顶点的路称为从源到U的特殊路径，并用dis数组距离当前每一个顶点所对应的最短特殊路径
3Dijkstra算法每一次从V-S中取出具有最短特殊长度的顶点u，将u添加到S中，同时对dis数组进行修改。一旦S包含了所有的V中的顶点，dis数组就记录了从源点到其它顶点的最短路径长度。
4 模板:
没有优化，时间复杂度o(n^2)
[cpp]  view plain copy
  1. #define MAXN 1010   
  2. #define INF 0xFFFFFFF   
  3. int  value[MAXN][MAXN];/*保存的是边权值*/  
  4. int  dis[MAXN]；/*保存源点到任意点之间的最短路*/  
  5. int  father[MAXN];/*保存i点的父亲节点*/  
  6. int  vis[MAXN];/*记录顶点是否没取过*/   
  7.   
  8. void input(){       
  9.       int star , end , v;  
  10.       scanf("%d%d" , &n , &m);  
  11.       /*初始化value数组*/  
  12.      for(int i = 1 ; i <= n ; i++){  
  13.          for(int j = 1; j <= n ; j++)  
  14.              value[i][j] = INF;  
  15.      }  
  16.     for(int i = 0 ; i < m ; i++){  
  17.         scanf("%d%d%d" ,  &star , &end , &v);  
  18.         if(value[star][end] == INF)  
  19.             value[star][end] = value[end][star] = v;/*处理成无向图*/  
  20.         else{  
  21.             if(v < value[star][end])/*判断重边是否出现*/  
  22.                  value[star][end] = value[end][star] = v;  
  23.         }  
  24. }  
  25.   
  26. void dijkstra(int s){  
  27.      memset(vis , 0 , sizeof(vis));  
  28.      memset(father , 0 , sizeof(father));  
  29.      /*初始化dis数组*/  
  30.      for(int i = 1 ; i<= n ; i++)  
  31.           dis[i] = INF;  
  32.      dis[s] = 0;  
  33.      for(int i = 1 ; i <= n ; i++){/*枚举n个顶点*/  
  34.         int pos;  
  35.         pos = -1;  
  36.         for(int j = 1 ; j <= n ;j++){/*找到未加入集合的最短路点*/  
  37.            if(!vis[j] && (pos == -1 || dis[j] < dis[pos]))  
  38.               pos = j;  
  39.         }  
  40.         vis[pos] = 1;/*把这个点加入最短路径集合*/  
  41.         for(int j = 1 ; j <= n ; j++){/*更新dis数组*/  
  42.            if(!vis[j] && (dis[j] > dis[pos] + value[pos][j])){  
  43.              dis[j] = dis[pos] + value[pos][j];  
  44.              father[j] = pos;  
  45.            }  
  46.         }  
  47.      }  
  48. }  
[cpp]  view plain  copy
  1. #define MAXN 1010  
  2. #define INF 0xFFFFFFF  
  3. int  value[MAXN][MAXN];/*保存的是边权值*/  
  4. int  dis[MAXN]；/*保存源点到任意点之间的最短路*/  
  5. int  father[MAXN];/*保存i点的父亲节点*/  
  6. int  vis[MAXN];/*记录顶点是否没取过*/   
  7.   
  8. void input(){       
  9.       int star , end , v;  
  10.       scanf("%d%d" , &n , &m);  
  11.       /*初始化value数组*/  
  12.      for(int i = 1 ; i <= n ; i++){  
  13.          for(int j = 1; j <= n ; j++)  
  14.              value[i][j] = INF;  
  15.      }  
  16.     for(int i = 0 ; i < m ; i++){  
  17.         scanf("%d%d%d" ,  &star , &end , &v);  
  18.         if(value[star][end] == INF)  
  19.             value[star][end] = value[end][star] = v;/*处理成无向图*/  
  20.         else{  
  21.             if(v < value[star][end])/*判断重边是否出现*/  
  22.                  value[star][end] = value[end][star] = v;  
  23.         }  
  24. }  
  25.   
  26. void dijkstra(int s){  
  27.      memset(vis , 0 , sizeof(vis));  
  28.      memset(father , 0 , sizeof(father));  
  29.      /*初始化dis数组*/  
  30.      for(int i = 1 ; i<= n ; i++)  
  31.           dis[i] = INF;  
  32.      dis[s] = 0;  
  33.      for(int i = 1 ; i <= n ; i++){/*枚举n个顶点*/  
  34.         int pos;  
  35.         pos = -1;  
  36.         for(int j = 1 ; j <= n ;j++){/*找到未加入集合的最短路点*/  
  37.            if(!vis[j] && (pos == -1 || dis[j] < dis[pos]))  
  38.               pos = j;  
  39.         }  
  40.         vis[pos] = 1;/*把这个点加入最短路径集合*/  
  41.         for(int j = 1 ; j <= n ; j++){/*更新dis数组*/  
  42.            if(!vis[j] && (dis[j] > dis[pos] + value[pos][j])){  
  43.              dis[j] = dis[pos] + value[pos][j];  
  44.              father[j] = pos;  
  45.            }  
  46.         }  
  47.      }  
  48. }  


[cpp]  view plain copy
  1. 优化过的，时间复杂度为o(mlogn);  
  2. /*利用邻接表来优化*/  
  3. #include    
  4. typedef pair<int , int>pii;/*pair专门把两个类型捆绑在一起的*/  
  5. priority_queue,greater >q;/*优先队列默认使用“<”，那么优先队列的元素是从大到小，所以自己定义“>”比较，STL中可以用greater来表示">"，这样就可以来声明一个小整数先出队的优先队列*/  
  6. #define MAXN 1010   
  7. #define INF 0xFFFFFFF   
  8. int n , m;/*有n个点，m条边*/  
  9. int first[MAXN] , next[MAXN];/*first数组保存的是节点i的第一条边，next保存的是边e的下一条边*/  
  10. int u[MAXN] , v[MAXN] , value[MAXN];  
  11. int vis[MAXN];  
  12. int dis[MAXN];  
  13.   
  14. /*读入这个图*/  
  15. void input(){  
  16.      scanf("%d%d" , &n , &m);  
  17.      /*初始化表头*/  
  18.      for(int i = 1 ; i <= n ; i++)  
  19.         first[i] = -1;  
  20.      for(int i = 1 ; i <= m ; i++){  
  21.         scanf("%d%d" , &u[i] , &v[i] , &value[i]);         
  22.         next[i] = first[u[i]];/*表头往后移动*/  
  23.         first[u[i]] = i;/*更新表头*/  
  24.      }  
  25. }  
  26.   
  27. /*Dijkstra*/  
  28. void Dijkstra(int s){  
  29.      memset(vis , 0 , sizeof(vis));  
  30.      /*初始化点的距离*/  
  31.      for(int i = 1 ; i <= n ; i++)  
  32.           dis[i] = INF;  
  33.     dis[s] = 0;  
  34.      while(!q.empty())  
  35.         q.pop();  
  36.      q.push(make_pair(dis[s] , s));  
  37.      while(!q.empty()){  
  38.           pii u = q.top();  
  39.           q.pop();  
  40.           int x = u.second;  
  41.           if(vis[x])  
  42.             continue;   
  43.           vis[x] = 1;  
  44.           for(int i = first[x] ; i != -1 ; i = next[i]){  
  45.              if(dis[v[e]] > dis[x] + value[i]){  
  46.                 dis[v[i]] = dis[x] + value[i];  
  47.                 q.push(make_pair(dis[v[i] , v[i]));  
  48.              }  
  49.           }  
  50.      }  
  51. }  
[cpp]  view plain  copy
  1. 优化过的，时间复杂度为o(mlogn);  
  2. /*利用邻接表来优化*/  
  3. #include   
  4. typedef pair<int , int>pii;/*pair专门把两个类型捆绑在一起的*/  
  5. priority_queue,greater >q;/*优先队列默认使用“<”，那么优先队列的元素是从大到小，所以自己定义“>”比较，STL中可以用greater来表示">"，这样就可以来声明一个小整数先出队的优先队列*/  
  6. #define MAXN 1010  
  7. #define INF 0xFFFFFFF  
  8. int n , m;/*有n个点，m条边*/  
  9. int first[MAXN] , next[MAXN];/*first数组保存的是节点i的第一条边，next保存的是边e的下一条边*/  
  10. int u[MAXN] , v[MAXN] , value[MAXN];  
  11. int vis[MAXN];  
  12. int dis[MAXN];  
  13.   
  14. /*读入这个图*/  
  15. void input(){  
  16.      scanf("%d%d" , &n , &m);  
  17.      /*初始化表头*/  
  18.      for(int i = 1 ; i <= n ; i++)  
  19.         first[i] = -1;  
  20.      for(int i = 1 ; i <= m ; i++){  
  21.         scanf("%d%d" , &u[i] , &v[i] , &value[i]);         
  22.         next[i] = first[u[i]];/*表头往后移动*/  
  23.         first[u[i]] = i;/*更新表头*/  
  24.      }  
  25. }  
  26.   
  27. /*Dijkstra*/  
  28. void Dijkstra(int s){  
  29.      memset(vis , 0 , sizeof(vis));  
  30.      /*初始化点的距离*/  
  31.      for(int i = 1 ; i <= n ; i++)  
  32.           dis[i] = INF;  
  33.     dis[s] = 0;  
  34.      while(!q.empty())  
  35.         q.pop();  
  36.      q.push(make_pair(dis[s] , s));  
  37.      while(!q.empty()){  
  38.           pii u = q.top();  
  39.           q.pop();  
  40.           int x = u.second;  
  41.           if(vis[x])  
  42.             continue;   
  43.           vis[x] = 1;  
  44.           for(int i = first[x] ; i != -1 ; i = next[i]){  
  45.              if(dis[v[e]] > dis[x] + value[i]){  
  46.                 dis[v[i]] = dis[x] + value[i];  
  47.                 q.push(make_pair(dis[v[i] , v[i]));  
  48.              }  
  49.           }  
  50.      }  
  51. }  


floyd(权值非负)适用于有向图和无向图

1 floyd 的思想就是通过枚举n个点利用DP的思想来更新最短距离的，假设当前枚举到第k个点，那么就有任意的两个点i , j ，如果i k 相连 j k 相连 那么就可以知道这个时候dis[i][j] = min(dis[i][j] , dis[i][k] + dis[k][j]);，那么只要枚举完n个点，那么就说明已经完全更新完所有两点直间的最短路。

2 floyd算法是最简单的最短路径的算法，可以计算图中任意两点间的最短路径。floyd算法的时间复杂度为o(n^3)，如果是一个没有边权的图，把相连的两点间的距离设为dis[i][j]=1.不相连的两点设为无穷大，用floyd算法可以判断i j两点是否相连。
3 floyd 算法不允许所有的权值为负的回路。可以求出任意两点之间的最短距离。处理的是无向图
4 缺点是时间复杂度比较高，不适合计算大量数据

5 如果dis[i][i] != 0，说明此时存在环。 

6 如果利用floyd求最小值的时候，初始化dis为INF ， 如果是求最大值的话初始化为-1.

7 模板：

[cpp]  view plain copy
  1. #define INF 0xFFFFFFF   
  2. #define MAXN 1010   
  3. int dis[MAXN][MAXN];  
  4.   
  5. /*如果是求最小值的话，初始化为INF即可*/  
  6. void init(){  
  7.      for(int i = 1 ; i <= n ; i++){  
  8.         for(int j = 1 ; j <= n ; j++)  
  9.              dis[i][j] = INF;  
  10.         dis[i][i] = 0;  
  11.      }  
  12. }  
  13.   
  14. /*如果是求最大值的话，初始化为-1*/  
  15. void init(){  
  16.      for(int i = 1 ; i <= n ; i++){  
  17.         for(int j = 1 ; j <= n ; j++)  
  18.              dis[i][j] = -1；  
  19.      }  
  20. }  
  21.   
  22. /*floyd算法*/  
  23. void folyd(){  
  24.         for(int k = 1 ; k <= n ; k++){/*枚举n个点来更新dis*/  
  25.             for(int i = 1 ; i <= n ; i++){  
  26.                 for(int j = 1 ; j <= n ; j++)  
  27.                   if(dis[i][k] != -1 && dis[j][k] != -1)/*如果在求最大值的时候加上这一句*/  
  28.                      dis[i][j] = min(dis[i][k]+dis[k][j] , dis[i][j]);   
  29.             }   
  30.        }  
  31.  }  
  32.    
[cpp]  view plain  copy
  1. #define INF 0xFFFFFFF  
  2. #define MAXN 1010  
  3. int dis[MAXN][MAXN];  
  4.   
  5. /*如果是求最小值的话，初始化为INF即可*/  
  6. void init(){  
  7.      for(int i = 1 ; i <= n ; i++){  
  8.         for(int j = 1 ; j <= n ; j++)  
  9.              dis[i][j] = INF;  
  10.         dis[i][i] = 0;  
  11.      }  
  12. }  
  13.   
  14. /*如果是求最大值的话，初始化为-1*/  
  15. void init(){  
  16.      for(int i = 1 ; i <= n ; i++){  
  17.         for(int j = 1 ; j <= n ; j++)  
  18.              dis[i][j] = -1；  
  19.      }  
  20. }  
  21.   
  22. /*floyd算法*/  
  23. void folyd(){  
  24.         for(int k = 1 ; k <= n ; k++){/*枚举n个点来更新dis*/  
  25.             for(int i = 1 ; i <= n ; i++){  
  26.                 for(int j = 1 ; j <= n ; j++)  
  27.                   if(dis[i][k] != -1 && dis[j][k] != -1)/*如果在求最大值的时候加上这一句*/  
  28.                      dis[i][j] = min(dis[i][k]+dis[k][j] , dis[i][j]);   
  29.             }   
  30.        }  
  31.  }  
  32.    

floyd扩展：

如何用floyd找出最短路径所行经的点： 1 这里要用到另一个矩阵P，它的定义是这样的：p(ij)的值如果为p，就表示i到j的最短行经为i->p...->j，也就是说p是i到j的最短行径中的j之前的第1个点。

2 P矩阵的初值为p(ij) = j。有了这个矩阵之后，要找最短路径就轻而易举了。对于i到j而言找出p(ij)，令为p，就知道了路径i->p....->j；再去找p(pj)，如果值为q，p到j的最短路径为p->q...->j；再去找p(qj)，如果值为r，i到q的最短路径为q>r...->q；所以一再反复，就会得到答案。

3  但是，如何动态的回填P矩阵的值呢？回想一下，当d(ij)>d(ik)+d(kj)时，就要让i到j的最短路径改为走i->...->k->...->j这一条路，但是d(ik)的值是已知的，换句话说，就是i->...->k这条路是已知的，所以i->...->k这条路上k的第一个城市(即p(ik))也是已知的，当然，因为要改走i->...->k->...->j这一条路，p(ij)的第一个城市正好是p(ik)。所以一旦发现d(ij)>d(ik)+d(kj)，就把p(ik)存入p(ij).

4 代码：

[cpp]  view plain copy
  1. int dis[MAXN][MAXN];  
  2. int path[MAXN][MAXN];  
  3.   
  4. void floyd(){  
  5.       int  i, j, k;  
  6.       /*先初始化化为j*/  
  7.       for (i = 1; i <= n; i++){  
  8.            for (j = 1; j <= n; j++)  
  9.                path[i][j] = j;  
  10.       }  
  11.       for (k = 1; k <= n; k++){/*枚举n个点*/  
  12.           for (i = 1; i <= n; i++){  
  13.               for (j = 1; j <= n; j++){  
  14.                    if (dis[i][j] > dis[i][k]+dis[k][j]){  
  15.                          path[i][j] = path[i][k];/*更新为path[i][k]*/  
  16.                          dis[i][j] = dis[i][k]+dis[k][j];  
  17.                     }  
  18.               }  
  19.            }  
  20.       }  
  21. }  
[cpp]  view plain  copy
  1. int dis[MAXN][MAXN];  
  2. int path[MAXN][MAXN];  
  3.   
  4. void floyd(){  
  5.       int  i, j, k;  
  6.       /*先初始化化为j*/  
  7.       for (i = 1; i <= n; i++){  
  8.            for (j = 1; j <= n; j++)  
  9.                path[i][j] = j;  
  10.       }  
  11.       for (k = 1; k <= n; k++){/*枚举n个点*/  
  12.           for (i = 1; i <= n; i++){  
  13.               for (j = 1; j <= n; j++){  
  14.                    if (dis[i][j] > dis[i][k]+dis[k][j]){  
  15.                          path[i][j] = path[i][k];/*更新为path[i][k]*/  
  16.                          dis[i][j] = dis[i][k]+dis[k][j];  
  17.                     }  
  18.               }  
  19.            }  
  20.       }  
  21. }  

2  floyd求解环中的最小环

1 为什么要在更新最短路之前求最小环：
在第k层循环，我们要找的是最大结点为k的环，而此时Dist数组存放的是k-1层循环结束时的经过k-1结点的最短路径，也就是说以上求出的最短路是不经过k点的，这就刚好符合我们的要求。为什么呢？假设环中结点i,j是与k直接相连，如果先求出经过k的最短路，那么会有这样一种情况，即：i到j的最短路经过k。这样的话就形成不了环 。

2最小环改进算法的证明：
一个环中的最大结点为k(编号最大)，与他相连的两个点为i,j，这个环的最短长度为g[i][k]+g[k][j]+dis[i][j] (i到j的路径中,所有结点编号都小于k的最短路径长度)。根据floyd的原理，在最外层循环做了k-1次之后，dist[i][j]则代表了i到j的路径中，所有结点编号都小于k的最短路径, 综上所述，该算法一定能找到图中最小环。

3 为什么还要value数组：
因为dis数组时刻都在变动不能表示出原来两个点之间的距离。

4 形成环至少要有3点不同的点，两个点是不能算环的。
5 代码：

[cpp]  view plain copy
  1. int mincircle = INF;  
  2. int dis[MAXN][MAXN];  
  3. int value[MAXN][MAXN];  
  4.   
  5. void floyd(){  
  6.      memcpy(value , dis , sizeof(value));  
  7.      for(int k = 1 ; k <= n ; k++){  
  8.           /*求最小环,不包含第k个点*/  
  9.           for(int i = 1 ; i < k ; i++){/*到k-1即可*/  
  10.                for(int j = i+1 ; j < k ; j++)/*到k-1即可*/  
  11.                    mincircle = min(mincircle , dis[i][j]+value[i][k]+value[k][j]);/*无向图*/  
  12.                    mincircle = min(mincircle , dis[i][j] +value[i][k]+value[k][j]);/*表示i->k ， k->j有边*/  
  13.            }  
  14.           /*更新最短路*/  
  15.           for(int i = 1 ; i <= n ; i++){  
  16.                for(int j = 1 ; j <= n ; j++)  
  17.                    dis[i][j] = min(dis[i][k]+dis[k][j] , dis[i][j]);  
  18.           }  
  19.      }    
  20. }  
[cpp]  view plain  copy
  1. int mincircle = INF;  
  2. int dis[MAXN][MAXN];  
  3. int value[MAXN][MAXN];  
  4.   
  5. void floyd(){  
  6.      memcpy(value , dis , sizeof(value));  
  7.      for(int k = 1 ; k <= n ; k++){  
  8.           /*求最小环,不包含第k个点*/  
  9.           for(int i = 1 ; i < k ; i++){/*到k-1即可*/  
  10.                for(int j = i+1 ; j < k ; j++)/*到k-1即可*/  
  11.                    mincircle = min(mincircle , dis[i][j]+value[i][k]+value[k][j]);/*无向图*/  
  12.                    mincircle = min(mincircle , dis[i][j] +value[i][k]+value[k][j]);/*表示i->k ， k->j有边*/  
  13.            }  
  14.           /*更新最短路*/  
  15.           for(int i = 1 ; i <= n ; i++){  
  16.                for(int j = 1 ; j <= n ; j++)  
  17.                    dis[i][j] = min(dis[i][k]+dis[k][j] , dis[i][j]);  
  18.           }  
  19.      }    
  20. }  

Bellman_Ford(权值可正可负)，用来判断负环 

1 Bellman_Frod可以计算边权为负值的最短路问题，适用于有向图和无向图.用来求解源点到达任意点的最短路。

2 在边权可正可负的图中，环有零环，正环，负环3种。如果包含零环和正环的话，去掉以后路径不会变成，如果包含负环则最短路是不存在的。那么既然不包含负环，所以最短路除了源点意外最多只经过n-1个点，这样就可以通过n-1次的松弛得到源点到每个点的最短路径。

3 时间复杂度o(n*m);
4 如果存在环的话就是经过n-1次松弛操作后还能更新dis数组。
5 模板：

[cpp]  view plain copy
  1. /* 
  2. 适用条件： 
  3. 1单源最短路径 
  4. 2有向图和无向图 
  5. 3边权可正可负 
  6. */  
  7.   
  8. #define INF 0xFFFFFFF   
  9. #define MAXN 1010*2   
  10. int dis[MAXN];/*dis[i]表示的是源点到点i的最短路*/  
  11. strucu Edge{  
  12.    int x;  
  13.    int y;  
  14.    int value;  
  15. }e[MAXN];  
  16.   
  17. /*返回最小值*/  
  18. int min(int a , int b){  
  19.     return a < b ? a : b;  
  20. }  
  21.   
  22. /*处理成无向图*/  
  23. void input(){  
  24.      for(int i = 0 ; i < m ; i++){  
  25.         scanf("%d%d%d" , e[i].x , &e[i].y , &e[i].value);  
  26.         e[i+m].x = e[i].y;/*注意地方*/  
  27.         e[i+m].y = e[i].x;/*注意地方*/  
  28.         e[i+m].value = e[i].value;            
  29.      }  
  30. }  
  31.   
  32. /*假设现在有n个点，m条边*/  
  33. void Bellman_Ford(int s){  
  34.     /*初始化dis数组*/  
  35.     for(int i = 1 ; i <= s ; i++)  
  36.          dis[i] = INF;  
  37.     dis[s] = 0;  
  38.     for(int i = 1 ; i < n ; i++){/*做n-1次松弛*/  
  39.        for(int j = 0 ; j < 2*m ; j++){/*每一次枚举2*m条边，因为是无向图*/  
  40.           if(dis[e[j].y] > dis[e[j].x] + e[j].value)  
  41.            dis[e[j.].y] = dis[e[i].x]+e[j].value;/*更新dis[e[j].y]*/  
  42.           }  
  43.        }  
  44.     }  
  45. }  
[cpp]  view plain  copy
  1. /* 
  2. 适用条件： 
  3. 1单源最短路径 
  4. 2有向图和无向图 
  5. 3边权可正可负 
  6. */  
  7.   
  8. #define INF 0xFFFFFFF  
  9. #define MAXN 1010*2  
  10. int dis[MAXN];/*dis[i]表示的是源点到点i的最短路*/  
  11. strucu Edge{  
  12.    int x;  
  13.    int y;  
  14.    int value;  
  15. }e[MAXN];  
  16.   
  17. /*返回最小值*/  
  18. int min(int a , int b){  
  19.     return a < b ? a : b;  
  20. }  
  21.   
  22. /*处理成无向图*/  
  23. void input(){  
  24.      for(int i = 0 ; i < m ; i++){  
  25.         scanf("%d%d%d" , e[i].x , &e[i].y , &e[i].value);  
  26.         e[i+m].x = e[i].y;/*注意地方*/  
  27.         e[i+m].y = e[i].x;/*注意地方*/  
  28.         e[i+m].value = e[i].value;            
  29.      }  
  30. }  
  31.   
  32. /*假设现在有n个点，m条边*/  
  33. void Bellman_Ford(int s){  
  34.     /*初始化dis数组*/  
  35.     for(int i = 1 ; i <= s ; i++)  
  36.          dis[i] = INF;  
  37.     dis[s] = 0;  
  38.     for(int i = 1 ; i < n ; i++){/*做n-1次松弛*/  
  39.        for(int j = 0 ; j < 2*m ; j++){/*每一次枚举2*m条边，因为是无向图*/  
  40.           if(dis[e[j].y] > dis[e[j].x] + e[j].value)  
  41.            dis[e[j.].y] = dis[e[i].x]+e[j].value;/*更新dis[e[j].y]*/  
  42.           }  
  43.        }  
  44.     }  
  45. }  

SPFA(权值可正可负)，判断负环.
1用来求解单源最短路径，源点到任意点的最短路。
2 算法介绍：建立一个队列q，初始时队列里只有一个起始点，在建立一个数组dis记录起始点到所有点的最短路径，并且初始化这个数组。然后进行松弛操作，用 队列里面的点去刷新起始点到所有点的最短路，如果刷新成功且刷新点不再队列中则把该点加入到队列最后，重复执行直到队列为空。
3 时间复杂度：O(ke),k指的是所有顶点的进队的平均次数，可以证明k<=2，e为边数

4 可以用SPFA来存在是否存在环，如果是的话就是存在一条边的松弛操作大于等于n。
5 模板：

[cpp]  view plain copy
  1. /* 
  2. 1 n个点 m条边 
  3. 2 邻接表存储图: first[i]存储的是节点i的第一条边的编号，nest[i]存储的是编号为i的边的下一条边的编号。 
  4. 3 star[i]表示编号为i的边的起点，end[i]表示编号为i的边的终点，value[i]表示编号为i的边的权值。 
  5. 4 dis[i] 表示的源点到i的最短路 
  6. */  
  7.   
  8. #define MAXN 1010   
  9. #define INF 0xFFFFFFF   
  10.   
  11. int n , m;  
  12. int first[MAXN] , next[MAXN];  
  13. int star[MAXN] , end[MAXN] , value[MAXN];  
  14. int dis[MAXN];  
  15. queue<int>q;  
  16.   
  17. /*输入*/  
  18. void input(){  
  19.      scanf("%d%d" , &n , &m);  
  20.      /*初始化表头*/  
  21.      for(int i = 1 ; i <= n ; i++){  
  22.         first[i] = -1;  
  23.         next[i] = -1;  
  24.      }  
  25.      /*读入m条边*/  
  26.      for(int i = 0 ; i < m ; i++){  
  27.         scanf("%d%d%d" , &star[i] , &end[i] , &value[i]);  
  28.         star[i+m] = end[i];  
  29.         end[i+m] = star[i];  
  30.         value[i+m] = value[i];  
  31.   
  32.         next[i] = first[star[i]];/*由于要插入表头，所以将原先表头后移*/  
  33.         first[star[i]] = i;/*插入表头*/  
  34.         next[i+m] = first[star[i+m]];  
  35.         first[star[i+m]] = i+m;  
  36.      }  
  37. }  
  38.   
  39. /*SPFA*/  
  40. void SPFA(int s){  
  41.      while(!q.empty())  
  42.           q.pop();  
  43.      int vis[MAXN];  
  44.      memset(vis , 0 , sizeof(vis));  
  45.      /*初始化dis*/  
  46.      for(int i = 1 ; i <= n ; i++)  
  47.           dis[i] = INF;  
  48.      dis[s] = 0;  
  49.      q.push(s);/*将源点加入队列*/  
  50.      vis[s] = 1;/*源点标记为1*/  
  51.      while(!q.empty()){  
  52.           int x = q.front();  
  53.           q.pop();  
  54.           vis[x] = 0;/*注意这里要重新标记为0，说明已经出队*/  
  55.           /*枚举和点x有关的所有边*/  
  56.           for(int i = first[x] ; i != -1 ; i = next[i]){  
  57.              if(dis[end[i]] > dis[x] + value[i]){/*松弛操作，利用三角不等式*/  
  58.                dis[end[i]] = dis[x] + value[i];  
  59.                if(!vis[end[i]]){/*如果该点不再队列里面*/  
  60.                   vis[end[i]] = 1;                  
  61.                   q.push(end[i]);  
  62.                }  
  63.              }  
  64.           }  
  65.      }  
[cpp]  view plain  copy
  1. /* 
  2. 1 n个点 m条边 
  3. 2 邻接表存储图: first[i]存储的是节点i的第一条边的编号，nest[i]存储的是编号为i的边的下一条边的编号。 
  4. 3 star[i]表示编号为i的边的起点，end[i]表示编号为i的边的终点，value[i]表示编号为i的边的权值。 
  5. 4 dis[i] 表示的源点到i的最短路 
  6. */  
  7.   
  8. #define MAXN 1010  
  9. #define INF 0xFFFFFFF  
  10.   
  11. int n , m;  
  12. int first[MAXN] , next[MAXN];  
  13. int star[MAXN] , end[MAXN] , value[MAXN];  
  14. int dis[MAXN];  
  15. queue<int>q;  
  16.   
  17. /*输入*/  
  18. void input(){  
  19.      scanf("%d%d" , &n , &m);  
  20.      /*初始化表头*/  
  21.      for(int i = 1 ; i <= n ; i++){  
  22.         first[i] = -1;  
  23.         next[i] = -1;  
  24.      }  
  25.      /*读入m条边*/  
  26.      for(int i = 0 ; i < m ; i++){  
  27.         scanf("%d%d%d" , &star[i] , &end[i] , &value[i]);  
  28.         star[i+m] = end[i];  
  29.         end[i+m] = star[i];  
  30.         value[i+m] = value[i];  
  31.   
  32.         next[i] = first[star[i]];/*由于要插入表头，所以将原先表头后移*/  
  33.         first[star[i]] = i;/*插入表头*/  
  34.         next[i+m] = first[star[i+m]];  
  35.         first[star[i+m]] = i+m;  
  36.      }  
  37. }  
  38.   
  39. /*SPFA*/  
  40. void SPFA(int s){  
  41.      while(!q.empty())  
  42.           q.pop();  
  43.      int vis[MAXN];  
  44.      memset(vis , 0 , sizeof(vis));  
  45.      /*初始化dis*/  
  46.      for(int i = 1 ; i <= n ; i++)  
  47.           dis[i] = INF;  
  48.      dis[s] = 0;  
  49.      q.push(s);/*将源点加入队列*/  
  50.      vis[s] = 1;/*源点标记为1*/  
  51.      while(!q.empty()){  
  52.           int x = q.front();  
  53.           q.pop();  
  54.           vis[x] = 0;/*注意这里要重新标记为0，说明已经出队*/  
  55.           /*枚举和点x有关的所有边*/  
  56.           for(int i = first[x] ; i != -1 ; i = next[i]){  
  57.              if(dis[end[i]] > dis[x] + value[i]){/*松弛操作，利用三角不等式*/  
  58.                dis[end[i]] = dis[x] + value[i];  
  59.                if(!vis[end[i]]){/*如果该点不再队列里面*/  
  60.                   vis[end[i]] = 1;                  
  61.                   q.push(end[i]);  
  62.                }  
  63.              }  
  64.           }  
  65.      }  

你可能感兴趣的:(最短路,最短路)

  • 广度优先搜索(BFS)算法解决迷宫最短路径问题 CDSNT 宽度优先算法c++
    问题描述：①迷宫由n行m列的单元格组成（n，m都小于等于50）②每个单元格要么是空地，要么是障碍物现请你找到一条从起点到终点的最短路径，输出最短路径及其长度，若不存在，则输出“NoAnswer.”。输入迷宫大小（n行m列）：5411011111110110111110输入起点的坐标：00输入终点的坐标：32输出：最短路径长度为7最短路径：(0,0)(1,0)(2,0)(3,0)(4,0)(4,1)
  • 数据结构考前一天 蒟蒻的贤 数据结构
    线性表：矩阵，链表（单链表必考）栈和队列：出入判断，括号匹配，中缀转后缀字符串数组：模式匹配next，nextval数组，数组寻址，三角矩阵对应一维数组k，二叉树：二叉链表，求叶子数量，求深度，左右转换，前中后遍历，森林与二叉树转化，哈夫曼树，哈夫曼编码，图：DFS，BFS，邻接矩阵，邻接表（EdgeNode,VertexNode），最小生成树（prime加点，kruskal加边），最短路径（di
  • 数据结构——二叉树的最小深度算法 943802606 #数据结构数据结构二叉树c语言
    给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。说明：叶子节点是指没有子节点的节点。输入：root=[3,9,20,null,null,15,7]输出：2示例2：输入：root=[2,null,3,null,4,null,5,null,6]输出：5提示：树中节点数的范围在[0,105]内-1000lchild不为空且T->rchild为空，返回左子树的高度+
  • 111.二叉树的最小深度 -----力扣每日打卡Day17 爱吃草莓蛋糕的猴 算法题二叉树算法leetcode
    目录1.题目2.题目分析3.代码实现1.题目给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。说明:叶子节点是指没有子节点的节点。示例:给定二叉树[3,9,20,null,null,15,7],3/\920/\157返回它的最小深度2.C语言函数头：/***Definitionforabinarytreenode.*structTreeNode{*intval
  • 力扣刷题--111、二叉树的最小深度 莫等闲，白了少年头 LeetCode算法javaLeetCode二叉树的最小深度
    题目：二叉树的最小深度题号：111难易程度：简单题面：给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。说明：叶子节点是指没有子节点的节点。示例1输入：root=[3,9,20,null,null,15,7]输出：2示例二：输入：root=[2,null,3,null,4,null,5,null,6]输出：5题目意思：即题面。题解：题解:1、分成四种情况。第一
  • 红黑树实现 黎相思 C++算法c++数据结构
    目录1.红黑树的概念1.1红黑树的规则1.2红黑树如何确保最长路径不超过最短路径的2倍呢?1.3红黑树的效率编辑2.红黑树的实现2.1红黑树的结构2.2红黑树的插入2.2.1红黑树插入一个值的大概过程2.2.2情况1:变色2.2.3情况2:单旋+变色2.2.4情况3:双旋+变色2.3红黑树的插入代码实现2.4红黑树的查找2.5红黑树的高度2.6红黑树节点个数2.7红黑树的验证2.8红黑树的删除3.
  • leetcode搜索系列 页图 leetcodec++leetcode
    BFS1.计算在网格中从原点到特定点的最短路径长度2.组成整数的最小平方数数量3.最短单词路径DFS1.查找最大的连通面积2.矩阵中的连通分量数目3.好友关系的连通分量数目4.填充封闭区域5.能到达的太平洋和大西洋的区域Backtracking1.数字键盘组合2.IP地址划分3.在矩阵中寻找字符串4.输出二叉树中所有从根到叶子的路径5.排列6.含有相同元素求排列7.组合8.组合求和9.含有相同元素
  • 2023年数学建模动态规划算法在最短路径问题中的应用：以Floyd算法为例 人工智能_SYBH 算法matlab数据结构动态规划
    订阅专栏后9月比赛期间会分享思路及Matlab代码数学建模是将实际问题抽象化为数学问题，并采用数学工具和技巧进行求解的过程。在实际应用中，数学建模是解决问题的一种有效方法。本文将介绍Floyd算法在数学建模中的应用。Floyd算法是解决最短路径问题的一种经典动态规划算法。最短路径问题是指在一个加权有向图中，从一个源节点到其他各节点的最短路径问题。在实际应用中，最短路径问题广泛应用于交通运输、通信网
  • 【考研】南邮历年复试上机试题目与题解 SpareLin 考研算法
    【考研】南邮历年复试上机试题目与题解文章目录【考研】南邮历年复试上机试题目与题解个人题目难度评估历年上机题目PROB1002求最值问题PROB1003新对称素数问题PROB1004进制转换PROB1005涂色问题(待补)PROB1006最大公约数和最小公倍数PROB1007斐波那契数列PROB1008回文回文PROB1009单源最短路PROB1010萌萌摘苹果PROB1011忠诚的骑士PROB10
  • 【面试笔记】过河问题｜图论｜羊｜狼｜农夫｜BFS unity
    题干要从A岸出发到B岸，A岸有M只羊、N只狼和1个农夫，船每一趟可载X只动物。有农夫看着、或则羊的数量大于狼，羊就不会被吃。请返回任一躺数最少方案。题解题目可转化为：在一个有向无路长的图中，在不知道各个节点之间如何连接的基础上，找到两个节点之间的最短路径。数据结构publicclassPack{publicintsheep;//羊的数量publicintwolf;//狼的数量publicintfa
  • 数据结构与算法分析：专题内容——人工智能中的寻路3之广度优先搜索（代码详解） 梅见十柒 数据结构与算法分析算法c语言广度优先笔记
    一、前言广度优先搜索尝试在不重复访问状态的情况下，寻找到一条最短路径。广度优先搜索保证如果存在一条到目标状态的路径，那么找到的肯定是最短路径。事实上，深度优先搜索和广度优先搜索的唯一不同就是广度优先搜索使用队列来保存开放集，而深度优先搜索使用栈。每次迭代时，广度优先搜索从队列头拿出一个未访问的状态，然后从这个状态开始，计算后继状态。如果达到了目标状态，那么搜索结束。任何已经在闭合集中的后继状态将会
  • 企业级网络架构 哦吼吼吼tian
    目录三层交换机三层交换机使用过程:连接外网动态路由ospf协议,开放最短路径优先协议ospf区域区域ID骨干区域0ospf配置:传输层传输层的作用传输层两个重要的协议TCP的应用UDP应用ACL访问控制列表ACL的主要类型ACL规则三层交换机使用三层交换技术实现VLAN间通信三层交换=二层交换+三层转发三层交换机使用过程:1.添加VLAN(vlanbatch23)2.对应的接口添加相应的VLAN(
  • 蓝桥杯Python组最后几天冲刺———吐血总结,练题总结,很管用我学会了 晚风时亦鹿 学习笔记Python算法笔记python
    一、重要知识要点1、穷举法2、枚举法3、动态规划4、回溯法5、图论6、深度优先搜索（DFS）7、广度优先搜索（BFS）8、二叉树9、递归10、分治法、矩阵法11、排列组合12、素数、质数、水仙花数13、欧几里得定理gcd14、求最大公约数、最小公倍数15、海伦公式（求三角形面积）16、博弈论17、贪心18、二分查找法19、hash表20、日期计算21、矩形快速幂22、树形DP23、最短路径24、最
  • 七.网络模型 Kylin524 运筹学python
    最小(支撑)树问题最小部分树求解：破圈法：任取一圈，去掉圈中最长边，直到无圈；加边法：取图G的n个孤立点｛v1，v2，…，vn}作为一个支撑图，从最短边开始往支撑图中添加，见圈回避，直到连通（有n－1条边）最短路问题求最短路有两种算法：求从某一点至其它各点之间最短离的狄克斯屈拉(Dijkstra)算法求网络图上任意两点之间最短路的Floyd(弗洛伊德)矩阵算法最短路问题的数学模型最大流问题：最大流
  • ospf收敛特性及其他的小特性 大丈夫立于天地间 hcie笔记智能路由器网络信息与通信学习算法网络协议
    1.收敛特性快速收敛： ·只第一次计算时计算全部节点FullSPF ·增量最短路径优先算法I-SPF（Incremental）   只对受影响的节点进行路由计算 ·全部路由计算PRC   只对发生变化的路由进行重新计算;   根据I-SPF算出来的SPT来更新路由。开销：RPCOspf1 spf-schedule-intervalxxxxxxmax-interva为OSPF SPF计算的最长间隔时
  • pythonsvm模型优化_Python进化算法工具箱的使用（三）用进化算法优化SVM参数 weixin_39878698 pythonsvm模型优化
    前言自从上两篇博客详细讲解了Python遗传和进化算法工具箱及其在带约束的单目标函数值优化中的应用以及利用遗传算法求解有向图的最短路径之后，我经过不断学习工具箱的官方文档以及对源码的研究，更加掌握如何利用遗传算法求解更多有趣的问题了。与前面的文章不同，本篇采用差分进化算法来优化SVM中的参数C和Gamma。(用遗传算法也可以，下面会给出效果比较)首先简单回顾一下Python高性能实用型遗传和进化算
  • 差分进化算法_Python进化算法工具箱的使用（三）用进化算法优化SVM参数 weixin_39747075 差分进化算法
    前言自从上两篇博客详细讲解了Python遗传和进化算法工具箱及其在带约束的单目标函数值优化中的应用以及利用遗传算法求解有向图的最短路径之后，我经过不断学习工具箱的官方文档以及对源码的研究，更加掌握如何利用遗传算法求解更多有趣的问题了。与前面的文章不同，本篇采用差分进化算法来优化SVM中的参数C和Gamma。（用遗传算法也可以，下面会给出效果比较）首先简单回顾一下Python高性能实用型遗传和进化算
  • OSPF（1）：基础知识与数据包、状态机、工作过程 小度爱学习 网络安全从小白到大神网络
    引言上一篇我们学习了RIP：RIP基础知识与配置，可是通过学习，我们发现RIP似乎只能运用在中小型网络中，那么中大型网络应该怎么做呢？这一篇博客我们就来学习OSPFOSPF---开放式最短路径优先协议动态路由优势评价维度：选路佳，收敛快，占用资源少RIP与OSPF比较1.OSPF本身是链路状态型协议，所以计算出的路径不会存在环路，并且使用带宽作为选路依据，所以，OSPF在选路的角度上优于RIP；2
  • 深入浅出广度优先搜索（BFS）：从原理到 Python 代码实现 纪至训至 算法python
    引言在图论和计算机科学中，广度优先搜索（Breadth-FirstSearch，简称BFS）是一种用于遍历或搜索图或树结构的算法。它从给定的起始节点开始，以广度优先的方式逐层探索图的节点，直到找到目标节点或遍历完整个图。BFS在许多实际问题中都有广泛应用，如路径规划、迷宫求解、社交网络分析等。本文将详细介绍BFS的原理，并通过一个Python代码示例，即使用BFS查找二维网格中从起点到终点的最短路
  • 图论算法——最短路问题 青云遮夜雨 数据结构算法数据结构c语言图论
    最短路问题无权最短路简单介绍算法优化(借助队列）Dijkstra算法具有负边值的图的最短路算法无权最短路简单介绍对于无权图G（边没有权值或认为权值为1），如果G是连通的，则每个顶点之间都存在路径。最短路径算法就是要找到一条连接不同顶点的最短路径。例如：V2到V5可以是V2->V5，也可以是V2->V0->V3->V5，很明显最短路是前者算法主要思路：广度优先搜索（bfs）：对于每个顶点，我们将跟踪
  • 算法之图论 专业刷题Pia 算法图论
    连接图有向图问题无向图问题无向图最短路径127.单词接龙-力扣（LeetCode）分析：对于无向图最短路径问题，建议使用BFS（对点的扩展关联（扩散迭代方式））。同时由于无向性注意建立查找集合Visit（防止进入循环）。建立uset方便查找。建立umap方便查重并记录。思路：uset记录所有wordlist中的word，通过bfs获得满足条件（uset找到，umap未出现）的点，并在umap记录（
  • 洛谷P2865 [USACO06NOV] Roadblocks G【C++解法】【次短路问题】 #Dong# c++算法数据结构图论
    /*求次短路问题【spfa解法】本题思路：1.用spfa做，用d1记录从1到n所有点距离点1的最短距离，用d2记录从n到1所有点距离点n的最短距离那么此时d1[n]即为1到n点的最短距离2.遍历每个顶点x，找到它们所指向的点y，利用d1[x](x距离1的最短距离)+d2[y](y距·离n的最短距离)+w[i](x和y的边的权值)因为次短路一定严格大于最短路，而且又是除了最短路以外最小的那个，所以利
  • P3489 [POI2009] WIE-Hexer summ1ts 算法c++图论dijkstra状态压缩
    *原题链接*最短路+状态压缩不愧是POI的题，看题面知道要求加了一些限制的最短路，看数据范围很容易想到状态压缩。求解最短路就用堆优化dijkstra好了。至于状态压缩，我们对原数组再开一维，表示此时“剑的集合”，相应的数组也要多开一维。由于此时的最短路有状态的限制，所以我们要用三元组来维护，如果不想写结构体也可以pair,int>。输入时存储边上的“怪物集合”，以及一个村庄的“铁匠集合”，在来到新
  • P2865 [USACO06NOV] Roadblocks G（洛谷）(次短路) 叶子清不青 算法
    开一个二维数组dis[N][2]分别记录最短路和次短路即可。dijkstra和spfa均可，推荐spfa。//dijkstra#includeusingnamespacestd;constintN=1e5+5;typedeflonglongll;typedefpairPII;intn,m,k;intT;priority_queue,greater>q;structnode{inte,w;};vec
  • P2865 [USACO06NOV]路障Roadblocks dianshu0741
    次短路模板题吧题意已经非常裸了：求无向图的1到n次短路。直接套用最短路(dijkstra)的主要框架。但在这个的基础上添加另外一个数组dist2。走到一条边的时候来三个判定：dist[u]+weightdist[v]&&dist[u]+weightrhs.d;}};voidlink(intu,intv,intw){e[++tot]=(Edges){head[u],v,w};head[u]=tot;
  • Luogu P3489 [POI2009]WIE-Hexer 最短路 躲不过这哀伤
    https://www.luogu.org/problemnew/show/P3489普通的最短路，不过我觉得这个复杂度按道理来说边数不应该是m*2^13吗，不知道是数据比较水还是实际上能证明复杂度低一些。代码如下#includeusingnamespacestd;constintmaxn=210;#definepapairintn,m,p,k;intdis[maxn][8200]={},kn[m
  • P4779 【模板】单源最短路径(堆优化dijkstra) summ1ts 一些模版算法图论最短路dijkstra堆
    堆优化dijkstra，时间复杂度，我个人写习惯的模版。#includeusingnamespacestd;#definePIIpair#definefifirst#definesesecondconstintN=2e5+10;intread(){intx=0,f=1;charch=getchar();while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar()
  • 算法练习——迷宫问题（Java）bfs广搜 流萤点火 算法bfsjava
    问题描述：小明置身于一个迷宫，请你帮小明找出从起点到终点的最短路程。小明只能向上下左右四个方向移动。输入输入包含多组测试数据。输入的第一行是一个整数T，表示有T组测试数据。每组输入的第一行是两个整数N和M（1que,intgx,intgy,intn,intm,char[][]arr){Qq=newQ();q.x=sx;q.y=sy;q.dept=0;que.add(q);//添加intfinish
  • 华南农业大学 OJ数据结构 迷宫问题2(C、C++) 打架戴手表、
    18720迷宫问题（最短路径）时间限制:1000MS代码长度限制:10KB提交次数:0通过次数:0题型:编程题语言:不限定Description迷宫是一个n*m的矩阵，玩家需要迷宫入口(坐标1,1)出发，寻找路径走到出口(n,m)。请判断玩家能否从迷宫中走出，如果能走出迷宫输出，输出最短的路径长度，否则输出-1。输入格式第一行两个整数n和m，代表n行m列。(1typedefstruct{intro
  • 数据结构OJ作业——队列 nnbs 数据结构数据结构poj队列
    POJ3984：http://poj.org/problem?id=3984迷宫，输出最短路径，bfs#include#include#include#includeusingnamespacestd;intmaze[5][5];pairpath[5][5];queue>q;intdx[]={1,-1,0,0};intdy[]={0,0,1,-1};voidbfs(intx,inty){q.pus
  • mysql主从数据同步 林鹤霄 mysql主从数据同步
    配置mysql5.5主从服务器(转) 教程开始：一、安装MySQL 说明：在两台MySQL服务器192.168.21.169和192.168.21.168上分别进行如下操作，安装MySQL 5.5.22  二、配置MySQL主服务器（192.168.21.169）mysql  -uroot  -p   &nb
  • oracle学习笔记 caoyong oracle
    1、ORACLE的安装    a>、ORACLE的版本    8i,9i :   i是internet    10g,11g : grid (网格)    12c : cloud (云计算)       b>、10g不支持win7 &
  • 数据库，SQL零基础入门 天子之骄 sql数据库入门基本术语
    数据库，SQL零基础入门        做网站肯定离不开数据库，本人之前没怎么具体接触SQL，这几天起早贪黑得各种入门，恶补脑洞。一些具体的知识点，可以让小白不再迷茫的术语，拿来与大家分享。          数据库，永久数据的一个或多个大型结构化集合，通常与更新和查询数据的软件相关
  • pom.xml 一炮送你回车库 pom.xml
    1、一级元素dependencies是可以被子项目继承的 2、一级元素dependencyManagement是定义该项目群里jar包版本号的，通常和一级元素properties一起使用，既然有继承，也肯定有一级元素modules来定义子元素 3、父项目里的一级元素<modules> <module>lcas-admin-war</module> <
  • sql查地区省市县 3213213333332132 sqlmysql
    -- db_yhm_city SELECT * FROM db_yhm_city WHERE class_parent_id = 1 -- 海南 class_id = 9 港、奥、台 class_id = 33、34、35 SELECT * FROM db_yhm_city WHERE class_parent_id =169 SELECT d1.cla
  • 关于监听器那些让人头疼的事 宝剑锋梅花香 画图板监听器鼠标监听器
           本人初学JAVA，对于界面开发我只能说有点蛋疼，用JAVA来做界面的话确实需要一定的耐心（不使用插件，就算使用插件的话也没好多少）既然Java提供了界面开发，老师又要求做，只能硬着头皮上啦。但是监听器还真是个难懂的地方，我是上了几次课才略微搞懂了些。       
  • JAVA的遍历MAP darkranger map
    Java Map遍历方式的选择 1. 阐述 　　对于Java中Map的遍历方式，很多文章都推荐使用entrySet，认为其比keySet的效率高很多。理由是：entrySet方法一次拿到所有key和value的集合；而keySet拿到的只是key的集合，针对每个key，都要去Map中额外查找一次value，从而降低了总体效率。那么实际情况如何呢？ 　　为了解遍历性能的真实差距，包括在遍历ke
  • POJ 2312 Battle City 优先多列+bfs aijuans 搜索
    来源：http://poj.org/problem?id=2312 题意：题目背景就是小时候玩的坦克大战，求从起点到终点最少需要多少步。已知S和R是不能走得，E是空的，可以走，B是砖，只有打掉后才可以通过。 思路：很容易看出来这是一道广搜的题目，但是因为走E和走B所需要的时间不一样，因此不能用普通的队列存点。因为对于走B来说，要先打掉砖才能通过，所以我们可以理解为走B需要两步，而走E是指需要1
  • Hibernate与Jpa的关系，终于弄懂 avords javaHibernate数据库jpa
    我知道Jpa是一种规范，而Hibernate是它的一种实现。除了Hibernate，还有EclipseLink(曾经的toplink)，OpenJPA等可供选择，所以使用Jpa的一个好处是，可以更换实现而不必改动太多代码。 在play中定义Model时，使用的是jpa的annotations，比如javax.persistence.Entity, Table, Column, OneToMany
  • 酸爽的console.log bee1314 console
    在前端的开发中，console.log那是开发必备啊，简直直观。通过写小函数，组合大功能。更容易测试。但是在打版本时，就要删除console.log，打完版本进入开发状态又要添加，真不够爽。重复劳动太多。所以可以做些简单地封装，方便开发和上线。 /** * log.js hufeng * The safe wrapper for `console.xxx` functions *
  • 哈佛教授：穷人和过于忙碌的人有一个共同思维特质 bijian1013 时间管理励志人生穷人过于忙碌
            一个跨学科团队今年完成了一项对资源稀缺状况下人的思维方式的研究，结论是：穷人和过于忙碌的人有一个共同思维特质，即注意力被稀缺资源过分占据，引起认知和判断力的全面下降。这项研究是心理学、行为经济学和政策研究学者协作的典范。 　　这个研究源于穆来纳森对自己拖延症的憎恨。他7岁从印度移民美国，很快就如鱼得水，哈佛毕业
  • other operate 征客丶 OSosx
    一、Mac Finder 设置排序方式，预览栏 在显示－》查看显示选项中 二、有时预览显示时，卡死在那，有可能是一些临时文件夹被删除了，如：/private/tmp[有待验证] -------------------------------------------------------------------- 若有其他凝问或文中有错误，请及时向我指出， 我好及时改正，同时也让我们一
  • 【Scala五】分析Spark源代码总结的Scala语法三 bit1129 scala
    1. If语句作为表达式 val properties = if (jobIdToActiveJob.contains(jobId)) { jobIdToActiveJob(stage.jobId).properties } else { // this stage will be assigned to "default" po
  • ZooKeeper 入门 BlueSkator 中间件zk
    ZooKeeper是一个高可用的分布式数据管理与系统协调框架。基于对Paxos算法的实现，使该框架保证了分布式环境中数据的强一致性，也正是基于这样的特性，使得ZooKeeper解决很多分布式问题。网上对ZK的应用场景也有不少介绍，本文将结合作者身边的项目例子，系统地对ZK的应用场景进行一个分门归类的介绍。 值得注意的是，ZK并非天生就是为这些应用场景设计的，都是后来众多开发者根据其框架的特性，利
  • MySQL取得当前时间的函数是什么 格式化日期的函数是什么 BreakingBad mysqlDate
    取得当前时间用 now() 就行。 在数据库中格式化时间 用DATE_FORMA T(date, format) . 根据格式串format 格式化日期或日期和时间值date，返回结果串。 可用DATE_FORMAT( ) 来格式化DATE 或DATETIME 值，以便得到所希望的格式。根据format字符串格式化date值: %S, %s 两位数字形式的秒（ 00,01,
  • 读《研磨设计模式》-代码笔记-组合模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; abstract class Component { public abstract void printStruct(Str
  • 4_JAVA+Oracle面试题(有答案) chenke oracle
    基础测试题 卷面上不能出现任何的涂写文字，所有的答案要求写在答题纸上，考卷不得带走。 选择题 1、 What will happen when you attempt to compile and run the following code? （3） public class Static { static { int x = 5; // 在static内有效 } st
  • 新一代工作流系统设计目标 comsci 工作算法脚本
      用户只需要给工作流系统制定若干个需求，流程系统根据需求，并结合事先输入的组织机构和权限结构，调用若干算法，在流程展示版面上面显示出系统自动生成的流程图，然后由用户根据实际情况对该流程图进行微调，直到满意为止，流程在运行过程中，系统和用户可以根据情况对流程进行实时的调整，包括拓扑结构的调整，权限的调整，内置脚本的调整。。。。。 在这个设计中，最难的地方是系统根据什么来生成流
  • oracle 行链接与行迁移 daizj oracle行迁移
    表里的一行对于一个数据块太大的情况有二种(一行在一个数据块里放不下) 第一种情况: INSERT的时候，INSERT时候行的大小就超一个块的大小。Oracle把这行的数据存储在一连串的数据块里(Oracle Stores the data for the row in a chain of data blocks)，这种情况称为行链接(Row Chain)，一般不可避免(除非使用更大的数据
  • [JShop]开源电子商务系统jshop的系统缓存实现 dinguangx jshop电子商务
    前言 jeeshop中通过SystemManager管理了大量的缓存数据，来提升系统的性能，但这些缓存数据全部都是存放于内存中的，无法满足特定场景的数据更新（如集群环境）。JShop对jeeshop的缓存机制进行了扩展，提供CacheProvider来辅助SystemManager管理这些缓存数据，通过CacheProvider,可以把缓存存放在内存,ehcache,redis，memcache
  • 初三全学年难记忆单词 dcj3sjt126com englishword
    several 儿子；若干 shelf 架子 knowledge 知识；学问 librarian 图书管理员 abroad 到国外，在国外 surf 冲浪 wave 浪；波浪 twice 两次；两倍 describe 描写；叙述 especially 特别；尤其 attract 吸引 prize 奖品；奖赏 competition 比赛；竞争 event 大事；事件 O
  • sphinx实践 dcj3sjt126com sphinx
      安装参考地址:http://briansnelson.com/How_to_install_Sphinx_on_Centos_Server   yum install sphinx 如果失败的话使用下面的方式安装 wget http://sphinxsearch.com/files/sphinx-2.2.9-1.rhel6.x86_64.rpm yum loca
  • JPA之JPQL（三） frank1234 ormjpaJPQL
    1 什么是JPQL JPQL是Java Persistence Query Language的简称，可以看成是JPA中的HQL， JPQL支持各种复杂查询。 2 检索单个对象 @Test public  void querySingleObject1() {     Query query = em.createQuery("sele
  • Remove Duplicates from Sorted Array II hcx2013 remove
    Follow up for "Remove Duplicates":What if duplicates are allowed at most twice? For example,Given sorted array nums = [1,1,1,2,2,3], Your function should return length
  • Spring4新特性——Groovy Bean定义DSL jinnianshilongnian spring 4
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • CentOS安装Mysql5.5 liuxingguome centos
    CentOS下以RPM方式安装MySQL5.5 首先卸载系统自带Mysql： yum remove mysql mysql-server mysql-libs compat-mysql51 rm -rf /var/lib/mysql rm /etc/my.cnf 查看是否还有mysql软件： rpm -qa|grep mysql 去http://dev.mysql.c
  • 第14章 工具函数（下） onestopweb 函数
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • POJ 1050 SaraWon 二维数组子矩阵最大和
    POJ ACM第1050题的详细描述，请参照 http://acm.pku.edu.cn/JudgeOnline/problem?id=1050 题目意思： 给定包含有正负整型的二维数组，找出所有子矩阵的和的最大值。 如二维数组 0 -2 -7 0 9 2 -6 2 -4 1 -4 1 -1 8 0 -2 中和最大的子矩阵是 9 2 -4 1 -1 8 且最大和是15
  • [5]设计模式——单例模式 tsface java单例设计模式虚拟机
    单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点   安全的单例模式：     /* * @(#)Singleton.java 2014-8-1 * * Copyright 2014 XXXX, Inc. All rights reserved. */ package com.fiberhome.singleton;
  • Java8全新打造，英语学习supertool yangshangchuan javasuperword闭包java8函数式编程
    superword是一个Java实现的英文单词分析软件，主要研究英语单词音近形似转化规律、前缀后缀规律、词之间的相似性规律等等。Clean code、Fluent style、Java8 feature: Lambdas, Streams and Functional-style Programming。   升学考试、工作求职、充电提高，都少不了英语的身影，英语对我们来说实在太重要
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他