hdu 2851 dijkstra算法变形

dijkstra算法模板:

Int visited[i]//结点i若被访问则为1,没有则为0
Int dist[i]// 目前结点j到其他各结点的最短路的长度
Int w[i][j]//边(i,j)的权值
初始化:(结点1~n)
memset(v,0,sizeof(v));
dist[j]=0;
dist[i]=inf;(i>=1&&i<=n&&i!=j)
    cin>>a>>b>>x;
     if(w[a][b]>x)//a到b可能有多条路径
    w[b][a]=w[a][b]=x;
w[x][y]=inf;边(x,y)不存在
for(i=1;i<=n;i++)
{
    int x,m=inf;
    for(j=1;j<=n;j++)
        if(!visited[j]&&dist[j]<m)
        {
            m=dist[j];
            x=j;
        }
visited[x]=1;
for(j=1;j<=n;j++)
If(!visited[j])
        dist[j]=min(dist[j],dist[x]+w[x][j])
}

Description

Lode Runner is a famous game, I think you played in your childhood.

Ok, now, I simple the problem. In the game, it has N horizontal roads, the ladders always stay at right side vertically, and the ladders are extending towards up and down with unlimited length. If ladder near or cross a road, little WisKey will walk on the
road by climbed the ladder. Two roads were covered by each other in the X-axis; it will be considered can be passing through. Each road has an integer W means the dangerous level.

Little WisKey must start at No.1 road, and he can’t go back, he always go ahead. WisKey want to go some roads, so he needs to know how minimum sum of dangerous will happen. You can finish the game, yes?

Input

The first integer C represents the number of cases, And C cases followed.

Each test case contains a single integer N roads (1<=N<= 2000) and M destinations (1<=M<=500). The next N line contains three integers Si, Ei, Wi, meaning the road build from Si to Ei, and the Wi dangerous level (0 <= Si <= Ei <= 1000, 1 <= Wi <= 1000). And
the roads sorted by Ei increasing yet. The last M line contains integers mean little WisKey’s destinations.

Output

For each questions, output the minimum sum of dangerous. If can’t reach the goal, please print -1.

Sample Input

3
10 4
1 4 7
5 6 3
3 7 5
2 9 8
10 13 8
12 14 11
11 15 13
16 18 5
17 19 6
8 20 9
1
2
3
10
5 5
1 4 5
3 6 10
5 8 20
2 9 1
7 10 2
1
2
3
4
5
4 4
1 5 1
2 7 20
2 7 3
7 9 4
1
2
3
4 

Sample Output

7
-1
12
24
5
15
35
6
8
1
21
4
8 

把点的权值转化为通向它的边的权值

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<string>
#include<algorithm>
#define LL long long
#define inf 0x3f3f3f3f
using namespace std;
struct node
{
    int l,r;
    int w;
}q[2010];
bool visited[2010];
int dist[2010];
int wx[2010][2010];
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        int n,m;
        cin>>n>>m;
        for(int i=1;i<=n;i++)
            scanf("%d%d%d",&q[i].l,&q[i].r,&q[i].w);
        memset(wx,inf,sizeof(wx));
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                if(i==j) wx[i][j]=wx[j][i]=0;
        for(int i=2;i<=n;i++)
            for(int j=1;j<=i-1;j++)
                if(q[j].r>=q[i].l)
                    wx[j][i]=q[i].w;
    memset(visited,0,sizeof(visited));
    memset(dist,inf,sizeof(dist));
    dist[1]=0;
    for(int i=1;i<=n;i++)
    {
        int x,mx=inf;
        for(int j=1;j<=n;j++)
            if(!visited[j]&&dist[j]<mx)
        {
            mx=dist[j];
            x=j;
        }
        visited[x]=1;
        for(int j=1;j<=n;j++)
            dist[j]=min(dist[j],dist[x]+wx[x][j]);
    }
        while(m--)
        {
            int b;
            cin>>b;
            if(dist[b]==inf)
                cout<<-1<<endl;
            else
                cout<<dist[b]+q[1].w<<endl;
        }
    }
    return 0;
}
时间: 2024-11-02 06:16:51

hdu 2851 dijkstra算法变形的相关文章

