哈理工 oj 2122 旅行（map + 最短路dij算法）

最新推荐文章于 2020-06-03 10:49:13 发布

研发之道

最新推荐文章于 2020-06-03 10:49:13 发布

阅读量990

点赞数

CC 4.0 BY-SA版权

分类专栏：最短路问题文章标签：算法 acm 编程 c++ IT

未来百科AI导航：https://www.huntagi.com

本文链接：https://blog.youkuaiyun.com/lsgqjh/article/details/47053263

最短路问题专栏收录该内容

11 篇文章

订阅专栏

本文介绍了一个旅行场景下的路径规划问题，旨在寻找从起点到终点所需的最少费用路径。通过使用Dijkstra算法实现，解决了旅行者在有限预算内的最优路径选择问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

旅行

Time Limit: 1000 MS

Memory Limit: 32768 K

Total Submit: 18(6 users)

Total Accepted: 3(3 users)

Rating:

Special Judge: No

Description

“04.24，和Sakura去东京天空树，世界上最暖和的地方天空树的顶上。”

“04.26，和Sakura去明治神宫，有人在那里举办婚礼。”

“04.25，和Sakura去迪士尼，鬼屋很可怕，但是有Sakura在，所以不可怕。”

“Sakura最好了。”

——江南《龙族》

绘梨衣和路明非今天要从迪士尼前往天空树，但他们的钱不多了，所以能省则省，他们现在有一个地图上面有n个景点和m条景点之间的路，每条路坐车都需要一定的钱数，现在他们求助于你，请你帮他们计算下从当前地点到目的地最少需要的钱数。

Input

有多组数据，每组数据第一行有两个数字2<=n<=30000，1<=m<=30000。

接下来n行输入n个地名。

接下来m行每行有两个字符串(长度不超过20)和一个数字，代表两地之间的坐车的费用。

接下来一行输入两个字符串分别代表起点和终点。

Output

一个int数代表最少需要的钱数。

数据保证不会超过int型范围。

Sample Input

2 1
disney
TokyoSkyTree
disney TokyoSkyTree 1
disney TokyoSkyTree

Sample Output

Source

2014暑假集训练习赛（7月19日）

看到理工题目上这个题目做的人没几个，就看看是什么玩意儿~！~

#include<iostream>
#include<sstream>
#include<algorithm>
#include<cstdio>
#include<string.h>
#include<cctype>
#include<string>
#include<cmath>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<set>
using namespace std;
const int maxn=30003;
const int INF=0x1f1f1f1f;
int n,m;
//标记起始位置
string s;
string e;
map<string,int>cnt;//映射成节点编号

struct Edge
{
    int from,to,dist;
    Edge(int u,int v,int d):from(u),to(v),dist(d) {}
};
vector<Edge>edges;//存储边的结点信息
vector<int>G[maxn];//邻接表
bool done[maxn];   //标记是否访问过
int d[maxn];    //距离数组
struct heapnode //用于优先队列自定义
{
    int d,u;
    bool operator <(const heapnode rhs) const
    {
        return d > rhs.d;
    }
    heapnode(int dd,int uu):d(dd),u(uu) {}
};


void init()//初始化必不可少
{
    for(int i=0; i<n; i++)
        G[i].clear();
    edges.clear();
}

void addedge(int from,int to,int dist)
{
    edges.push_back(Edge(from,to,dist));
    int m = edges.size();
    G[from].push_back(m-1);
}

void dij( int s)
{
    priority_queue<heapnode>Q;
    for(int i=0; i<=n; i++)//初始化距离数组
        d[i]=INF;
    d[s]=0;
    memset(done ,0,sizeof(done));
    Q.push( heapnode(0,s) );
    while(!Q.empty())
    {
        heapnode x = Q.top();
        Q.pop();
        int u=x.u;
        if(u==cnt[e])
        {
            printf("%d\n",x.d);
            break;
        }
        if(done[u])continue;
        done[u] = true;
        for(int i=0; i<G[u].size(); i++)
        {
            Edge& e=edges[G[u][i]];//取出来一条邻接边
            if(d[e.to]>d[u]+e.dist)
            {
                d[e.to] = d[u] + e.dist;
                Q.push((heapnode(d[e.to],e.to)));
            }
        }
    }
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        int t=1;
        int ans=0;
        string str;
        init();
        for(int i=0; i<n; i++)
        {
            cin>>str;
            cnt[str]=t++;
        }
        for(int i=0; i<m; i++)
        {
            string str2;
            int x;
            cin>>str>>str2>>x;
            addedge(cnt[str],cnt[str2],x);
            addedge(cnt[str2],cnt[str],x);
        }
        cin>>s>>e;
        dij(cnt[s]);
        s.clear();
        e.clear();
        cnt.clear();
    }
    return 0;
}
/*
2 1
a
v
a v 1
a v
3 2
a
b
c
a b 2
b c 3
a c
*/