关于几个的区别和联系：http://www.cnblogs.com/zswbky/p/5432353.html

d.每组的第一行是三个整数T，S和D，表示有T条路，和草儿家相邻的城市的有S个（草儿家到这个城市的距离设为0），草儿想去的地方有D个；

求D个城市中距离草儿家最近的距离。

s.进行1次单源最短路，找出距离最小的即可。

c.Dijkstra单源最短路

  1. /*
  2. Dijkstra单源最短路
  3. 权值必须是非负
  4. 单源最短路径，Dijkstra算法，邻接矩阵形式，复杂度为O(n^2)
  5. 求出源beg到所有点的最短路径，传入图的顶点数，和邻接矩阵cost[][]
  6. 返回各点的最短路径lowcost[]，路径pre[].pre[i]记录beg到i路径上的父结点，pre[beg]=-1
  7. 可更改路径权类型，但是权值必须为非负
  8. */
  9. #include<iostream>
  10. #include<stdio.h>
  11. #include<string.h>
  12. using namespace std;
  13.  
  14. const int MAXN=;
  15. #define typec int
  16. const typec INF=0x3f3f3f3f;//防止后面溢出，这个不能太大
  17. bool vis[MAXN];
  18. int pre[MAXN];
  19. void Dijkstra(typec cost[][MAXN],typec lowcost[],int n,int beg){
  20.     for(int i=;i<n;i++){
  21.         lowcost[i]=INF;vis[i]=false;pre[i]=-;
  22.     }
  23.     lowcost[beg]=;
  24.     for(int j=;j<n;j++){
  25.         int k=-;
  26.         int Min=INF;
  27.         for(int i=;i<n;i++)
  28.             if(!vis[i]&&lowcost[i]<Min){
  29.                 Min=lowcost[i];
  30.                 k=i;
  31.             }
  32.         if(k==-)break;
  33.         vis[k]=true;
  34.         for(int i=;i<n;i++)
  35.             if(!vis[i]&&lowcost[k]+cost[k][i]<lowcost[i]){
  36.                 lowcost[i]=lowcost[k]+cost[k][i];
  37.                 pre[i]=k;
  38.             }
  39.     }
  40. }
  41.  
  42. int cost[MAXN][MAXN];
  43. int lowcost[MAXN];
  44.  
  45. int main(){
  46.  
  47.     int T,S,D;
  48.     int a,b,time;
  49.     int city1[MAXN];
  50.     int city2[MAXN];
  51.  
  52.     while(~scanf("%d%d%d",&T,&S,&D)){
  53.         for(int i=;i<MAXN;++i){
  54.             for(int j=;j<MAXN;++j){
  55.                 cost[i][j]=INF;
  56.             }
  57.         }
  58.         memset(vis,false,sizeof(vis));
  59.  
  60.         for(int i=;i<T;++i){
  61.             scanf("%d%d%d",&a,&b,&time);
  62.             if(time<cost[a][b]){
  63.                 cost[a][b]=time;
  64.                 cost[b][a]=time;
  65.             }
  66.         }
  67.         //0作为草儿家
  68.         for(int i=;i<S;++i){
  69.             scanf("%d",&city1[i]);
  70.             cost[][city1[i]]=;
  71.             cost[city1[i]][]=;
  72.         }
  73.         for(int i=;i<D;++i){
  74.             scanf("%d",&city2[i]);
  75.         }
  76.  
  77.         Dijkstra(cost,lowcost,MAXN,);
  78.         int minTime=lowcost[city2[]];
  79.         for(int i=;i<D;++i){
  80.             if(lowcost[city2[i]]<minTime)
  81.                 minTime=lowcost[city2[i]];
  82.         }
  83.  
  84.         printf("%d\n",minTime);
  85.     }
  86.     return ;
  87. }