HDU 2112 HDU Today (Dijkstra算法)

HDU Today Time Limit: 15000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 13952    Accepted Submission(s): 3264 Problem Description 经过锦囊相助,海东集团终于度过了危机,从此,HDU的发展就一直顺风顺水,到了2050年,集团已经相当规模了,据说进入了钱江肉丝经济开发区500强.这时候

POJ 3255 Roadblocks Dijkstra 算法变形

#include <cstdio> #include <iostream> #include <queue> using namespace std; const int INF = 1000000; const int maxn = 5005; struct edge{ int y,w; edge(int cy,int ww){ y = cy; w = ww; } }; vector<edge> vec[maxn]; int n,m; struct num

畅通project续HDU杭电1874【dijkstra算法 || SPFA】

http://acm.hdu.edu.cn/showproblem.php?pid=1874 Problem Description 某省自从实行了非常多年的畅通project计划后.最终修建了非常多路.只是路多了也不好,每次要从一个城镇到还有一个城镇时,都有很多种道路方案能够选择,而某些方案要比还有一些方案行走的距离要短非常多.这让行人非常困扰. 如今,已知起点和终点,请你计算出要从起点到终点.最短须要行走多少距离. Input 本题目包括多组数据.请处理到文件结束. 每组数据第一行包括两个正

ACM: HDU 2544 最短路-Dijkstra算法

HDU 2544最短路 Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Description 在每年的校赛里,所有进入决赛的同学都会获得一件很漂亮的t-shirt.但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候,却是非常累的!所以现在他们想要寻找最短的从商店到赛场的路线,你可以帮助他们吗? Input 输入包括多组数据.每组数据第一行是两个整数N.M(N<=100,M<

ACM: HDU 3790 最短路径问题-Dijkstra算法

HDU 3790 最短路径问题 Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Description 给你n个点,m条无向边,每条边都有长度d和花费p,给你起点s终点t,要求输出起点到终点的最短距离及其花费,如果最短距离有多条路线,则输出花费最少的. Input 输入n,m,点的编号是1~n,然后是m行,每行4个数 a,b,d,p,表示a和b之间有一条边,且其长度为d,花费为p.最后一行是

ACM: HDU 1874 畅通工程续-Dijkstra算法

HDU 1874 畅通工程续 Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Description 某省自从实行了很多年的畅通工程计划后,终于修建了很多路.不过路多了也不好,每次要从一个城镇到另一个城镇时,都有许多种道路方案可以选择,而某些方案要比另一些方案行走的距离要短很多.这让行人很困扰. 现在,已知起点和终点,请你计算出要从起点到终点,最短需要行走多少距离. Input 本题目包含多

HDU 2112 HDU Today【最短路+map容器,spfa算法+Dijkstra算法】

HDU Today Time Limit: 15000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 25102    Accepted Submission(s): 6067 Problem Description 经过锦囊相助,海东集团终于度过了危机,从此,HDU的发展就一直顺风顺水,到了2050年,集团已经相当规模了,据说进入了钱江肉丝经济开发区500强.这时候

HDU 2544 最短路(我的dijkstra算法模板、SPAFA算法模板)

思路:这道题是基础的最短路径算法,可以拿来试一下自己对3种方法的理解 dijkstra主要是从第一个点开始枚举,每次枚举出当当前最小的路径,然后再以那最小的路径点为起点,求出它到其它未标记点的最短距离 bellman-ford 算法则是假设有向网中有n 个顶点.且不存在负权值回路,从顶点v1 和到顶点v2 如果存在最短路径,则此路径最多有n-1 条边.这是因为如果路径上的边数超过了n-1 条时,必然会重复经过一个顶点,形成回路:而如果这个回路的权值总和为非负时,完全可以去掉这个回路,使得v1到v

ACM: HDU 1869 六度分离-Dijkstra算法

HDU 1869六度分离 Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Description 1967年,美国著名的社会学家斯坦利·米尔格兰姆提出了一个名为“小世界现象(small world phenomenon)”的著名假说,大意是说,任何2个素不相识的人中间最多只隔着6个人,即只用6个人就可以将他们联系在一起,因此他的理论也被称为“六度分离”理论(six degrees of se