1.topology:

 #include <fstream>

 #include <iostream>

 #include <algorithm>

 #include <cstdio>

 #include <cstring>

 #include <cmath>

 #include <cstdlib>

 using namespace std;

 #define EPS 1e-6

 #define ll long long

 #define INF 0x7fffffff

 const int N=;

 const int N2=;

 int fir[N],next_[N2],u[N2],v[N2];

 int du[N];

 int n,m;

 void Topology();

 int main(){

     //freopen("D:\\input.in","r",stdin);

     //freopen("D:\\output.out","w",stdout);

     scanf("%d%d",&n,&m);

     for(int i=;i<=n;i++)   fir[i]=-,du[i]=;

     for(int i=;i<=m;i++){

         scanf("%d%d",&u[i],&v[i]);

         next_[i]=fir[u[i]];

         fir[u[i]]=i;

         du[v[i]]++;

     }

     Topology();

     return ;

 }

 void Topology(){

     int top=-;

     for(int i=;i<=n;i++)

         if(du[i]==)    du[i]=top,top=i;

     for(int i=;i<=n;i++){

         if(top==-){

             cout<<"A cycle exists in the graph!"<<endl;

             return;

         }else{

             int j=top;

             top=du[top];

             cout<<j<<endl;

             for(int k=fir[j];k!=-;k=next_[k]){

                 if(--du[v[k]]==)

                     du[v[k]]=top,top=v[k];

             }

         }

     }

 }

2.dijkstra:

 #include <fstream>

 #include <iostream>

 #include <algorithm>

 #include <cstdio>

 #include <cstring>

 #include <cmath>

 #include <cstdlib>

 using namespace std;

 #define INF 0x7fffffff

 const int N=;

 const int N2=;

 int node_num,edge_num,start_node,final_node;

 int node_first[N],node_next[N2],node_begin[N2],node_end[N2],node_value[N2];

 int dis[N],node_fa[N],road[N],road_len;

 bool b[N];

 void TheBegin();//初始化

 void Work();//存储无向图

 void Dijkstra();//核心算法

 void Road();//输出最短路径

 int main(){

     //freopen("D:\\input.in","r",stdin);

     //freopen("D:\\output.out","w",stdout);

     scanf("%d%d%d%d",&node_num,&edge_num,&start_node,&final_node);

     TheBegin();

     Work();

     Dijkstra();

     Road();

     return ;

 }

 void TheBegin(){

     for(int i=;i<=node_num;i++){

         node_first[i]=-;

         dis[i]=INF;

     }

 }

 void Work(){

     for(int i=;i<=edge_num;i++){

         scanf("%d%d%d",&node_begin[i],&node_end[i],&node_value[i]);

         node_next[i]=node_first[node_begin[i]];

         node_first[node_begin[i]]=i;

         node_begin[i+edge_num]=node_end[i];

         node_end[i+edge_num]=node_begin[i];

         node_value[i+edge_num]=node_value[i];

         node_next[i+edge_num]=node_first[node_begin[i+edge_num]];

         node_first[node_begin[i+edge_num]]=i+edge_num;

     }

 }

 void Dijkstra(){

     dis[start_node]=;

     for(int k=;k<=node_num;k++){

         int x,m=INF;

         for(int i=;i<=node_num;i++)

             if(!b[i]&&dis[i]<m) m=dis[x=i];

         b[x]=;

         for(int i=node_first[x];i!=-;i=node_next[i]){

             if(!b[node_end[i]]&&dis[node_end[i]]>dis[x]+node_value[i]){

                 dis[node_end[i]]=dis[x]+node_value[i];

                 node_fa[node_end[i]]=x;

             }

         }

     }

     printf("%d\n",dis[final_node]);

 }

 void Road(){

     for(int i=final_node;i!=start_node;i=node_fa[i])    road[road_len++]=i;

     printf("the shortest road is:%d",start_node);

     for(int i=road_len-;i>=;i--)  printf("-->%d",road[i]);

     puts("");

 }

