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. 在chrome中安装基于REST的web服务客户端

    基于REST的Web服务客户端的使用方法 点击转到基于REST的Web服务客户端下载页面 chrome浏览器如果安装扩展程序点击chrome浏览器右上角,选择“设置在“设置”对话框里选择“扩展程序”然 ...

  2. Linux期中架构 全网备份案例

    server端脚本 #!/bin/bash #1 进行数据完整性验证 并生成结果 find /backup -type f -name "finger.txt"| xargs md ...

  3. [UE4]Selector和Sequence的区别

    Selector和Sequence子节点都是返回true才会执行下一个子节点. Sequence是从左到右依次执行,左边节点如果返回false,则不会执行右边的节点 Selector会同步执行所有子节 ...

  4. C++中关于class B:A与Class B::A问题

    一,class B:A为类的继承关系,即A类是B类的基类class <派生类名>:<继承方式><基类名>{<派生类新定义成员>}; 例如: #inclu ...

  5. [转]Tornado get/post请求异步处理框架分析

    转自: http://m.blog.csdn.net/blog/joeyon/41956027 首先说下环境,python2.7,Tornado3.0 然后本文讨论的不是Tornado底层如何用epo ...

  6. Spark分析之Standalone运行过程分析

    一.集群启动过程--启动Master $SPARK_HOME/sbin/start-master.sh start-master.sh脚本关键内容: spark-daemon.sh start org ...

  7. 探究CSS中border-top属性的使用

    上一节我们介绍了CSS top属性的用法,那么这节关于CSS border-top属性用法学习起来就会轻松一些,border-top 简写属性把上边框的所有属性设置到一个声明中. 本文向大家描述一下C ...

  8. webpack(2)--Entry

    Entry entry是配置模块的入口,可以抽象成输入,webpack执行构建的第一步将从入口开始搜寻及递归解析出所有入口依赖的模块. 注意: entry是必填,若不填写则将导致webpack报错退出 ...

  9. opencv查看源代码

    这一节是一个插曲,有的人刚开始学opencv就看源代码,有的人直接拿着opencv的API用...... 学了一个多月opencv了,就是没找到源代码,想看的时候都是从网上找的,或者看网上说从哪个文件 ...

  10. Can not find the tag library descriptor for "http://java.sun.com/jsp/jstl/co

    转自:https://www.xuebuyuan.com/934357.html 需要引入standard.jar和jstl.jar 正确添加即可