c2.Dijkstra算法+堆优化

  1. /*
  2. Dijkstra算法+堆优化
  3. 使用优先队列优化，复杂度O(E log E)
  4. 使用优先队列优化Dijkstra算法
  5. 复杂度O(E log E)
  6. 注意对vector<Edge>E[MAXN]进行初始化后加边
  7. */
  8. #include<iostream>
  9. #include<stdio.h>
  10. #include<vector>
  11. #include<string.h>
  12. #include<queue>
  13. using namespace std;
  14.  
  15. const int INF=0x3f3f3f3f;
  16. const int MAXN=;
  17. struct qnode{
  18.     int v;
  19.     int c;
  20.     qnode(int _v=,int _c=):v(_v),c(_c){}
  21.     bool operator <(const qnode &r)const{
  22.         return c>r.c;
  23.     }
  24. };
  25. struct Edge{
  26.     int v,cost;
  27.     Edge(int _v=,int _cost=):v(_v),cost(_cost){}
  28. };
  29. vector<Edge>E[MAXN];
  30. bool vis[MAXN];
  31. int dist[MAXN];
  32. //点的编号从1开始
  33. void Dijkstra(int n,int start){
  34.     memset(vis,false,sizeof(vis));
  35.     for(int i=;i<=n;i++)dist[i]=INF;
  36.     priority_queue<qnode>que;
  37.     while(!que.empty())que.pop();
  38.     dist[start]=;
  39.     que.push(qnode(start,));
  40.     qnode tmp;
  41.     while(!que.empty()){
  42.         tmp=que.top();
  43.         que.pop();
  44.         int u=tmp.v;
  45.         if(vis[u])continue;
  46.         vis[u]=true;
  47.         for(int i=;i<E[u].size();i++){
  48.             int v=E[tmp.v][i].v;
  49.             int cost=E[u][i].cost;
  50.             if(!vis[v]&&dist[v]>dist[u]+cost){
  51.                 dist[v]=dist[u]+cost;
  52.                 que.push(qnode(v,dist[v]));
  53.             }
  54.         }
  55.     }
  56. }
  57. void addedge(int u,int v,int w){
  58.     E[u].push_back(Edge(v,w));
  59. }
  60.  
  61. int main(){
  62.     int T,S,D;
  63.     int a,b,time;
  64.     int city1[MAXN];
  65.     int city2[MAXN];
  66.  
  67.     while(~scanf("%d%d%d",&T,&S,&D)){
  68.         for(int i=;i<MAXN;++i){
  69.             E[i].clear();
  70.         }
  71.  
  72.         for(int i=;i<T;++i){
  73.             scanf("%d%d%d",&a,&b,&time);
  74.             addedge(a,b,time);//这里有重边了。。没办法，
  75.             addedge(b,a,time);
  76.         }
  77.         //0作为草儿家
  78.         for(int i=;i<S;++i){
  79.             scanf("%d",&city1[i]);
  80.             addedge(,city1[i],);
  81.             addedge(city1[i],,);
  82.         }
  83.         for(int i=;i<D;++i){
  84.             scanf("%d",&city2[i]);
  85.         }
  86.  
  87.         Dijkstra(MAXN-,);
  88.         int minTime=dist[city2[]];
  89.         for(int i=;i<D;++i){
  90.             if(dist[city2[i]]<minTime)
  91.                 minTime=dist[city2[i]];
  92.         }
  93.  
  94.         printf("%d\n",minTime);
  95.     }
  96.     return ;
  97. }

