相当于模板题了，用trie来完成字符串到数字的映射比map<string, int>要快不少，令外可以考虑hash。

运行时间对比：

(1)(2)600ms左右 (3)3000ms左右(4)1500ms左右

（1）O(n^2)的dijkstra:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <map>
using namespace std;
 
#define umin(a, b) if ((a) > (b)) (a) = (b)
 
const int maxn = 157;
 
int n;
struct Trie {
    int ch[maxn * 32][26];
    int val[maxn * 32], sz;
    void init() {
        memset(val, 0, sizeof(val));
        memset(ch[0], 0, sizeof(ch[0]));
        sz = 0;
    }
    int insert(char *s) {
        int i = 0, j = 0;
        for (; s[j]; i = ch[i][s[j]], j ++) {
            if (s[j] < 'a') s[j] -= 'A';
            else s[j] -= 'a';
            if (!ch[i][s[j]]) {
                ch[i][s[j]] = ++ sz;
                memset(ch[sz], 0, sizeof(ch[sz]));
            }
        }
        if (!val[i]) val[i] = ++ n;
        return val[i];
    }
} trie;
 
int dist[maxn][maxn], d[maxn];
bool vis[maxn];
 
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif // ONLINE_JUDGE
    int m;
    char s1[40], s2[40];
    int t;
    while (cin >> m, ~m) {
        n = 0;
        trie.init();
        scanf("%s%s", s1, s2);
        trie.insert(s1);
        t = trie.insert(s2);
        memset(dist, 0x3f, sizeof(dist));
        for (int i = 0; i < m; i ++) {
            int x;
            scanf("%s%s%d", s1, s2, &x);
            int u = trie.insert(s1), v = trie.insert(s2);
            umin(dist[u][v], x);
            umin(dist[v][u], x);
        }
        memset(vis, 0, sizeof(vis));
        memset(d, 0x3f, sizeof(d));
        d[1] = 0;
        for (int i = 1; i < n; i ++) {
            int pos = 0, mind = 0x3f3f3f3f;
            for (int j = 1; j <= n; j ++) {
                if (!vis[j] && d[j] < mind) {
                    mind = d[j];
                    pos = j;
                }
            }
            if (!pos) break;
            vis[pos] = true;
            for (int j = 1; j <= n; j ++) {
                if (!vis[j]) umin(d[j], d[pos] + dist[pos][j]);
            }
        }
        printf("%d\n", d[t] == 0x3f3f3f3f? -1 : d[t]);
    }
    return 0;
}

（2）SPFA:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <map>
using namespace std;
 
#define umin(a, b) if ((a) > (b)) (a) = (b)
 
const int maxn = 157;
 
int n;
struct Trie {
    int ch[maxn * 32][26];
    int val[maxn * 32], sz;
    void init() {
        memset(val, 0, sizeof(val));
        memset(ch[0], 0, sizeof(ch[0]));
        sz = 0;
    }
    int insert(char *s) {
        int i = 0, j = 0;
        for (; s[j]; i = ch[i][s[j]], j ++) {
            if (s[j] < 'a') s[j] -= 'A';
            else s[j] -= 'a';
            if (!ch[i][s[j]]) {
                ch[i][s[j]] = ++ sz;
                memset(ch[sz], 0, sizeof(ch[sz]));
            }
        }
        if (!val[i]) val[i] = ++ n;
        return val[i];
    }
} trie;
 
vector<vector<int> >G, W;
queue<int> Q;
int d[maxn];
bool mark[maxn];
 
bool relax(int u, int v, int w) {
    if (d[v] > d[u] + w) {
        d[v] = d[u] + w;
        return true;
    }
    return false;
}
 
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif // ONLINE_JUDGE
    int m;
    char s1[40], s2[40];
    int t;
    while (cin >> m, ~m) {
        n = 0;
        trie.init();
        scanf("%s%s", s1, s2);
        trie.insert(s1);
        t = trie.insert(s2);
        G.clear();
        W.clear();
        G.resize(maxn + 2);
        W.resize(maxn + 2);
        for (int i = 0; i < m; i ++) {
            int x;
            scanf("%s%s%d", s1, s2, &x);
            int u = trie.insert(s1), v = trie.insert(s2);
            G[u].push_back(v);
            G[v].push_back(u);
            W[u].push_back(x);
            W[v].push_back(x);
        }
        while (!Q.empty()) Q.pop();
        Q.push(1);
        memset(d, 0x3f, sizeof(d));
        memset(mark, 0, sizeof(mark));
        mark[1] = true;
        d[1] = 0;
        while (!Q.empty()) {
            int h = Q.front(); Q.pop();
            for (int i = 0; i < G[h].size(); i ++) {
                int v = G[h][i], r = relax(h, v, W[h][i]);
                if (!mark[v] && r) {
                    mark[v] = true;
                    Q.push(v);
                }
            }
            mark[h] = false;
        }
        printf("%d\n", d[t] == 0x3f3f3f3f? -1 : d[t]);
    }
    return 0;
}

