带权最短路 51Nod - 1459 - 迷宫游戏

这是我在51nod上做的第一道基础题目.
让我感受到了自己的菜…
思路很清晰,写出来就1w个bug
最后读了大佬的题解才明白
水平还是不行啊..继续努力!

---

1459 迷宫游戏

基准时间

限制：1 秒 空间限制：131072 KB 分值: 0 难度：基础题
你来到一个迷宫前。该迷宫由若干个房间组成，每个房间都有一个得分，第一次进入这个房间，你就可以得到这个分数。还有若干双向道路连结这些房间，你沿着这些道路从一个房间走到另外一个房间需要一些时间。游戏规定了你的起点和终点房间，你首要目标是从起点尽快到达终点，在满足首要目标的前提下，使得你的得分总和尽可能大。现在问题来了，给定房间、道路、分数、起点和终点等全部信息，你能计算在尽快离开迷宫的前提下，你的最大得分是多少么？

Input

第一行4个整数n (<=500), m, start, end。n表示房间的个数，房间编号从0到(n - 1)，m表示道路数,任意两个房间之间最多只有一条道路，start和end表示起点和终点房间的编号。
第二行包含n个空格分隔的正整数(不超过600)，表示进入每个房间你的得分。
再接下来m行，每行3个空格分隔的整数x, y, z (0< z < =200)表示道路,表示从房间x到房间y(双向)的道路,注意，最多只有一条道路连结两个房间, 你需要的时间为z。
输入保证从start到end至少有一条路径。

Output

一行，两个空格分隔的整数，第一个表示你最少需要的时间，第二个表示你在最少时间前提下可以获得的最大得分。

Input示例

3 2 0 2
1 2 3
0 1 10
1 2 11

Output示例

21 6

---

思路

从题意中很容易得出这是一道最短路径题目,只是稍微变形,加了一个权值
题目要求就是:在最短路径的情况下,得分总和尽可能大
自然而然的想到了,存在多个最短路径的情况,我要做的就是加一个判断,路径相等的情况下,选择权值最大的路径.

---

代码一

#include<iostream>
#include<string>
#include<algorithm>
#include<map>


using namespace std;

const int INF = 0x3f3f3f3f;
int n, m, Start, End;
int score[500];
int Map[500][500];
int dis[500];
bool vis[500];
int x, y, z;
int goal[500];
/*
3 2 0 2
1 2 3
0 1 10
1 2 11
*/
void dijkstra(int sta) {
    goal[sta] = score[sta];
    for (int i = 0; i < n; i++) {
        if (Map[Start][i] < INF)
            goal[i] = goal[Start] + score[i];
        dis[i] = Map[Start][i];
    }


    vis[sta] = 1;
    dis[sta] = 0;

    for (int j = 0; j < n; j++) {
        int min = INF,v = 0;
        for (int i = 0; i < n; i++)
            if (!vis[i] && dis[i] < min)
                min = dis[i], v = i;

        vis[v] = 1;
        for (int i = 0; i < n; i++)
            if (!vis[i] && dis[v] != INF&&Map[v][i]) {
                if (dis[v] + Map[v][i] < dis[i]) {
                    dis[i] = dis[v] + Map[v][i];
                    goal[i] = goal[v] + score[i];
                }
                else if (dis[v] + Map[v][i] == dis[i]
                    && goal[v] + score[i] > goal[i]) {
                    goal[i] = goal[v] + score[i];
                }

            }
    }
}

int main() {
    cin >> n >> m >> Start >> End;
    for (int i = 0; i < n; i++)
        cin >> score[i];
    memset(Map, 0x3f3f3f, sizeof(Map));
    for (int i = 0; i < m; i++) {
        cin >> x >> y >> z;
        Map[y][x] = Map[x][y] = z;
    }
    dijkstra(Start);
    cout << dis[End] << " " << goal[End] << endl;
}

代码2

完全理解了之后,
重写了一遍
改了改部分代码
添加了模板的注释

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;