c3.单源最短路bellman_ford算法

  1. /*
  2. 单源最短路bellman_ford算法
  3. 单源最短khtkbellman_ford算法，复杂度O(VE)
  4. 可以处理负边权图。
  5. 可以判断是否存在负环回路。返回true，当且仅当图中不包含从源点可达的负权回路
  6. vector<Edge>E;先E.clear()初始化，然后加入所有边
  7. 点的编号从1开始（从0开始简单修改就可以了）
  8. */
  9. #include<iostream>
  10. #include<stdio.h>
  11. #include<vector>
  12. using namespace std;
  13.  
  14. const int INF=0x3f3f3f3f;
  15. const int MAXN=;
  16. int dist[MAXN];
  17. struct Edge{
  18.     int u,v;
  19.     int cost;
  20.     Edge(int _u=,int _v=,int _cost=):u(_u),v(_v),cost(_cost){}
  21. };
  22. vector<Edge>E;
  23. //点的编号从1开始
  24. bool bellman_ford(int start,int n){
  25.     for(int i=;i<=n;i++)dist[i]=INF;
  26.     dist[start]=;
  27.     //最多做n-1次
  28.     for(int i=;i<n;i++){
  29.         bool flag=false;
  30.         for(int j=;j<E.size();j++){
  31.             int u=E[j].u;
  32.             int v=E[j].v;
  33.             int cost=E[j].cost;
  34.             if(dist[v]>dist[u]+cost){
  35.                 dist[v]=dist[u]+cost;
  36.                 flag=true;
  37.             }
  38.         }
  39.         if(!flag)return true;//没有负环回路
  40.     }
  41.     for(int j=;j<E.size();j++)
  42.         if(dist[E[j].v]>dist[E[j].u]+E[j].cost)
  43.             return false;//有负环回路
  44.     return true;//没有负环回路
  45. }
  46. void addedge(int u,int v,int cost){
  47.     E.push_back(Edge(u,v,cost));
  48. }
  49.  
  50. int main(){
  51.     int T,S,D;
  52.     int a,b,time;
  53.     int city1[MAXN];
  54.     int city2[MAXN];
  55.  
  56.     while(~scanf("%d%d%d",&T,&S,&D)){
  57.         E.clear();
  58.  
  59.         for(int i=;i<T;++i){
  60.             scanf("%d%d%d",&a,&b,&time);
  61.             addedge(a,b,time);//有重边了。
  62.             addedge(b,a,time);
  63.         }
  64.         //0作为草儿家
  65.         for(int i=;i<S;++i){
  66.             scanf("%d",&city1[i]);
  67.             addedge(,city1[i],);
  68.             addedge(city1[i],,);
  69.         }
  70.         for(int i=;i<D;++i){
  71.             scanf("%d",&city2[i]);
  72.         }
  73.  
  74.         bellman_ford(,MAXN-);//MAXN-1
  75.         int minTime=dist[city2[]];
  76.         for(int i=;i<D;++i){
  77.             if(dist[city2[i]]<minTime)
  78.                 minTime=dist[city2[i]];
  79.         }
  80.  
  81.         printf("%d\n",minTime);
  82.     }
  83.     return ;
  84. }

