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.      }  

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

  • 洛谷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
  • 运筹学——图论与最短距离（Python实现）(2)，2024年最新Python高级面试framework m0_60575487 2024年程序员学习图论python面试
    适用于wij≥0，给出了从vs到任意一个点vj的最短路。Dijkstra算法是在1959年提出来的。目前公认，在所有的权wij≥0时，这个算法是寻求最短路问题最好的算法。并且，这个算法实际上也给出了寻求从一个始定点vs到任意一个点vj的最短路。2案例1——贪心算法实现==============2.1旅行商问题（TSP）**旅行商问题(TravelingSalesmanProblem，TSP)**
  • C语言-数据结构 无向图迪杰斯特拉算法(Dijkstra)邻接矩阵存储 Happy鱿鱼 算法c语言数据结构
    在迪杰斯特拉中，相比普利姆算法，是从顶点出发的一条路径不断的寻找最短路径，在实现的时候需要创建三个辅助数组，记录算法的关键操作，分别是Visited[MAXVEX]记录顶点是否被访问，教材上写的final数组但作用是一样的，然后第二个数组是TmpDistance[MAXVEX]，教材使用的D数组，命名语义化较弱不太好理解，实际用途与TmpDistance一样的，用于记录算法过程中，当前顶点到达邻接
  • bfs 求解迷宫最短路径问题 蒟蒻彧彧 搜索
    问题描述下图给出了一个迷宫的平面图，其中标记为1的为障碍，标记为0的为可以通行的地方。010000000100001001110000迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这个它的上、下、左、右四个方向之一。对于上面的迷宫，从入口开始，可以按DRRURRDDDR的顺序通过迷宫，一共10步。其中D、U、L、R分别表示向下、向上、向左、向右走。对于下面这个更复杂的迷宫（30行5
  • BFS迷宫最小路径问题 colorful_stars C/C++算法c++算法leetcode数据结构
    给定一个迷宫，0表示空地可以走，1表示墙壁不能穿越；在迷宫中可以向（上下左右）四个方向行进；找到从左上角到右下角的最短路径，并计算最短路径的长度。迷宫示例如下：算法步骤：1、从起始点出发，遍历四个方向，如果某个方向可以走，则先存储起来；2、按照四个方向中可以走网格进行尝试，如果该网格的四个方向仍可以走，则存储起来。3、直至到达网格的右下角，停止搜索。从以上分析可以看出，该步骤是按照一个广度优先搜索
  • Floyd算法求最短路径 阿轩不熬夜~~ 算法学习c++数据结构
    目录一.Floyd算法介绍二.算法实现一.邻接矩阵介绍二.过程简述三.Floyd核心代码三.例题分析一.B3647【模板】Floyd.二.P2835刻录光盘四.Floyd算法的优缺点一.Floyd算法介绍Floyd算法又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与Dijkstra算法类似。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教
  • 图论中虚拟原点和反向建图两种方法—Acwing1137选择最短路线 kkj2004 算法图论
    虚拟原点和反向建图两种方法（本题中受范围限制运行速度区别不大）（附AC代码）这是蒟蒻在Acwing的第一篇题解（斗胆求赞）题目传送门现在时间是2023/1/2620:56，给大家拜个晚年看到题的第一眼就发现了这道题是一道图论中巧妙建图的模板题水题（好在范围也不大，不用加任何的优化）这道题如果一开始的思路是让某个图论算法跑W遍的话，那大概率会TLE（当然我没试），所以我们不能将这道题的时间复杂度*W
  • POJ 1062 : 昂贵的聘礼 - 最短路Dijkstra+枚举（难） bookybooky 图论最短路Dijsktrapojzoj图论
    dijkstra处理权值非负情形，最近才开始看最短路。题目大意：（中文题容易理解）大致就是说，最终要得到酋长的许诺，每件物品可能有其他物品（1件）能让此物品价格优惠，你可通过交易获得物品从而以最少金钱达到酋长许诺。交易受到“等级限制”。其中的等级限制处理需要一定的技巧，细节一定要处理好！输入：（单Case输入）第一行两个整数M，N（1>30)-1足够，邻接矩阵用int也足够，并不像DISCUSS中
  • 【代码随想录训练营第42期 Day53打卡 - 图论Part4 - 卡码网 110. 字符串接龙 105. 有向图的完全可达性 逝去的秋风 代码随想录打卡图论深度优先算法广度优先
    目录一、个人感受二、题目与题解题目一：卡码网110.字符串接龙题目链接题解：BFS+哈希题目二：卡码网105.有向图的完全可达性题目链接题解：DFS三、小结一、个人感受对于两大基本搜索：深度优先搜索DFS遍历所有路径，每条路径都是一条路走到底，用于解决需要处理所有位置的情况；广度优先搜索BFS遍历最近相邻路径（常用邻接图，邻接表实现），用于用于求得最短路径，最小次数等。今天打卡题目个人感觉挺难，事
  • 最短路算法一 halcyonfreed 算法
    2024061819:33朴素版Dijkstra47:00Heap优化版1:04:00Bellman-ford最短路算法——5种！！！考察重点：不会考算法证明，这里不讲了，重点是实现+抽象1.如何建图——如何定义点边，抽象成一个图问题Prim/i/，kruskal是最小生成树算法不是prime/ai/质数1.是么时候用？方法n图的node数m边数单源：只有一个起点，求从1个点到其他所有点/第n号点
  • 单源最短路径 洛谷【P4779】 data_structure_wr 算法
    题目描述给定一个nn个点，mm条有向边的带非负权图，请你计算从ss出发，到每个点的距离。数据保证你能从ss出发到任意点。输入格式第一行为三个正整数n,m,sn,m,s。第二行起mm行，每行三个非负整数ui,vi,wiui,vi,wi，表示从uiui到vivi有一条权值为wiwi的有向边。输出格式输出一行nn个空格分隔的非负整数，表示ss到每个点的距离。输入输出样例输入#14611222322411
  • OSPF动态路由协议 抽象文学带师 网络oracletcp/ip
    OSPF动态路由协议一．OSPF：开放式最短路径优先协议无类别链路状态型IGP协议组播更新：224.0.0.5/6支持等开销负载均衡生成的路由条目优先级10，使用cost值作为度量；链路状态型协议最大的问题，在于邻居间传递拓扑信息，更新量巨大，故非常消耗设备的带宽和计算资源，不能在中大型网络生存；因此OSPF协议需要结构化的部署--区域划分、合理ip地址规划支持触发更新；每30min进行一次周期更
  • 最短路径算法——A*算法 有一点点想CoCo你 算法
    A*算法是静态路网中求解最短路径最有效的直接搜索算法，也是解决许多搜索问题的有效算法，广泛应用于机器人路径搜索、游戏动画路径搜索等。它是图搜索算法的一种。A*算法是一种启发式的搜索算法，它是基于深度优先算法(DepthFirstSearch,DFS)和广度优先算法(BreadthFirstSearch,BFS)的一种融合算法，按照一定原则确定如何选取下一个结点。参考：A*寻路算法详解#A星#启发式
  • 数据结构——最短路径问题 胡牧之. 学习笔记数据结构数据结构
    文章目录前言一、问题分类二、单源最短路径1.无权图（BFS）（1）问题分析（2）路径记录2.有权图（朴素DiskStra算法）（1）问题分析（2）算法介绍（3）代码实现（4）思考三、多源最短路径1.问题分析2.枚举（1）思路3.Floyd算法（1）思路分析（2）代码实现前言两个顶点之间的最短路径问题就是求一条路径可以令两顶点沿途各边权值之和最小。一、问题分类对于这个问题，可以分为两种情况：1.单源
  • 数据结构总结之最短路径 @阿奇@ 最短路径图论
    1.弗洛伊德算法模板题：uva10000#include#includeusingnamespacestd;intdis[105][105];intmain(){intn;intt=0;while(cin>>n,n){inta,b,s;memset(dis,-1,sizeof(dis));cin>>s;while(cin>>a>>b,a)dis[a][b]=1;inti,j;for(intk=1;
  • 数据结构之最短路径Dijkdtra算法 HPU_FRDHR 数据结构篇最短路径Dijkdtra算法
    题意：两个整数：T和N.接下来T行，每行描述以三个以空格分隔的整数的轨迹。前两个分别代表两个点，第三个为两点间的距离输出：从N到1必须经过的最小距离优先队列优化的djk求单源最短路,链式前向星存图时间复杂度o(E*log(V))#include#include#includeusingnamespacestd; typedefpairpii; //first存储权值，second存储终点 cons
  • FFmpeg 7.0 版本 “Dijkstra”的特点概述 Codec Conductor FFmpegffmpegFFmpeg音视频
    FFmpeg7.0FFmpeg官网：https://ffmpeg.org/FFmpeg官网更新日志，2024.4.5号发布代号"Dijkstra"的7.0版本的FFmpeg，如下截图：为什么叫Dijkstra“Dijkstra”指的是艾兹格·戴克斯特拉（EdsgerWybeDijkstra），他是一位荷兰计算机科学家，对计算机科学领域做出了巨大贡献。戴克斯特拉最著名的成就之一是发明了最短路径算法，
  • 动态规划算法： 我不会JAVA！ 算法动态规划
    动态规划算法简介动态规划（DynamicProgramming,DP）是一种将复杂问题分解为更简单的子问题来求解的算法思想。它通过保存中间子问题的解，避免了重复计算，从而大大提高了解决问题的效率。动态规划通常用于求解最优化问题，比如最短路径、最大收益等。动态规划解题步骤确定状态：明确在问题的某一步中，需要存储什么信息来描述子问题的解。状态转移方程：找出如何通过前一步的状态来得到当前状态，即如何递推
  • Python高效实现Dijkstra算法求解单源最短路径问题 清水白石008 pythonPython题库python算法网络
    Python高效实现Dijkstra算法求解单源最短路径问题在Python面试中，考官通常会关注候选人的编程能力、问题解决能力以及对Python语言特性的理解。Dijkstra算法是一种经典的图算法，用于求解单源最短路径问题。本文将详细介绍如何实现Dijkstra算法，确保代码实用性强，条理清晰，操作性强。1.引言Dijkstra算法由荷兰计算机科学家EdsgerDijkstra于1956年提出，
  • 如何选择最佳路线？ 周山至水数翠峰 算法数据结构贪心算法
    交通线路的选择日常交通线路的选择，并不是按最短路径选择的。还要参考道路的等级，道路是否拥堵，道路通行速度等多种情形。本程序列举出所有能通行的线路，并计算出行驶距离，来供用户选择。当然，也可以加入道路实时通行情况，收费情况，并依据用户的偏好，计算出最佳线路。线路如何描述？·交通线路纷繁复杂，是一种无序的网状结构。对于线路的描述，本人认为所有的交通图，都是由点互相连通组成的。每个点，如果相连的点为一个
  • 2022-01-14每日刷题打卡 你好_Ä 图论算法
    2022-01-14每日刷题打卡AcWing——y总算法课851.spfa求最短路-AcWing题库给定一个n个点m条边的有向图，图中可能存在重边和自环，边权可能为负数。请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出impossible。数据保证不存在负权回路。输入格式第一行包含整数n和m。接下来m行每行包含三个整数x,y,z，表示存在一条从点x到点y的有向边，边长为z。输出
  • 代码随想录算法训练营day76 | Floyd 算法精讲、A * 算法精讲 sunflowers11 代码随想录二刷算法数据结构
    本次题目来自于卡码网97.小明逛公园（Floyd算法精讲）1、确定dp数组以及下标的含义grid[i][j][k]=m，表示节点i到节点j以[1...k]集合为中间节点的最短距离为m2、确定递推公式分两种情况：节点i到节点j的最短路径经过节点k节点i到节点j的最短路径不经过节点k对于第一种情况，grid[i][j][k]=grid[i][k][k-1]+grid[k][j][k-1]第二种情况，g
  • 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其他