[SinGuLaRiTy] 最短路计算代码库

【SinGuLaRiTy-1002】 Copyright (c) SinGuLaRiTy 2017. All Rights Reserved.

Dijkstra:

题目描述

有向图的单源点最短路问题(Dijkstra算法)

输入

第1行:2个空格分开的整数n(2<=n<=500)和m(10<=m<=20000),分别表示图的顶点数和边数。

第2..m+1行:每行3个空格分开的整数i,j, w。i表示一条边的起点,j表示终点, w表示权值。

第m+2行:2个整数s,t(1<=s,t<=n),表示指定的顶点。

输出

第1行:最小距离

第2行:最短路径(从起点到终点的序列,用1个空格分开)

样例输入 样例输出

5 7

1 2 10

1 4 30

1 5 100

2 3 50

3 5 10

4 3 20

4 5 60

1 5


60

1 4 3 5

代码:

#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<cmath>
using namespace std;
int n,m;
int G[501][501],dis[501],L[501];
bool used[501];
void Dijkstra(int s)
{
    for(int i=1;i<=n;i++)
    {
        used[s]=1;
        for(int j=1;j<=n;j++)
        {
            if(G[s][j]==0||s==j)
                continue;
            if(dis[j]>dis[s]+G[s][j])
                dis[j]=dis[s]+G[s][j],L[j]=s;
        }
        int themin=0x3f3f3f3f;
        for(int i=1;i<=n;i++)
            if(used[i]==0&&dis[i]<themin)
                s=i,themin=dis[i];
    }
}
int main()
{
    int a,b,c,S,E,cnt=1;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        G[a][b]=c;
    }
    scanf("%d%d",&S,&E);
    int e=E;
    dis[S]=0;
    for(int i=1;i<=n;i++)
        if(i!=S) dis[i]=0x3f3f3f3f;  

    Dijkstra(S);

    printf("%d\n",dis[E]);
    while(L[E]!=0)
    {
        dis[cnt++]=L[E];
        E=L[E];
    }
    for(int i=cnt-1;i>=1;i--)
        printf("%d ",dis[i]);
    printf("%d",e);
    return 0;
}

SPAF:

题目描述

有向图的单源点最短路径问题。源点编号为1,终点编号为n。

输入

第1行:2个空格分开的整数n(2<=n<=5000)和m(10<=m<=500000),分别表示图的顶点数和边数。

第2..m+1行:每行3个空格分开的整数i,j, w。i表示一条边的起点,j表示终点, w表示权值。

输出

第1行:1个整数,表示最小距离

样例输入1 样例输出1

4 7

1 2 68

1 3 19

1 4 66

2 3 23

3 4 65

3 2 57

4 1 68

66

样例输入

样例输出

3 3

1 2 -7

2 3 4

3 1 2

No Solution

代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
struct node{
    int v,w,next;
}edge[500050];
int cnt,head[5050],n,m,dis[5050],tot[5050];
bool inq[5050];
void addedge(int u,int v,int w)
{
    edge[cnt].v=v;
    edge[cnt].w=w;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}
bool SPFA()
{
    memset(dis,0x3f,sizeof dis);
    dis[1]=0;
    inq[1]=1;
    deque<int>q;
    q.push_front(1);
    while(!q.empty())
    {
        int u=q.front();
        q.pop_front();
        inq[u]=0;
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].v,w=edge[i].w;
            if(dis[v]>dis[u]+w)
            {
                dis[v]=dis[u]+w;
                if(!inq[v])
                {
                    if(dis[v]<dis[u])q.push_front(v);
                    else q.push_back(v);
                    inq[v]=1;
                    if(++tot[v]>n)return 0;
                }
            }
        }
    }
    return 1;
}
int main()
{
    int u,v,w;
    scanf("%d%d",&n,&m);
    memset(head,-1,sizeof head);
    for(int i=1;i<=m;++i)
    {
        scanf("%d%d%d",&u,&v,&w);
        addedge(u,v,w);
    }
    SPFA()?printf("%d\n",dis[n]):
    puts("No Solution");
}