3.dijkstra堆优化:

 #include <fstream>

 #include <iostream>

 #include <algorithm>

 #include <cstdio>

 #include <queue>

 #include <cstring>

 #include <cmath>

 #include <cstdlib>

 using namespace std;

 #define INF 0x7fffffff

 const int N=;

 const int N2=;

 int node_num,edge_num,start_node,final_node;

 int node_first[N],node_next[N2],node_begin[N2],node_end[N2],node_value[N2];

 int dis[N],node_fa[N],road[N],road_len;

 bool b[N];

 typedef pair<int,int> pii;

 priority_queue<pii,vector<pii>,greater<pii> >pq;

 void TheBegin();//初始化

 void Work();//存储无向图

 void Dijkstra();//核心算法

 void Road();//输出最短路径

 int main(){

     //freopen("D:\\input.in","r",stdin);

     //freopen("D:\\output.out","w",stdout);

     scanf("%d%d%d%d",&node_num,&edge_num,&start_node,&final_node);

     TheBegin();

     Work();

     Dijkstra();

     Road();

     return ;

 }

 void TheBegin(){

     for(int i=;i<=node_num;i++){

         node_first[i]=-;

         dis[i]=INF;

     }

 }

 void Work(){

     for(int i=;i<=edge_num;i++){

         scanf("%d%d%d",&node_begin[i],&node_end[i],&node_value[i]);

         node_next[i]=node_first[node_begin[i]];

         node_first[node_begin[i]]=i;

         node_begin[i+edge_num]=node_end[i];

         node_end[i+edge_num]=node_begin[i];

         node_value[i+edge_num]=node_value[i];

         node_next[i+edge_num]=node_first[node_begin[i+edge_num]];

         node_first[node_begin[i+edge_num]]=i+edge_num;

     }

 }

 void Dijkstra(){

     dis[start_node]=;

     pq.push(make_pair(dis[start_node],start_node));

     while(!pq.empty()){

         pii tmp=pq.top();

         pq.pop();

         int x=tmp.second;

         if(b[x])    continue;

         b[x]=;

         for(int i=node_first[x];i!=-;i=node_next[i]){

             if(!b[node_end[i]]&&dis[node_end[i]]>dis[x]+node_value[i]){

                 dis[node_end[i]]=dis[x]+node_value[i];

                 pq.push(make_pair(dis[node_end[i]],node_end[i]));//队列里可能会加入重复元素

                 node_fa[node_end[i]]=x;

             }

         }

     }

     printf("%d\n",dis[final_node]);

 }

 void Road(){

     for(int i=final_node;i!=start_node;i=node_fa[i])    road[road_len++]=i;

     printf("the shortest road is:%d",start_node);

     for(int i=road_len-;i>=;i--)  printf("-->%d",road[i]);

     puts("");

 }

4.spfa:

 #include <fstream>

 #include <iostream>

 #include <algorithm>

 #include <cstdio>

 #include <queue>

 #include <cstring>

 #include <cmath>

 #include <cstdlib>

 using namespace std;

 #define INF 0x7fffffff

 const int N=;

 const int N2=;

 int node_num,edge_num,start_node,final_node;

 int node_first[N],node_next[N2],node_begin[N2],node_end[N2],node_value[N2];

 int dis[N],node_fa[N],road[N],road_len;

 bool b[N];

 queue<int> q;

 void TheBegin();//初始化

 void Work();//存储无向图

 void Spfa();//核心算法

 void Road();//输出最短路径

 int main(){

     //freopen("D:\\input.in","r",stdin);

     //freopen("D:\\output.out","w",stdout);

     scanf("%d%d%d%d",&node_num,&edge_num,&start_node,&final_node);

     TheBegin();

     Work();

     Spfa();

     Road();

     return ;

 }

 void TheBegin(){

     for(int i=;i<=node_num;i++){

         node_first[i]=-;

         dis[i]=INF;

     }

 }

 void Work(){

     for(int i=;i<=edge_num;i++){

         scanf("%d%d%d",&node_begin[i],&node_end[i],&node_value[i]);

         node_next[i]=node_first[node_begin[i]];

         node_first[node_begin[i]]=i;

         node_begin[i+edge_num]=node_end[i];

         node_end[i+edge_num]=node_begin[i];

         node_value[i+edge_num]=node_value[i];

         node_next[i+edge_num]=node_first[node_begin[i+edge_num]];

         node_first[node_begin[i+edge_num]]=i+edge_num;

     }

 }

 void Spfa(){

     dis[start_node]=;

     q.push(start_node);

     while(!q.empty()){

         int x=q.front();

         q.pop();

         b[x]=;

         for(int i=node_first[x];i!=-;i=node_next[i]){

             if(dis[node_end[i]]>dis[x]+node_value[i]){

                 dis[node_end[i]]=dis[x]+node_value[i];

                 node_fa[node_end[i]]=x;

                 if(!b[node_end[i]]){

                     q.push(node_end[i]);

                     b[node_end[i]]=;

                 }

             }

         }

     }

     printf("%d\n",dis[final_node]);

 }

 void Road(){

     for(int i=final_node;i!=start_node;i=node_fa[i])    road[road_len++]=i;

     printf("the shortest road is:%d",start_node);

     for(int i=road_len-;i>=;i--)  printf("-->%d",road[i]);

     puts("");

 }

