UESTC30-最短路-Floyd最短路、spfa+链式前向星建图

最短路

Time Limit: 3000/1000MS (Java/Others)
Memory Limit: 65535/65535KB (Java/Others)

在每年的校赛里,所有进入决赛的同学都会获得一件很漂亮的T-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候,却是非常累的!所以现在他们想要寻找最短的从商店到赛场的路线,你可以帮助他们吗?

Input

输入包括多组数据。

每组数据第一行是两个整数NN ,MM (N≤100N≤100 ,M≤10000M≤10000 ),NN 表示成都的大街上有几个路口,标号为11 的路口是商店所在地,标号为NN 的路口是赛场所在地,MM 则表示在成都有几条路。N=M=0N=M=0 表示输入结束。

接下来MM 行,每行包括33 个整数AA ,BB ,CC (1≤A1≤A ,B≤NB≤N ,1≤C≤10001≤C≤1000 ),表示在路口AA 与路口BB 之间有一条路,我们的工作人员需要CC 分钟的时间走过这条路。

输入保证至少存在11 条商店到赛场的路线。

Output

对于每组输入,输出一行,表示工作人员从商店走到赛场的最短时间。

Sample input and output

Sample Input Sample Output
2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0
3
2

题意好理解,就是最短路。

最短路。。。传送门http://developer.51cto.com/art/201403/433874.htm

