Floyd

Floyd 本质上类似一种动态规划,dp [ i ] [ j ] = dp [ i ] [ k ] + dp[ k ] [ j ]。

 /**
  *  Night gathers, and now my watch begins.
  *  It shall not end until my death.
  *  I shall take no wife, hold no lands, father no children.
  *  I shall wear no crowns and win no glory.
  *  I shall live and die at my post.
  *  I am the sword in the darkness.
  *  I am the watcher on the walls.
  *  I am the fire that burns against the cold,
  *  the light that wakes the sleepers,
  *  the shield that guards the realms of men.
  *  I pledge my life and honor to the Night's Watch,
  *  for this night,
  *  and all the nights to come.
  */

 #include<bits/stdc++.h>
 #define lson i<<2
 #define rson i<<2|1
 #define LS l,mid,lson
 #define RS mid+1,r,rson
 #define mem(a,x) memset(a,x,sizeof(a))
 #define gcd(a,b) __gcd(a,b)
 #define ll long long
 #define ull unsigned long long
 #define lowbit(x) (x&-x)
 #define enld endl
 #define mian main
 #define itn int
 #define prinft printf

 const double PI = acos (-1.0);
 const int INF = 0x3f3f3f3f;
 ;
 ;
 ;
 ;

 using namespace std;

 int Map[MAXN][MAXN];
 int n, m, q;
 int a, b, c;

 void Floyd () {
     ; k < n; k++)
         ; i <= n; i++)
             ; j <= n; j++)
                 Map[i][j] = min (Map[i][j], Map[i][k] + Map[k][j]);
 }

 int main() {
     while (cin >> n >> m >> q) {
         ; i <= n; i++)
             ; j <= n; j++)
                 Map[i][j] = INF;

         ; i <= m; i++) {
             cin >> a >> b >> c;
             Map[a][b] = Map[b][a] = min (Map[a][b], c);
         }
         Floyd();
         ; i <= q; i++) {
             cin >> a >> b;
             cout << Map[a][b] << endl;
         }
     }
     ;
 }

Floyd

 /**
  *  Night gathers, and now my watch begins.
  *  It shall not end until my death.
  *  I shall take no wife, hold no lands, father no children.
  *  I shall wear no crowns and win no glory.
  *  I shall live and die at my post.
  *  I am the sword in the darkness.
  *  I am the watcher on the walls.
  *  I am the fire that burns against the cold,
  *  the light that wakes the sleepers,
  *  the shield that guards the realms of men.
  *  I pledge my life and honor to the Night's Watch,
  *  for this night,
  *  and all the nights to come.
  */

 #include<bits/stdc++.h>
 #define lson i<<2
 #define rson i<<2|1
 #define LS l,mid,lson
 #define RS mid+1,r,rson
 #define mem(a,x) memset(a,x,sizeof(a))
 #define gcd(a,b) __gcd(a,b)
 #define ll long long
 #define ull unsigned long long
 #define lowbit(x) (x&-x)
 #define enld endl
 #define mian main
 #define itn int
 #define prinft printf

 const double PI = acos (-1.0);
 const int INF = 0x3f3f3f3f;
 ;
 ;
 ;
 ;

 using namespace std;

 int Map[MAXN][MAXN];
 int n, m, q;
 int a, b, c;

 void Floyd () {
     ; k <= n; k++)
         ; i <= n; i++)
             ; j <= n; j++)
                 Map[i][j] = min (Map[i][j], Map[i][k] + Map[k][j]);
 }

 int main() {
     while (~scanf ("%d%d", &n, &m) && n || m) {
         ; i <= n; i++)
             ; j <= n; j++)
                 Map[i][j] = INF;

         ; i <= m; i++) {
             scanf ("%d%d%d", &a, &b, &c);
             Map[a][b] = Map[b][a] = min (Map[a][b], c);
         }
         Floyd();
         cout << Map[][n] << endl;

     }
     ;
 }

Dijkstra

从源点出发,首先寻找离源点最近的几个节点,now 储存现在离源点最近的节点的序号。

 /**
  *  Night gathers, and now my watch begins.
  *  It shall not end until my death.
  *  I shall take no wife, hold no lands, father no children.
  *  I shall wear no crowns and win no glory.
  *  I shall live and die at my post.
  *  I am the sword in the darkness.
  *  I am the watcher on the walls.
  *  I am the fire that burns against the cold,
  *  the light that wakes the sleepers,
  *  the shield that guards the realms of men.
  *  I pledge my life and honor to the Night's Watch,
  *  for this night,
  *  and all the nights to come.
  */

 #include<bits/stdc++.h>
 #define lson i<<2
 #define rson i<<2|1
 #define LS l,mid,lson
 #define RS mid+1,r,rson
 #define mem(a,x) memset(a,x,sizeof(a))
 #define gcd(a,b) __gcd(a,b)
 #define ll long long
 #define ull unsigned long long
 #define lowbit(x) (x&-x)
 #define enld endl
 #define mian main
 #define itn int
 #define prinft printf

 const double PI = acos (-1.0);
 const int INF = 0x3f3f3f3f;
 ;
 ;
 ;
 ;

 using namespace std;

 int Map[MAXN][MAXN];
 int dis[MAXN];
 int vis[MAXN];
 int n, m, q;
 int a, b, c;

 void Dijkstra (int src) {
     mem (vis, );
     ; i <= n; i++)
         dis[i] = INF;
     dis[src] = ;
     ) {
         ;
         ; i <= n; i++)
              || dis[i] < dis[now]))
                 now = i;
         )
             break;
         vis[now] = ;
         ; i <= n; i++)
             dis[i] = min (dis[i], dis[now] + Map[now][i]);
         cout<<now<<endl;
         ; i <= n; i++)
             cout << dis[i] << ' ';
         cout << endl;
     }
 }

 int main() {
     while (cin >> n >> m >> q) {
         ; i <= n; i++)
             ; j <= n; j++)
                 Map[i][j] = INF;

         ; i <= m; i++) {
             cin >> a >> b >> c;
             Map[a][b] = Map[b][a] = min (Map[a][b], c);
         }
         Dijkstra ();
         ; i <= q; i++) {
             cin >> a >> b;
             cout << dis[i] << endl;
         }

     }
     ;
 }

