POJ 3592 Instantaneous Transference（Tarjan缩点 + 记忆化搜索）

题意：

一辆坦克从 N*M 矩阵的左上角出发，每次往右或往 下走一格，每格可以是 '#' (表示不可以走), '*' 表示传送门，或者是数字，

表示在该格可以获得的值（只能取一次），传送门可以传送到指定位置，你可以选择被传送或者走相邻的格，问坦克可以获得的值的和最大为多少。

思路：

1. 本题是由几个比较基本的问题组合而成的，关键的问题是在于建图，感谢前面几个网络流题目所培养的建图思想。

2. 因为坦克只能往右下角的方向走，所以在满足条件的情况下，可以由 (i, j) 向 (i+1, j) or (i, j+1) 引弧。因为传送门的存在，还可以再引弧。

3. 建图之后，由于传送门的存在可能会存在环，tarjan 算法化环为点，然后在单向图中记忆化搜索便可得出输出结果。

 

#include <iostream>

#include <stack>

#include <vector>

#include <algorithm>

using namespace std;



const int MAXN = 1610;

vector<int> G[MAXN];

vector<int> G1[MAXN];

stack<int> S;

int dfn[MAXN], low[MAXN], sccno[MAXN], sccnum, cflag;

int row, col, F[MAXN], ore[MAXN], w[MAXN];

char map[50][50];



void tarjan(int u) {

    dfn[u] = low[u] = ++cflag;

    S.push(u);

    for (int i = 0; i < G[u].size(); i++) {

        int v = G[u][i];

        if (!dfn[v]) {

            tarjan(v);

            low[u] = min(low[u], low[v]);

        } else if (!sccno[v]) {

            low[u] = min(low[u], dfn[v]);

        }

    }

    if (low[u] == dfn[u]) {

        sccnum += 1;

        int v = -1;

        while (v != u) {

            v = S.top();

            S.pop();

            sccno[v] = sccnum;

            w[sccnum] += ore[v];

        }

    }

}



void findscc(int n) {

    for (int i = 0; i <= n; i++)

        dfn[i] = low[i] = sccno[i] = 0;

    sccnum = cflag = 0;

    for (int i = 1; i <= n; i++)

        if (!dfn[i]) tarjan(i);

}



int dp(int u) {

    if (F[u]) return F[u];

    F[u] = w[u];

    int x = 0;

    for (int i = 0; i < G1[u].size(); i++) {

        int v = G1[u][i];

        x = max(x, dp(v));

    }

    if (x) F[u] += x;

    return F[u];

}



inline int ID(int i, int j) { return i * col + j + 1; }



int main() {

    int cases;

    scanf("%d", &cases);

    while (cases--) {

        scanf("%d%d", &row, &col);



        int n = ID(row - 1, col - 1);

        for (int i = 1; i <= n; i++)

            G[i].clear(), G1[i].clear();



        for (int i = 0; i < row; i++)

            scanf("%s", map[i]);



        for (int i = 0; i < row; i++) {

            for (int j = 0; j < col; j++) {

                if (map[i][j] == '#') continue;

                if (i + 1 < row && map[i+1][j] != '#')

                    G[ID(i, j)].push_back(ID(i+1, j));

                if (j + 1 < col && map[i][j+1] != '#')

                    G[ID(i, j)].push_back(ID(i, j+1));

                ore[ID(i, j)] = map[i][j] - '0';

                if (map[i][j] == '*') {

                    int x, y;

                    scanf("%d%d", &x, &y);

                    if (map[x][y] != '#')

                        G[ID(i, j)].push_back(ID(x, y));

                    ore[ID(i, j)] = 0;

                }

            }

        }

        for (int i = 0; i <= n; i++)

            F[i] = w[i] = 0;

        findscc(n);

        for (int u = 1; u <= n; u++) {

            for (int i = 0; i < G[u].size(); i++) {

                int v = G[u][i];

                if (sccno[u] != sccno[v]) 

                    G1[sccno[u]].push_back(sccno[v]);

            }

        }

        printf("%d\n", dp(sccno[ID(0, 0)]));

    }

    return 0;

}