const int INF = 0x3f3f3f3f; //无穷大
const int MAXN = 1010;      //数组大小

int n;                      //节点数 nodes num
bool vis[MAXN];             //标记是否被访问 if visited
int pre[MAXN];              //走过的路径 path of visiting
int dis[MAXN];              //最短路径 lowcost

int Graph[MAXN][MAXN];      //图

int score[MAXN];            //用于记录每个点的分数
void Dij(int sta/*start*/)
{
    //To initialize the dis[],vis[] and pre[]
    for (int i = 0; i < n; i++)
    {
        dis[i] = INF;
        vis[i] = false;
        pre[i] = 0;
    }
    pre[sta] = score[sta];
    dis[sta] = 0;//set the begin
    for (int j = 0; j < n; j++)
    {
        int k = -1;
        int min = INF;
        for (int i = 0; i < n; i++)
        {
            //select the no visited min from the dis[]
            //after the initialization the dis[] equals INF
            //the begin num is dis[sta]
            if (!vis[i] && dis[i] < min)
            {
                min = dis[i];
                k = i;
            }
        }

        if (k == -1)
        {
            //all the nodes are visited(expanded)
            break;
        }
        vis[k] = true;//sign the node

        //expand the node
        for (int i = 0; i < n; i++)
        {
            if (!vis[i]) {
                //if the no visited node's (dis to i) > (dis to k + direct path of k to i)
                //we find the less route
                if (dis[i] > dis[k] + Graph[k][i])
                {
                    //update the dis
                    dis[i] = dis[k] + Graph[k][i];
                    //record the node
                    pre[i] = pre[k]+score[i];
                }
                else if (dis[i] == dis[k] + Graph[k][i])
                {
                    pre[i] = pre[i] > pre[k] + score[i] ? pre[i] : pre[k] + score[i];
                }
            }
        }
    }
}
int main()
{
    int m, Start, End;
    int x, y, z;
    cin >> n >> m >> Start >> End;
    for (int i = 0; i < n; i++)
        cin >> score[i];

    memset(Graph, 0x3f3f3f, sizeof(Graph));
    for (int i = 0; i < m; i++) {
        cin >> x >> y >> z;
        Graph[y][x] = Graph[x][y] = z;
    }
    Dij(Start);
    cout << dis[End] << " " << pre[End] << endl;
}

代码3

再来一遍…
增加了多组输入情况的初始化.
减少了一丢丢计算次数.

#include <iostream>
#include <cstring>
using namespace std;

const int INF = 0x3f3f3f3f;
const int MAXN = 1010;

bool vis[MAXN];
int Graph[MAXN][MAXN], dis[MAXN], score[MAXN], goal[MAXN];
int n, m;

void dijk(int sta)
{
    memset(dis, INF, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    memset(goal, 0, sizeof(goal));
    goal[sta] = score[sta];
    dis[sta] = 0;

    for (int j = 0; j < n; ++j) {
        int min = INF, u = -1;
        for (int i = 0; i < n; ++i)
            if (!vis[i] && dis[i] < min)
                min = dis[i], u = i;

        if (u < 0)break;

        vis[u] = true;

        int disui, goalui;
        for (int i = 1; i < n; ++i) {
            disui = dis[u] + Graph[u][i];
            if (!vis[i] && !(dis[i] < disui)) {
                goalui = goal[u] + score[i];
                if (dis[i] > disui)
                    dis[i] = disui, goal[i] = goalui;
                else
                    goal[i] = goal[i] > goalui ? goal[i] : goalui;
            }
        }
    }
}
int main()
{
    int m, Start, End;
    int x, y, z;
    cin >> n >> m >> Start >> End;
    for (int i = 0; i < n; i++)
        cin >> score[i];

    memset(Graph, 0x3f3f3f, sizeof(Graph));
    for (int i = 0; i < m; ++i) {
        cin >> x >> y >> z;
        Graph[y][x] = Graph[x][y] = z;
    }
    dijk(Start);
    cout << dis[End] << " " << goal[End] << endl;
}