5.floyd:

 #include <fstream>

 #include <iostream>

 #include <algorithm>

 #include <cstdio>

 #include <cstring>

 #include <cmath>

 #include <cstdlib>

 using namespace std;

 #define INF 0x7fffffff

 const int N=;

 const int N2=;

 int node_num,edge_num,ans_num;

 int dp[N][N];

 int main()

 {

     //freopen("D:\\input.in","r",stdin);

     //freopen("D:\\output.out","w",stdout);

     int u,v,w;

     scanf("%d%d",&node_num,&edge_num);

     for(int i=;i<=node_num;i++)

         for(int j=;j<=node_num;j++)

             dp[i][j]=(i==j?:INF);

     for(int i=;i<=edge_num;i++)

     {

         scanf("%d%d%d",&u,&v,&w);

         dp[u][v]=w;

         dp[v][u]=w;

     }

     for(int k=;k<=node_num;k++)

         for(int i=;i<=node_num;i++)

             for(int j=;j<=node_num;j++)

                 if(dp[i][k]!=INF&&dp[k][j]!=INF)    dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]);

     scanf("%d",&ans_num);

     for(int i=;i<=ans_num;i++)

     {

         scanf("%d%d",&u,&v);

         printf("%d->%d: %d\n",u,v,dp[u][v]);

     }

     return ;

 }

6.kruskal(并查集):

 #include <fstream>

 #include <iostream>

 #include <algorithm>

 #include <cstdio>

 #include <cstring>

 #include <cmath>

 #include <cstdlib>

 using namespace std;

 #define EPS 1e-6

 #define ll long long

 #define INF 0x7fffffff

 const int N=;

 const int N2=;

 int node_num,edge_num;

 int node_u[N2],node_v[N2],node_w[N2],p[N],r[N2];

 inline int cmp(const int &a,const int &b)  { return node_w[a]<node_w[b]; }

 inline int find(int x) { return p[x]==x?x:p[x]=find(p[x]); }

 int Kruskal();

 int main(){

     //freopen("D:\\input.in","r",stdin);

     //freopen("D:\\output.out","w",stdout);

     scanf("%d%d",&node_num,&edge_num);

     for(int i=;i<=edge_num;i++)

         scanf("%d%d%d",&node_u[i],&node_v[i],&node_w[i]);

     printf("%d\n",Kruskal());

     return ;

 }

 int Kruskal(){

     int ans=;

     for(int i=;i<=node_num;i++)   p[i]=i;

     for(int i=;i<=edge_num;i++)   r[i]=i;

     sort(&r[],&r[edge_num+],cmp);

     for(int i=;i<=edge_num;i++){

         int e=r[i];

         int x=find(node_u[e]);

         int y=find(node_v[e]);

         if(x!=y)    ans+=node_w[e],p[x]=y;

     }

     return ans;

 }