Dijkstra

 /**
  *  Night gathers, and now my watch begins.
  *  It shall not end until my death.
  *  I shall take no wife, hold no lands, father no children.
  *  I shall wear no crowns and win no glory.
  *  I shall live and die at my post.
  *  I am the sword in the darkness.
  *  I am the watcher on the walls.
  *  I am the fire that burns against the cold,
  *  the light that wakes the sleepers,
  *  the shield that guards the realms of men.
  *  I pledge my life and honor to the Night's Watch,
  *  for this night,
  *  and all the nights to come.
  */

 #include<bits/stdc++.h>
 #define lson i<<2
 #define rson i<<2|1
 #define LS l,mid,lson
 #define RS mid+1,r,rson
 #define mem(a,x) memset(a,x,sizeof(a))
 #define gcd(a,b) __gcd(a,b)
 #define ll long long
 #define ull unsigned long long
 #define lowbit(x) (x&-x)
 #define enld endl
 #define mian main
 #define itn int
 #define prinft printf

 const double PI = acos (-1.0);
 const int INF = 0x3f3f3f3f;
 ;
 ;
 ;
 ;

 using namespace std;

 int Map[MAXN][MAXN];
 int dis[MAXN];
 int vis[MAXN];
 int n, m, q;
 int a, b, c;

 void Dijkstra (int src) {
     mem (vis, );
     ; i <= n; i++)
         dis[i] = INF;
     dis[src] = ;
     ) {
         ;
         ; i <= n; i++)
              || dis[i] < dis[now]))
                 now = i;
         )
             break;
         vis[now] = ;
         ; i <= n; i++)
             dis[i] = min (dis[i], dis[now] + Map[now][i]);
         cout<<now<<endl;
         ; i <= n; i++)
             cout << dis[i] << ' ';
         cout << endl;
     }
 }

 int main() {
     while (cin >> n >> m >> q) {
         ; i <= n; i++)
             ; j <= n; j++)
                 Map[i][j] = INF;

         ; i <= m; i++) {
             cin >> a >> b >> c;
             Map[a][b] = Map[b][a] = min (Map[a][b], c);
         }
         Dijkstra ();
         ; i <= q; i++) {
             cin >> a >> b;
             cout << dis[i] << endl;
         }

     }
     ;
 }

SPFA

将每次被松弛了的节点入队,直到队列为空,得到的就是源点到各节点的最短路。

 /**
  *  Night gathers, and now my watch begins.
  *  It shall not end until my death.
  *  I shall take no wife, hold no lands, father no children.
  *  I shall wear no crowns and win no glory.
  *  I shall live and die at my post.
  *  I am the sword in the darkness.
  *  I am the watcher on the walls.
  *  I am the fire that burns against the cold,
  *  the light that wakes the sleepers,
  *  the shield that guards the realms of men.
  *  I pledge my life and honor to the Night's Watch,
  *  for this night,
  *  and all the nights to come.
  */

 #include<bits/stdc++.h>
 #define lson i<<2
 #define rson i<<2|1
 #define LS l,mid,lson
 #define RS mid+1,r,rson
 #define mem(a,x) memset(a,x,sizeof(a))
 #define gcd(a,b) __gcd(a,b)
 #define ll long long
 #define ull unsigned long long
 #define lowbit(x) (x&-x)
 #define enld endl
 #define mian main
 #define itn int
 #define prinft printf

 const double PI = acos (-1.0);
 const int INF = 0x3f3f3f3f;
 ;
 ;
 ;
 ;

 using namespace std;

 //邻接表实现
 struct node {
     int to, cost;
     node (int a, int b) {
         to = a, cost = b;
     }
 };
 vector<node> edge[MAXN];

 int vis[MAXN];      //可以用map
 int dis[MAXN];
 int n, m;
 int a, b, c;
 queue<int> q;

 void spfa (int src) {
     mem (vis, );
     vis[src] = ;
     dis[src] = ;
     q.push (src);
     while (!q.empty()) {
         int now = q.front();
         q.pop();
         vis[now] = ;
         ; i < edge[now].size(); ++i) {
             if (dis[now] + edge[now][i].cost > dis[edge[now][i].to])
                 continue;
             dis[edge[now][i].to] = dis[now] + edge[now][i].cost;        //更新
             if (!vis[edge[now][i].to]) {                                //入队
                 q.push (edge[now][i].to);
                 vis[edge[now][i].to] = ;
             }
         }
     }
 }

 int main() {
     while (cin >> n >> m && (n || m)) {
         while (!q.empty())
             q.pop();
         ; i <= n; i++)
             dis[i] = INF;
         ; i <= n; i++)
             edge[i].clear();

         ; i <= m; i++) {
             cin >> a >> b >> c;
             edge[a].push_back (node (b, c)), edge[b].push_back (node (a, c));
         }
         spfa ();
         cout << dis[n] << endl;
     }
     ;
 }