c4.单源最短路SPFA

  1. /*
  2. 单源最短路SPFA
  3. 时间复杂度O(kE)
  4. 这个是队列实现，有时候改成栈实现会更加快，很容易修改
  5. 这个复杂度是不定的
  6. */
  7. #include<iostream>
  8. #include<stdio.h>
  9. #include<vector>
  10. #include<string.h>
  11. #include<queue>
  12. using namespace std;
  13.  
  14. const int MAXN=;
  15. const int INF=0x3f3f3f3f;
  16. struct Edge{
  17.     int v;
  18.     int cost;
  19.     Edge(int _v=,int _cost=):v(_v),cost(_cost){}
  20. };
  21. vector<Edge>E[MAXN];
  22. void addedge(int u,int v,int w){
  23.     E[u].push_back(Edge(v,w));
  24. }
  25. bool vis[MAXN];//在队列标志
  26. int cnt[MAXN];//每个点的入队列次数
  27. int dist[MAXN];
  28. bool SPFA(int start,int n){
  29.     memset(vis,false,sizeof(vis));
  30.     for(int i=;i<=n;i++)dist[i]=INF;
  31.     vis[start]=true;
  32.     dist[start]=;
  33.     queue<int>que;
  34.     while(!que.empty())que.pop();
  35.     que.push(start);
  36.     memset(cnt,,sizeof(cnt));
  37.     cnt[start]=;
  38.     while(!que.empty()){
  39.         int u=que.front();
  40.         que.pop();
  41.         vis[u]=false;
  42.         for(int i=;i<E[u].size();i++){
  43.             int v=E[u][i].v;
  44.             if(dist[v]>dist[u]+E[u][i].cost){
  45.                 dist[v]=dist[u]+E[u][i].cost;
  46.                 if(!vis[v]){
  47.                     vis[v]=true;
  48.                     que.push(v);
  49.                     if(++cnt[v]>n)return false;
  50.                     //cnt[i] 为入队列次数，用来判定是否存在负环回路
  51.                 }
  52.             }
  53.         }
  54.     }
  55.     return true;
  56. }
  57.  
  58. int main(){
  59.     int T,S,D;
  60.     int a,b,time;
  61.     int city1[MAXN];
  62.     int city2[MAXN];
  63.  
  64.     while(~scanf("%d%d%d",&T,&S,&D)){
  65.         for(int i=;i<MAXN;++i){
  66.             E[i].clear();
  67.         }
  68.  
  69.         for(int i=;i<T;++i){
  70.             scanf("%d%d%d",&a,&b,&time);
  71.             addedge(a,b,time);//有重边了。
  72.             addedge(b,a,time);
  73.         }
  74.         //0作为草儿家
  75.         for(int i=;i<S;++i){
  76.             scanf("%d",&city1[i]);
  77.             addedge(,city1[i],);
  78.             addedge(city1[i],,);
  79.         }
  80.         for(int i=;i<D;++i){
  81.             scanf("%d",&city2[i]);
  82.         }
  83.  
  84.         SPFA(,MAXN-);//MAXN-1
  85.         int minTime=dist[city2[]];
  86.         for(int i=;i<D;++i){
  87.             if(dist[city2[i]]<minTime)
  88.                 minTime=dist[city2[i]];
  89.         }
  90.  
  91.         printf("%d\n",minTime);
  92.     }
  93.     return ;
  94. }

增加一个Floyd的邻接表（这个题不错，有时间看看）

http://blog.163.com/zjut_nizhenyang/blog/static/169570029201111841938607/

Floyd

http://www.cnblogs.com/zswbky/p/5432387.html

最短路模板（Dijkstra & Dijkstra算法+堆优化 & bellman_ford & 单源最短路SPFA）的更多相关文章

  1. 【算法】单源最短路——Dijkstra

    对于固定起点的最短路算法,我们称之为单源最短路算法.单源最短路算法很多,最常见的就是dijkstra算法. dijkstra主要用的是一种贪心的思想,就是说如果i...s...t...j是最短路,那么 ...

  2. [ACM_图论] Domino Effect (POJ1135 Dijkstra算法 SSSP 单源最短路算法 中等 模板)

    Description Did you know that you can use domino bones for other things besides playing Dominoes? Ta ...

  3. 单源最短路模板（dijkstra）

    单源最短路(dijkstra算法及堆优化) 弱化版题目链接 n^2 dijkstra模板 #include<iostream> #include<cstdio> #includ ...

  4. 单源最短路——dijkstra算法

    Dijkstra算法 1.定义概览 Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法,用于计算一个节点到其他所有节点的最短路径.主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止. 问 ...

  5. 【算法系列学习】Dijkstra单源最短路 [kuangbin带你飞]专题四 最短路练习 A - Til the Cows Come Home

    https://vjudge.net/contest/66569#problem/A http://blog.csdn.net/wangjian8006/article/details/7871889 ...

  6. 利用分支限界法求解单源最短路(Dijkstra)问题

    分支限界法定义:采用Best fist search算法,并使用剪枝函数的算法称为分支界限法. 分支限界法解释:按Best first的原则,有选择的在其child中进行扩展,从而舍弃不含有最优解的分 ...

  7. 牛客编程巅峰赛S1第6场 - 黄金&钻石&王者 C.星球游戏 (单源最短路,Dijkstra)

    题意:有\(n\)个点,\(m\)条双向边,两个方向的权值都是相等的,可以从\(A\)中的某个点出发走到\(B\)中的某个点,求所有路径中的最短距离,如果A和B中没有点联通,则输出\(-1\). 题解 ...

  8. 洛谷 P5837 [USACO19DEC]Milk Pumping G (单源最短路,dijkstra)

    题意:有一\(n\)个点,\(m\)条边的双向图,每条边都有花费和流量,求从\(1\)~\(n\)的路径中,求\(max\frac{min(f)}{\sum c}\). 题解:对于c,一定是单源最短路 ...

  9. 模板C++ 03图论算法 1最短路之单源最短路（SPFA）

    3.1最短路之单源最短路(SPFA) 松弛:常听人说松弛,一直不懂,后来明白其实就是更新某点到源点最短距离. 邻接表:表示与一个点联通的所有路. 如果从一个点沿着某条路径出发,又回到了自己,而且所经过 ...