Floyd:

代码:

#include<cstdio>
#include<cstring>
#define maxn 100
#define INF -1
int map[maxn][maxn];
int n, m, path[maxn][maxn];  

void Floyd(int n)
{
    int i, j, k;
    for(k = 0; k < n; ++k)
        for(i = 0; i < n; ++i)
            for(j = 0; j < n; ++j)
                if(map[i][k] != INF && map[k][j] != INF && (map[i][k] + map[k][j] < map[i][j] || map[i][j] == INF)){
                    map[i][j] = map[i][k] + map[k][j];
                    path[i][j] = k;
                }
}  

void getPath(int v, int u)
{
    int k = path[v][u];
    if(k == INF){
        printf("%d===>", v);
                return;
    }
    getPath(v, k);
    getPath(k, u);
}  

int main()
{
    scanf("%d%d", &n, &m);
    memset(map, INF, sizeof(map));
    memset(path, INF, sizeof(path));
    int i, j, a, b, c;
    for(i = 0; i < n; ++i) map[i][i] = 0;
    for(i = 0; i < m; ++i){
        scanf("%d%d%d", &a, &b, &c);
        map[a][b] = c;
    }
    Floyd(n);
    for(i = 0; i < n; ++i)
        for(j = 0; j < n; ++j)
            if(map[i][j] != INF){
                printf("%d->%d:%d\n the path is:", i, j, map[i][j]);
                getPath(i, j);
                printf("%d\n", j);
            }
    return 0;
}  

BellmanFord:

题目描述

有向图负权的单源点最短路问题(BellmanFord 算法),如果最短路径有多条,输出路径经过边数较小的解; 如果最短路径边数相同,输出编号较小的序列.

输入

第1行:2个空格分开的整数n(2<=n<=500)和m(10<=m<=20000),分别表示图的顶点数和边数。

第2..m+1行:每行3个空格分开的整数i,j, w。i表示一条边的起点,j表示终点, w表示权值。

第m+2行:2个整数s,t(1<=s,t<=n),表示指定的顶点。

输出

第1行:最小距离

第2行:最短路径(从起点到终点的序列,用1个空格分开)

如果出现负权回路,输出:No Solution

样例输入 样例输出
6 7
1 2 2
1 3 -1
2 4 -3
3 4 3
3 6 7
4 6 -2
3 5 6
1 6
-3
1 2 4 6

代码:

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int f[20005][3],dis[505],s[505];
void print(int x)
{
    if(s[x]==0) return;
    print(s[x]);
    printf(" %d",x);
}
int main()
{
    int n,m,i,j,q,z;
    scanf("%d%d",&n,&m);
    for(i=1;i<=m;i++)
        scanf("%d%d%d",&f[i][0],&f[i][1],&f[i][2]);
    scanf("%d%d",&q,&z);
    memset(dis,1,sizeof(dis));
    dis[q]=0;
    for(i=1;i<=n;i++){
        for(j=1;j<=m;j++){
            if(dis[f[j][0]]+f[j][2]<dis[f[j][1]]&&i<n){
                dis[f[j][1]]=dis[f[j][0]]+f[j][2];
                s[f[j][1]]=f[j][0];
            }
            if(i==n&&dis[f[j][0]]+f[j][2]<dis[f[j][1]]){
                printf("No Solution");
                return 0;
            }
        }
    }
    printf("%d\n",dis[z]);
    printf("%d",q);
    print(z);
}

Time:2017-02-03

时间: 2024-11-01 20:10:07

[SinGuLaRiTy] 最短路计算代码库的相关文章

【Neko C Engine】一个基于 C 语言的游戏基础代码库

原本已经用 C++ 在写着一个游戏代码库了,个人作品,规模很小,只能满足基本的游戏开发需求,后来突发奇想,试着用 C 语言重写了一次自己的游戏代码库,姑且叫做 Neko C Engine 吧,缩写 nkCEngine,基于 Windows 系统,底层封装了 Win32 窗口.D3D.DirectSound 等等,使用的时候不需要操心 Win32 窗口,不需要操心绘图与音效播放的细节,直接一个 C 函数创建对象,然后用对应的 C 函数操作对象: 这个库的最终目标,是希望公开出来给所有对游戏开发感兴

