題目： UVa - 10557 - XYZZY

題目說明

給一個有向圖，圖上每個點都會有能量值變化量，初始能量值為 100，求是否能從起點 ( 1 號點 ) 走到終點，且過程中能量值不能為 0。

Input： 每組測資第一行為一整數 N，表示有 N 個點，若為 -1 表示結束，後面 N 行依序為每個點的資訊 (1 ~ N)，每行至少有兩個整數，第一個整數表示該點的能量值變化量，後面一個整數表示該點連接到幾個其他的點，後面為該點能連接到的點 ( 單向 )。

Output： 若從起點 ( 1 號點 ) 能走到終點則輸出 "winnable"，否則輸出 "hopeless"。

解題思路

這個解法需要有 Bellman Ford 演算法的概念。

可以將題目轉換為求最大路徑的問題，由於可能會有正環，所以我們需要知道連接在正環的點是否能到達終點，若可以那表示一定能走到終點，因為可以一直在正環走，使能量值無限。

找出圖上能到達終點的點的問題可以轉換成，在反向的圖上，從終點開始走能到達的點。

所以先讀取測資並建圖，同時建一個反向的圖，接著先找出能到達終點的點，之後使用 Bellman Ford，再檢查是否有正環，若沒有則最後判斷到終點的最大路徑和是否大於 0 即可。需要注意的是，由於過程中能量值不能為 0，所以每個點的最大路徑和一開始都設為 0。

參考解法

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
#include <iostream>
#include <algorithm>
#include <vector>
#include <climits>
#include <unordered_set>

using namespace std;

static auto __ = []
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    return 0;
}();

// data
int N;
int energy[101];
int dist[101];
vector<int> G[101];   // 正向圖
vector<int> re[101];  // 反向圖
unordered_set<int> s; // 可以連到終點的點

void init()
{
    s.clear();
    fill(dist, dist + 101, 0);
    fill(G, G + 101, vector<int>());
    fill(re, re + 101, vector<int>());
}

// 從終點往回走 ( 反向圖 )，找出可以到達終點的點
void dfs(int u)
{
    s.insert(u);
    for (auto& v : re[u]) if (!s.count(v)) dfs(v);
}

bool bellman()
{
    // 從 1 開始
    dist[1] = 100;

    // 若不存在正環，則做 n - 1 次後 dist 會儲存 1 到每個點的最大能量走法
    for (int i = 0; i < N - 1; ++i) for (int u = 1; u <= N; ++u) for (auto& v : G[u])
    {
        if (dist[u]) dist[v] = max(dist[u] + energy[v], dist[v]);
    }

    for (int u = 1; u <= N; ++u) for (auto& v : G[u])
    {
        // 若 v 還能變大表示有正環，可以重複走直到能量無限，
        // 所以如果 v 能到達終點，表示一定能走到終點
        if (dist[u] && dist[v] < dist[u] + energy[v])
        {
            if (s.count(v)) return true;
            dist[v] = dist[u] + energy[v];
        }
    }

    return dist[N];
}

int main()
{
    while (cin >> N && N != -1)
    {
        init();

        for (int i = 1; i <= N; ++i)
        {
            int j, tmp;
            cin >> tmp >> j;
            energy[i] = tmp;
            while (j--) cin >> tmp, G[i].push_back(tmp), re[tmp].push_back(i);
        }

        // 找出可以走到終點的點
        dfs(N);

        if (bellman()) cout << "winnable\n";
        else cout << "hopeless\n";
    }
}