hdu 2544 SPFA

单源最短路模板 + hdu - 2544的更多相关文章

  1. 单源最短路模板(dijkstra)

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

  2. 单源最短路模板_SPFA_Dijkstra(堆优化)_C++

    随手一打就是标准的SPFA,默认1号节点为出发点,当然不用 f 判断是否在队里也可以,只是这样更优化一点 void spfa() { int i,x,k; ;i<=n;i++) { d[i]=o ...

  3. 【单源最短路模板】 poj 2387

    #include <cstdio> #include <iostream> #include <stdlib.h> #include <memory.h> ...

  4. 最短路模板(Dijkstra & Dijkstra算法+堆优化 & bellman_ford & 单源最短路SPFA)

    关于几个的区别和联系:http://www.cnblogs.com/zswbky/p/5432353.html d.每组的第一行是三个整数T,S和D,表示有T条路,和草儿家相邻的城市的有S个(草儿家到 ...

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

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

  6. 模板C++ 03图论算法 1最短路之单源最短路(SPFA)

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

  7. 单源最短路_SPFA_C++

    当我们需要求一个点到其它所有点的最短路时,我们可以采用SPFA算法 代码特别好写,而且可以有环,但是不能有负权环,时间复杂度是O(α(n)n),n为边数,α(n)为n的反阿克曼函数,一般小于等于4 模 ...

  8. 2018/1/28 每日一学 单源最短路的SPFA算法以及其他三大最短路算法比较总结

    刚刚AC的pj普及组第四题就是一种单源最短路. 我们知道当一个图存在负权边时像Dijkstra等算法便无法实现: 而Bellman-Ford算法的复杂度又过高O(V*E),SPFA算法便派上用场了. ...

  9. 用scheme语言实现SPFA算法(单源最短路)

    最近自己陷入了很长时间的学习和思考之中,突然发现好久没有更新博文了,于是便想更新一篇. 这篇文章是我之前程序设计语言课作业中一段代码,用scheme语言实现单源最段路算法.当时的我,花了一整天时间,学 ...

随机推荐

  1. html5 canvas旋转

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...

  2. Javascript Jquery 中的数组定义与操作

    1.认识数组 数组就是某类数据的集合,数据类型可以是整型.字符串.甚至是对象Javascript不支持多维数组,但是因为数组里面可以包含对象(数组也是一个对象),所以数组可以通过相互嵌套实现类似多维数 ...

  3. iOS 判断相册相机是否允许

    1 判断是否允许使用相机: NSString *mediaType = AVMediaTypeVideo; AVAuthorizationStatus authStatus = [AVCaptureD ...

  4. 第6月第4天 AVMutableComposition AVMutableVideoComposition

    1. AVMutableComposition is a mutable subclass of AVComposition you use when you want to create a new ...

  5. lucene修改索引——(六)

    原理: 修改的原理是先删除,后增加一个,这也是常用的一种修改的方式. 删除的文档的id不会被新增加的文档占用,类似于mysql的自增,当删除一个id=2时,以后id=2就是空着的,不会上来一个把2给占 ...

  6. Shiro:ajax的session超时处理

    本问题解决方案参照网站多篇文章融合解决,在此表示感谢! 环境:springboot+shiro+jquery-easyui 问题:在ajax请求时,如果此时session已经失效,系统没有自动跳转到登 ...

  7. dede列表页调用

    {dede:list pagesize ='16'} <li class="item pull-left"> <a class="item-wrap&q ...

  8. tensorflow-训练(train)/测试(test)

    一个TFRecords 文件为一个字符串序列.这种格式并非随机获取,它比较适合大规模的数据流,而不太适合需要快速分区或其他非序列获取方式. 操作组 操作 Training Optimizers,Gra ...

  9. SpringBoot-定制banner

    我们在启动Spring Boot项目的时候,在控制台会默认输出一个启动图案 这个图案如果你需要的话是可以自己修改的,修改方式很简单 1.在src/main/resources下新建一个banner.t ...

  10. 体会 git 之优越性

    既生瑜,何生亮.已有subversion,何需git?先有firefox叱咤一时,何需chrome来搅局? 原本以为之前的解决方案已经能够满足现时的需求,但这是真正的事实吗?直到新颖的工具降临,才惊叹 ...