随机推荐

  1. RBM阅读笔记

    RBM包含两个层,可见层(visble layer)和隐藏层(hidden layer).神经元之间的连接具有以下特点:层内无连接,层间全连接.RBM可以看做是一个二分图(神经元当做顶点,神经元之间的 ...

  2. 移动端的拖拽这个demo实现的功能

    SQL数据库适合那些需求确定和对数据完整性要去严格的项目.NoSQL数据库适用于那些对速度和可扩展性比较看重的那些不相关的,不确定和不断发展的需求. 总所周知,网页的加载速度跟图片是有很大的关系的,因 ...

  3. SQL EXEC 命令用法

    EXEC命令有两个用法: 1.执行一个存储过程,或者执行一个动态批次. 2.批次是一个内容为SQL语句的字符串. 举列子: 1.exec name_proc :没有参数 exec name_proc ...

  4. opendir函数

    #include<sys/types.h> #include<dirent.h> DIR *dirptr = NULL; struct dirent *entry; dirpt ...

  5. 【python】PIL 批量绘制图片矩形框工具

    工具采用PIL:Python Imaging Library,图像处理标准库.PIL功能非常强大,但API却非常简单易用. 安装PIL 在Debian/Ubuntu Linux下直接通过apt安装 $ ...

  6. MySql分组函数-Group by与having理解

    注意:select 后的字段,必须要么包含在group by中,要么包含在having 后的聚合函数里. 1. GROUP BY 是分组查询, 一般 GROUP BY 是和聚合函数配合使用 group ...

  7. POI2012

    现在才开始写 POI 是不是太弱了? -Rendezvous 怎么说呢,我发现我的代码好长啊-长啊-长啊-长长长长长长长长长长长长长长长长长长长长长长啊- 大概就是在一个内向树上搞一个类似 lca 的 ...

  8. [转]使用Maven添加依赖项时（Add Dependency）时，没有提示项目可用，并且在Console中，输出： Unable to update index for central|http://repo1.maven.org/maven2 。

    使用Maven添加依赖项时(Add Dependency)时,没有提示项目可用,并且在Console中,输出: Unable to update index for central|http://re ...

  9. [原创]cocos2d-x研习录-第三阶 特性之调度器

    在游戏中,经常会周期执行一些检测.操作或更新一些数据等,我们称之为调度.Cocos2D-x中将调度封装为类CCScheduler,方便在游戏开发中使用.我们一起来学习一下,CCScheduler具有哪 ...

  10. logrotate机制与原理[转载]

    http://blog.lightxue.com/how-logrotate-works/ 日志实在是太有用了,它记录了程序运行时各种信息.通过日志可以分析用户行为,记录运行轨迹,查找程序问题.可惜磁 ...