（3）map + cin :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <map>
using namespace std;
const int maxn = 2e4 +7;
map<string, int> mp;
int n;
vector<vector<int> >G, W;
queue<int> Q;
bool mark[maxn];
int d[maxn];
bool relax(int u, int v, int w) {
    if (d[v] > d[u] + w) {
        d[v] = d[u] + w;
        return true;
    }
    return false;
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif // ONLINE_JUDGE
    string s1, s2, S;
    int x, m;
    while (cin >> m, ~m) {
        cin >> s1 >> s2;
        S = s2;
        n = 1;
        mp.clear();
        G.clear();
        W.clear();
        G.resize(maxn + 2);
        W.resize(maxn + 2);
        if (!mp[s1]) mp[s1] = n ++;
        if (!mp[s2]) mp[s2] = n ++;
        for (int i = 0; i < m; i ++) {
            cin >> s1 >> s2 >> x;
            if (!mp[s1]) mp[s1] = n ++;
            if (!mp[s2]) mp[s2] = n ++;
            G[mp[s1]].push_back(mp[s2]);
            G[mp[s2]].push_back(mp[s1]);
            W[mp[s1]].push_back(x);
            W[mp[s2]].push_back(x);
        }
        while (!Q.empty()) Q.pop();
        Q.push(1);
        memset(d, 0x3f, sizeof(d));
        memset(mark, 0, sizeof(mark));
        mark[1] = true;
        d[1] = 0;
        while (!Q.empty()) {
            int h = Q.front(); Q.pop();
            for (int i = 0; i < G[h].size(); i ++) {
                int v = G[h][i], r = relax(h, v, W[h][i]);
                if (!mark[v] && r) {
                    mark[v] = true;
                    Q.push(v);
                }
            }
            mark[h] = false;
        }
        printf("%d\n", d[mp[S]] == 0x3f3f3f3f? -1 : d[mp[S]]);
    }
    return 0;
}

（4）map + scanf:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <map>
using namespace std;
const int maxn = 2e4 +7;
map<string, int> mp;
int n;
vector<vector<int> >G, W;
queue<int> Q;
bool mark[maxn];
int d[maxn];
bool relax(int u, int v, int w) {
    if (d[v] > d[u] + w) {
        d[v] = d[u] + w;
        return true;
    }
    return false;
}
 
void read_string(string &s) {
    char s0[100];
    scanf("%s", s0);
    s = string(s0);
}
 
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif // ONLINE_JUDGE
    string s1, s2, S;
    int x, m;
    while (cin >> m, ~m) {
        read_string(s1);
        read_string(s2);
        S = s2;
        n = 1;
        mp.clear();
        G.clear();
        W.clear();
        G.resize(maxn + 2);
        W.resize(maxn + 2);
        if (!mp[s1]) mp[s1] = n ++;
        if (!mp[s2]) mp[s2] = n ++;
        for (int i = 0; i < m; i ++) {
            read_string(s1);
            read_string(s2);
            scanf("%d", &x);
            if (!mp[s1]) mp[s1] = n ++;
            if (!mp[s2]) mp[s2] = n ++;
            G[mp[s1]].push_back(mp[s2]);
            G[mp[s2]].push_back(mp[s1]);
            W[mp[s1]].push_back(x);
            W[mp[s2]].push_back(x);
        }
        while (!Q.empty()) Q.pop();
        Q.push(1);
        memset(d, 0x3f, sizeof(d));
        memset(mark, 0, sizeof(mark));
        mark[1] = true;
        d[1] = 0;
        while (!Q.empty()) {
            int h = Q.front(); Q.pop();
            for (int i = 0; i < G[h].size(); i ++) {
                int v = G[h][i], r = relax(h, v, W[h][i]);
                if (!mark[v] && r) {
                    mark[v] = true;
                    Q.push(v);
                }
            }
            mark[h] = false;
        }
        printf("%d\n", d[mp[S]] == 0x3f3f3f3f? -1 : d[mp[S]]);
    }
    return 0;
}