Overview of the Oppia codebase(Oppia代码库总览)

Oppia is built with Google App Engine. Its backend is written in Python, and its frontend is written using AngularJS. Oppia是基于Google App Engine开发建设的.它的后台是用Python编写,前端是用AngularJS编写. The core核心 Most of Oppia's functionality is in the core/ directory, w

[java代码库]-简易计算器(第二种)

第二种方案:在程序中不使用if/switch……case等语句,完成计算器功能. <html> <head> <title>简易计算器</title> <script language="javascript">//易错:不是"text/javascript" function doCal(){ var value1=parseInt(document.getElementById("value1

Python科学计算函数库介绍

数值计算库 NumPy为Python提供了快速的多维数组处理的能力,而SciPy则在NumPy基础上添加了众多的科学计算所需的各种工具包,有了这两个库,Python就有几乎和Matlab一样的处理数据和计算的能力了. NumPy和SciPy官方网址: http://www.scipy.org NumPy为Python带来了真正的多维数组功能,并且提供了丰富的函数库处理这些数组.它将常用的数学函数都进行数组化,使得这些数学函数能够直接对数组进行操作,将本来需要在Python级别进行的循环,放到C语

IOS代码库

1 /* 九宫格计算 */ 2 int totalCol = 5;//指定总列数 3 4 CGFloat viewW = 50;//subview宽度 5 CGFloat viewH = 50;//subview高度 6 7 CGFloat marginX = (self.view.bounds.size.width-viewW*totalCol)/(totalCol+1);//计算横向空白间隙 8 CGFloat marginY = marginX;//计算纵向空白间隙(和横向一致) 9 10

Python-布尔类型与短路计算-03.15-yulong

布尔类型与短路计算 我们已经了解了Python支持布尔类型的数据,布尔类型只有True和False两种值,但是布尔类型有以下几种运算: 与运算:只有两个布尔值都为 True 时,计算结果才为 True. True and True # ==> TrueTrue and False # ==> FalseFalse and True # ==> FalseFalse and False # ==> False 或运算:只要有一个布尔值为 True,计算结果就是 True. True

Python中的短路计算

在Python中,布尔类型还可以与其他数据类型做 and.or和not运算,请看下面的代码: In [1]: a = True In [2]: print(a and 'a=T' or 'a=F') a=T 输出为: a=T 计算结果不是布尔类型,而是字符串 a=T,这是为什么呢? 因为Python把0.空字符串''和None看成 False,其他数值和非空字符串都看成 True,所以: True and 'a=T' 计算结果是 'a=T' 继续计算 'a=T' or 'a=F' 计算结果还是

ACM选手进阶指北:一个好的代码库与latex维护代码文档

一个好的代码库是必须的,打的久的人心里自然有b数 而且对于算法模板而言,简单的文件夹分级维护就能满足所有需求了 当然,好的代码库不只是把代码堆进去那么简单, 还需要随用随取,变量名不冲突,风格一致,封装优秀等等 并且每次写题都用自己的板子,不断精进细节 非常推荐使用封装,默认参数,宏定义,有意义的变量名,统一取名习惯和常数名等等 例如主席树的模板代码,直接复制粘贴就能用,也不会和你写了一半的其他代码冲突: int rt[maxn];//@树根@ class ptree{public: #defi

iOS流行的开源代码库

本文介绍一些流行的iOS的开源代码库 1.AFNetworking 更新频率高的轻量级的第三方网络库,基于NSURL和NSOperation,支持iOS和OSX.https://github.com/AFNetworking/AFNetworking 2.GPUImage 图像处理库,基于OpenGL ES,图像处理效率高.https://github.com/BradLarson/GPUImage 3.Masonry 自动布局库.https://github.com/SnapKit/Mason