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. appium 中文API 集

    参考:https://testerhome.com/topics/3711 根据appium 1.4.13.1版本整理,1.5弃用了find by name 所以更新了下如有错误请多多指正谢谢@lyl ...

  2. SimpleXML概述

    要处理XML 文件,有两种传统的处理思路:SAX 和DOM.SAX 基于事件触发机制,对XML 文件进行一次扫描,完成要进行的处理:DOM 则将整个XML 文件构造为一棵DOM树,通过对DOM 树的遍 ...

  3. Linux命令详解-用户管理

    1. 用户管理 1.Linux用户管理 linux有三类用户: (1.)超级用户 : root用户具有操作系统的一切权限 uid=0 (2.)普通用户: 具有操作系统有限的权限  uid=500-60 ...

  4. javascript中setInterval制作跑马灯的效果

    html代码: javascript代码 <script type="text/javascript"> function scroll() { var title = ...

  5. Spring Security编程模型

    1.采用spring进行权限控制 url权限控制 method权限控制 实现:aop或者拦截器(本质就是之前之后进行控制)--------------------proxy就是 2.权限模型: 本质理 ...

  6. python 四种数值类型(int,long,float,complex)介绍

    Python支持四种不同的数值类型,包括int(整数)long(长整数)float(浮点实际值)complex (复数),本文章向码农介绍python 四种数值类型,需要的朋友可以参考一下. 数字数据 ...

  7. html 更新

    HTML介绍 Web服务本质 import socket sk = socket.socket() sk.bind(("127.0.0.1", 8080)) sk.listen(5 ...

  8. python中的模块及包及软件目录结构规范

    知识内容: 1.模块的定义与分类 2.模块的导入 3.模块与包 4.不同目录下的模块调用 一.模块的定义与分类 1.什么是模块 模块就是实现了某个功能的代码集合,模块是由一大堆代码构成的 类似于函数式 ...

  9. python带参数装饰器使用

    # -*- coding: utf-8 -* """TensorFlow指定使用GPU工具类 author: Jill usage: 方法上加@tf_with_devic ...

  10. 0_Simple__simpleCubemapTexture

    立方体纹理贴图 ▶ 源代码.用纹理方法把元素按原顺序从 CUDA3D 数组中取出来,求个相反数放入全局内存,输出. #include <stdio.h> #include "cu ...