[hdu2112]最短路的更多相关文章

  1. HDU2112 HDU Today 最短路+字符串哈希

    HDU Today Time Limit: 15000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total ...

  2. hdu2112(HDU Today 简单最短路)

    Problem Description 经过锦囊相助,海东集团终于度过了危机,从此,HDU的发展就一直顺风顺水,到了2050年,集团已经相当规模了,据说进入了钱江肉丝经济开发区500强.这时候,XHD ...

  3. Hdu-2112 HDU Today (单源多点最短路——Dijsktra算法)

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=2112 题目大意:给你N个公交车站,起点,终点,各站之间的距离,求起点到终点之间的最短距离.(起点终点相 ...

  4. hdu2112 HDU Today 基础最短路

    这题的关键是把车站的名字转化为点的编号.我用的是map.声明一个map<string,int> st,然后按照字符串出现的次序给st赋值.例如:st[s1]=2;代表这字符串s1出现的次序 ...

  5. bzoj1001--最大流转最短路

    http://www.lydsy.com/JudgeOnline/problem.php?id=1001 思路:这应该算是经典的最大流求最小割吧.不过题目中n,m<=1000,用最大流会TLE, ...

  6. 【USACO 3.2】Sweet Butter（最短路）

    题意 一个联通图里给定若干个点,求他们到某点距离之和的最小值. 题解 枚举到的某点,然后优先队列优化的dijkstra求最短路,把给定的点到其的最短路加起来,更新最小值.复杂度是\(O(NElogE) ...

  7. Sicily 1031: Campus （最短路）

    这是一道典型的最短路问题,直接用Dijkstra算法便可求解,主要是需要考虑输入的点是不是在已给出的地图中,具体看代码 #include<bits/stdc++.h> #define MA ...

  8. 最短路（Floyd）

    关于最短的先记下了 Floyd算法: 1.比较精简准确的关于Floyd思想的表达:从任意节点A到任意节点B的最短路径不外乎2种可能,1是直接从A到B,2是从A经过若干个节点X到B.所以,我们假设maz ...

  9. bzoj1266最短路+最小割

    本来写了spfa wa了 看到网上有人写Floyd过了 表示不开心￣へ￣ 改成Floyd试试... 还是wa ヾ(｡｀Д´｡)原来是建图错了(样例怎么过的) 结果T了 于是把Floyd改回spfa 还 ...

随机推荐

  1. Eclipse Hadoop源码阅读环境

    一.解压hadoop src包到workspace目录.为加快下载jar包的速度,在eclipse的maven设置里将配置文件的路径设置正确,然后配置maven的settings.xml: <m ...

  2. AI vs PS 矢量 VS 位图

    矢量图 AI最大可以放大64000%.不会失真,依然很清晰.原理是不同的点以及点与点之间的路径构成的,不论放大的多大,点在路径在,就可以精确的计算出它的区域.AI中无法直接编辑位图. 位图 代表PS, ...

  3. testNG 常用的注解

    常用注解介绍: @BeforeSuite 在该套件的所有测试都运行在注释的方法之前,仅运行一次 @AftereSuite 在该套件的所有测试都运行在注释方法之后,仅运行一次 @BeforeClass  ...

  4. [linux] linux的top命令参数详解

    简介 top命令是Linux下常用的性能分析工具,能够实时显示系统中各个进程的资源占用状况,类似于Windows的任务管理器. top显示系统当前的进程和其他状况,是一个动态显示过程,即可以通过用户按 ...

  5. AOP-SheepAspect

    转载https://www.cnblogs.com/InCsharp/p/5902133.html SheepAspect 简介以及代码示列: SheepAspect是一个AOP框架为.NET平台,深 ...

  6. 全网最全最细的appium自动化测试环境搭建教程以及appium工作原理

    一.前言 ​ 对于appium自动化测试环境的搭建我相信90%的自学者都是在痛苦中挣扎,在挣扎中放弃,在放弃后又重新开始,只有10%的人,人品比较好,能够很快并顺利的搭建成功.appium 自动化测试 ...

  7. 关于用C-free进行C语言编程在电脑中生成的.exe和.o文件

    在使用C-free进行C语言编程时,程序运行后会自动在电脑文件中生成以.exe和.o为后缀名的文件: 1,生成的.exe文件为系统自动打包完成的应用程序,该程序可直接在其他无C-free环境的电脑上运 ...

  8. 小米Note 10 Lite海外发布 无缘中国市场

    [TechWeb]5月1日消息,昨日晚间,小米Note 10 Lite在海外亮相.小米市场部副总经理臧智渊在微博透露,小米Note 10 Lite 6GB+64GB版售价349欧元(约合人民币2700 ...

  9. 使用3种协议搭建yum仓库

    制作本地yum仓库 开启服务一般要关闭防火墙,selinux之后再reboot ## 方案一:FTP协议------ftp://IP 下载vsftpd---启动vsftpd---ftp://10.0. ...

  10. Javascript基础之-var，let和const深入解析（二）

    你想在在变量声明之前就使用变量?以后再也别这样做了. 新的声明方式(let,const)较之之前的声明方式(var),还有一个区别,就是新的方式不允许在变量声明之前就使用该变量,但是var是可以得.请 ...