打训练赛的时候这个题wa了7次,最后也没写对,也是没谁了(;′д`)ゞ

代码:

#include<bits/stdc++.h>
using namespace std;
const int N=100+10;
const int INF=0x3f3f3f3f;
typedef long long ll;
int hh[N][N];
int n,m;
int gg(){                                                    //关键
    for(int h=1;h<=n;h++)
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)                                   //这里当时写错了,j<=n写成j<=m了。。。
    hh[i][j]=min(hh[i][j],hh[i][h]+hh[h][j]);
}
int main(){
    int h,k,l;
    while(~scanf("%d%d",&n,&m)&&(n||m)){
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
            hh[i][j]=INF;
            for(int i=0;i<m;i++){
                scanf("%d%d%d",&h,&k,&l);
                if(l<hh[h][k])
                    hh[h][k]=hh[k][h]=l;
            }
            gg();
            printf("%d\n",hh[1][n]);
    }
    return 0;
}

啊啊啊啊啊啊啊,还有一个思路可以写,spfa算法+链式前向星建图

然而,前向星有的看懂了,有的还很(O_O)?传送门http://www.cnblogs.com/Tovi/p/6194786.html

人家的代码,传送门http://blog.csdn.net/lvshubao1314/article/details/23034601

代码:

#include<string.h>
#include<stdio.h>
#include<iostream>
#include<queue>
using namespace std;
const int maxn=1e5+1;
const int INF=1e9;
struct node{
    int b,w,next;
};
node edge[maxn];
int s,n,ip;
int head[maxn],que[maxn],visit[maxn],dis[maxn];
void add(int u,int v,int c){
    edge[ip].b=v;edge[ip].w=c;edge[ip].next=head[u];head[u]=ip++;
}
void spfa(int start,int numpoint){
    memset(visit,0,sizeof(visit));
    for(int i=0;i<=numpoint;i++)
        dis[i]=INF;
    int front=-1,tail=-1;
    dis[start]=0;visit[start]=1;que[++tail]=start;
    int top,to,temp;
    while(front!=tail){
        if(++front>numpoint)front-=numpoint;
        top=que[front];visit[top]=0;
        for(int p=head[top];p!=-1;p=edge[p].next){
            to=edge[p].b;temp=dis[top]+edge[p].w;
            if(dis[to]>temp){
                dis[to]=temp;
                if(!visit[to]){
                    if(++tail>numpoint)tail-=numpoint;
                    que[tail]=to;
                    visit[to]=1;
                }
            }
        }
    }
}
int main(){
    int b,w,m,k;
    while(~scanf("%d%d",&n,&m)){
        if(m==0&&n==0)break;
        int maxx=-100;
        memset(head,-1,sizeof(head));
        ip=0;
        for(int i=1;i<=m;i++){
            cin>>k>>b>>w;
            if(k>maxx)maxx=k;
            if(b>maxx)maxx=b;
            add(k,b,w);
            add(b,k,w);
        }
        spfa(1,maxx);
        printf("%d\n",dis[n]);
    }
    return 0;
}

菜的掉渣,继续努力TAT

时间: 2024-08-01 17:43:57

UESTC30-最短路-Floyd最短路、spfa+链式前向星建图的相关文章

NYOJ 20 吝啬的国度 【BFS+链式前向星建图,Vector建图】

吝啬的国度 时间限制:1000 ms  |  内存限制:65535 KB 难度:3 描述 在一个吝啬的国度里有N个城市,这N个城市间只有N-1条路把这个N个城市连接起来.现在,Tom在第S号城市,他有张该国地图,他想知道如果自己要去参观第T号城市,必须经过的前一个城市是几号城市(假设你不走重复的路). 输入 第一行输入一个整数M表示测试数据共有M(1<=M<=5)组 每组测试数据的第一行输入一个正整数N(1<=N<=100000)和一个正整数S(1<=S<=100000

链式前向星建图

1 /* 2 //链式前向星维护的是一个边集数组 3 const int N = 1e6+5;//边的数目 4 int head[N];//某个点相邻的第一条边的编号 5 int cnt;//边的数目 6 struct Edge{ 7 int to;//这条边到达的终点 8 int dis;//这条边的权值 9 int next;//这条边指向的下一条边的编号(可以自己想想,并不是上一条,采用的是类似于前插法) 10 }edge[N]; 11 void addEdge(int u,int v,i

最短路 spfa 算法 &amp;&amp; 链式前向星存图

推荐博客  https://i.cnblogs.com/EditPosts.aspx?opt=1 http://blog.csdn.net/mcdonnell_douglas/article/details/54379641 spfa  自行百度 说的很详细 spfa 有很多实现的方法  dfs  队列  栈  都可以 时间复杂度也不稳定 不过一般情况下要比bellman快得多 #include <stdio.h> #include <math.h> #include <st

最短路 SPFA()链式前向星

在极端情况下,图特别大,用邻接链表也会超空间限制,此时需要用到链式前向星来存图. 1 #include<bits/stdc++.h> 2 using namespace std; 3 4 const int inf = INT_MAX / 10; 5 const int num = ???; 6 struct Edge{ 7 int to, next, w;//edge[i]的i就是起点,终点to,权值w,相同起点的下一条边next 8 }edge[num]; 9 int n, m, cnt;

POJ 3159 Candies(差分约束+spfa+链式前向星)

题目链接:http://poj.org/problem?id=3159 题目大意:给n个人派糖果,给出m组数据,每组数据包含A,B,C三个数,意思是A的糖果数比B少的个数不多于C,即B的糖果数 - A的糖果数<=C . 最后求n 比 1 最多多多少颗糖果. 解题思路:经典差分约束的题目,具体证明看这里<数与图的完美结合——浅析差分约束系统>. 不妨将糖果数当作距离,把相差的最大糖果数看成有向边AB的权值,我们得到 dis[B]-dis[A]<=w(A,B).看到这里,我们可以联想到

链式前向星存图

#include <iostream> #include <cstdio> #include <algorithm> #include <cstring> #define INF 0x3f3f3f3f using namespace std; typedef long long ll; const int maxn = 1000000 + 5; int n,m,be,en; int to[maxn]; int cost[maxn]; int head[max

【最短路】Dijkstra+ 链式前向星+ 堆优化(优先队列)

Dijkstra+ 链式前向星+ 优先队列   Dijkstra算法 Dijkstra最短路算法,个人理解其本质就是一种广度优先搜索.先将所有点的最短距离Dis[ ]都刷新成∞(涂成黑色),然后从起点x (Dis[x]= 0, Dis[]值最小 )开始查询:先将x 加入(涂成灰色),对x 的所有边进行遍历,对所有搜索到的点x+ 1 进行松弛(刷新),若经过x 点的松弛,得到的距离小于原来的值:Dis[x]+ dis(x, x+ 1) < Dis[x+ 1], 则用新值刷新,把x+ 1加入(涂成灰

HDU3342 Legal or Not【拓扑排序】【链式前向星】

Legal or Not Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 4633    Accepted Submission(s): 2115 Problem Description ACM-DIY is a large QQ group where many excellent acmers get together. It is

链式前向星DFS

采用链式前向星存图的DFS: #include <iostream> #include <cmath> #include <cstdio> #include <cstring> #include <cstdlib> #include <algorithm> #include <queue> using namespace std; typedef long long LL; const int maxN = 100 + 3