7.prim:

 #include <fstream>

 #include <iostream>

 #include <algorithm>

 #include <cstdio>

 #include <cstring>

 #include <cmath>

 #include <cstdlib>

 using namespace std;

 #define EPS 1e-6

 #define ll long long

 #define INF 0x7fffffff

 const int N=;

 int a[N][N],distance_[N],node_num,edge_num;

 bool choose[N];

 int Prim();

 int main(){

     //freopen("D:\\input.in","r",stdin);

     //freopen("D:\\output.out","w",stdout);

     int u,v,w;

     scanf("%d%d",&node_num,&edge_num);

     for(int i=;i<=node_num;i++)

         for(int j=;j<=node_num;j++)

             a[i][j]=(i==j?:INF);

     for(int i=;i<=edge_num;i++){

         scanf("%d%d%d",&u,&v,&w);

         a[u][v]=w;

         a[v][u]=w;

     }

     printf("%d\n",Prim());

     return ;

 }

 int Prim(){

     int ans=;

     for(int i=;i<=node_num;i++)   choose[i]=,distance_[i]=INF;

     distance_[]=;

     for(int i=;i<=node_num;i++){

         int x=-;

         for(int j=;j<=node_num;j++)

             if(!choose[j])

                 if(x==-)    x=j;

                 else if(distance_[j]<distance_[x])    x=j;

         choose[x]=;

         ans+=distance_[x];

         for(int j=;j<=node_num;j++)

             if(!choose[j]&&a[x][j]!=INF){

                 distance_[j]=min(distance_[j],a[x][j]);

             }

     }

     return ans;

 }

8.prim堆优化:

 #include <fstream>

 #include <iostream>

 #include <algorithm>

 #include <cstdio>

 #include <cstring>

 #include <cmath>

 #include <cstdlib>

 #include <queue>

 using namespace std;

 #define EPS 1e-6

 #define ll long long

 #define INF 0x7fffffff

 const int N=;

 const int N2=;

 int distance_[N],node_num,edge_num;

 int node_first[N],node_next[N2],node_u[N2],node_v[N2],node_w[N2];

 bool choose[N];

 struct cmp{

     bool operator()(const int &a,const int &b) const{

         return distance_[a]>distance_[b];

     }

 };

 priority_queue<int,vector<int>,cmp> pq;

 int prim();

 int main(){

     //freopen("D:\\input.in","r",stdin);

     //freopen("D:\\output.out","w",stdout);

     scanf("%d%d",&node_num,&edge_num);

     for(int i=;i<=node_num;i++)

         node_first[i]=-;

     for(int i=;i<=edge_num;i++){

         scanf("%d%d%d",&node_u[i],&node_v[i],&node_w[i]);

         node_next[i]=node_first[node_u[i]];

         node_first[node_u[i]]=i;

         node_u[i+edge_num]=node_v[i];

         node_v[i+edge_num]=node_u[i];

         node_w[i+edge_num]=node_w[i];

         node_next[i+edge_num]=node_first[node_u[i+edge_num]];

         node_first[node_u[i+edge_num]]=i+edge_num;

     }

     printf("%d\n",prim());

     return ;

 }

 int prim(){

     int ans=;

     for(int i=;i<=node_num;i++)   choose[i]=,distance_[i]=INF;

     distance_[]=;

     pq.push();

     while(!pq.empty()){

         int x=pq.top();

         pq.pop();

         if(choose[x])   continue;

         choose[x]=;

         ans+=distance_[x];

         for(int i=node_first[x];i!=-;i=node_next[i])

             if(!choose[node_v[i]]){

                 if(distance_[node_v[i]]>node_w[i]){

                     distance_[node_v[i]]=node_w[i];

                     pq.push(node_v[i]);

                 }

             }

     }

     return ans;

 }

几个小模板：topology, dijkstra, spfa, floyd, kruskal, prim的更多相关文章

  1. 最短路算法详解（Dijkstra/SPFA/Floyd）

    新的整理版本版的地址见我新博客 http://www.hrwhisper.me/?p=1952 一.Dijkstra Dijkstra单源最短路算法,即计算从起点出发到每个点的最短路.所以Dijkst ...

  2. 【模板】dijkstra与floyd

    (我永远喜欢floyd) 温馨提示:与SPFA一起食用效果更佳 传送门:https://www.cnblogs.com/Daz-Os0619/p/11388157.html Floyd 大概思路: 对 ...

  3. (最短路径算法整理)dijkstra、floyd、bellman-ford、spfa算法模板的整理与介绍

    这一篇博客以一些OJ上的题目为载体.整理一下最短路径算法.会陆续的更新... 一.多源最短路算法--floyd算法 floyd算法主要用于求随意两点间的最短路径.也成最短最短路径问题. 核心代码: / ...

  4. 最短路（Dijkstra，Floyd，Bellman_Ford，SPFA）

    当然,这篇文章是借鉴大佬的... 最短路算法大约来说就是有4种——Dijkstra,Floyd,Bellman_Ford,SPFA 接下来,就可以一一看一下... 1.Dijkstra(权值非负,适用 ...

  5. 单元最短路径算法模板汇总(Dijkstra, BF,SPFA)，附链式前向星模板

    一:dijkstra算法时间复杂度,用优先级队列优化的话,O((M+N)logN)求单源最短路径,要求所有边的权值非负.若图中出现权值为负的边,Dijkstra算法就会失效,求出的最短路径就可能是错的 ...

  6. hdu 2066 ( 最短路) Floyd & Dijkstra & Spfa

    http://acm.hdu.edu.cn/showproblem.php?pid=2066 今天复习了一下最短路和最小生成树,发现居然闹了个大笑话-----我居然一直写的是Floyd,但我自己一直以 ...

  7. 算法学习笔记（三） 最短路 Dijkstra 和 Floyd 算法

    图论中一个经典问题就是求最短路.最为基础和最为经典的算法莫过于 Dijkstra 和 Floyd 算法,一个是贪心算法,一个是动态规划.这也是算法中的两大经典代表.用一个简单图在纸上一步一步演算,也是 ...

  8. HDU 2992 Hotel booking（BFS+DFS 或者 SPFA+Floyd）

    点我看题目 题意 : 一个司机要从1点到达n点,1点到n点中有一些点有宾馆,司机的最长开车时间不能超过10小时,所以要在10小时之内找到宾馆休息,但是为了尽快的走到n点,问最少可以经过几个宾馆. 思路 ...

  9. PKU 1932 XYZZY(Floyd+Bellman||Spfa+Floyd)

    题目大意:原题链接 给你一张图,初始你在房间1,初始生命值为100,进入每个房间会加上那个房间的生命(可能为负),问是否能到达房间n.(要求进入每个房间后生命值都大于0) 解题思路: 解法一:Floy ...

随机推荐

  1. 学习笔记之Cloud computing

    Cloud computing - Wikipedia https://en.wikipedia.org/wiki/Cloud_computing

  2. 初步认识AutoMapper

      AutoMapper 初步认识AutoMapper 前言 手动映射 使用AutoMapper 创建映射 Conventions 映射到一个已存在的实例对象   前言 通常在一个应用程序中,我们开发 ...

  3. C#中char空值的几种表示方式

    C#中char空值的几种表示方式 在C#中char类型的表示方式通常是用单引号作为分隔符,而字符串是用双引号作为分隔符. 例如: 程序代码 程序代码 char a = 'a'; char b = 'b ...

  4. Spark SQL 基本原理

    Spark SQL 模块划分 Spark SQL架构--catalyst设计图 Spark SQL 运行架构 Hive的兼容性

  5. JavaScript函数及作用域

    知识内容: 1.JavaScript函数 2.JavaScript全局函数及特殊函数 3.JavaScript作用域 4.本节练习 参考资料:<JavaScript高级程序设计> 一.Ja ...

  6. python拓展1 week1-week5复习回顾

    知识内容: 1.python基础概念及基础语法 2.python基础数据类型 3.python模块相关 4.python函数相关 5.python面向对象相关 6.python文件处理相关 注:本节内 ...

  7. sqlserver操作命令

    启动命令:Net Start MSSqlServer 暂停命令:Net Pause MSSqlServer 重新启动暂停的命令:Net Continue MSSqlServer 停止命令:Net st ...

  8. tornado--同步异步

    同步:指两个或两个以上随时间变化的量在变化过程中保持一定的相对关系 现象:有一个共同的时钟,按来的顺序一个一个处理 异步:双方不需要共同的时钟,也就是接收方不知道发送方什么时候发送,所以在发送的信息中 ...

  9. tensorflow读取数据

    线程和队列 在使用TensorFlow进行异步计算时,队列是一种强大的机制. 为了感受一下队列,让我们来看一个简单的例子.我们先创建一个“先入先出”的队列(FIFOQueue),并将其内部所有元素初始 ...

  10. Python入门-散点图绘制

    Python入门-散点图绘制  废话不说 直接上代码 import matplotlib.pyplot as plt x_values = list(range(1,1001)) y_values = ...