hdu4571 / 2013 ACM-ICPC长沙赛区全国邀请赛 G.Travel in time · Floyd + dp

题解

题意：n个景点m条路，每走过一条路需要花费 $L$ 的时间，每个景点都有对应的满意度 $S_i$ ，访问每个景点需要 $C_i$ 的时间，要求在 $T$ 时间内，选择一些满足满意值严格递增的景点参观（也可以路过不参观，路过没有满意值需求），问从景点 $S$ 到景点 $E$ 的满意度之和最大是多少

我又来补题了…

大致做法：

1. Floyd求出景点到景点之间的最短路
2. 动态规划的方式求最大值，dp前n个点的时间和满意值的最优解，然后通过其他访问的点转移来更新最优解，dp[i][j]表示前i个景点剩余时间为j的最优解
3. 可以看得出来，要使满意度之和最大值，肯定是路径上要访问的景点都去访问才能最大，所以状态转移方程可以抛弃路过的部分，dp[i][k] = max(dp[i][k], dp[j][k + d[u][v] + p[i].c] + p[i].s)
4. 由于起点和终点可以路过，所以要虚拟一个必须经过的超级起点和一个必须经过的超级终点确定dp的初始状态和最终状态
5. 景点按照满意度从小到大排序，超级起点和超级终点可以设置一下，使其永远在两端
6. 注意判重！！两点间可能多条边
7. 点的横纵坐标均从0开始

---

---

#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, m, K, t, s, e;

struct node {
    int s, c, id;
    bool operator<(const node b) const {
        if (s == b.s)return c < b.c;
        return s < b.s;
    }
} p[105];

int d[105][105];
int dp[105][305];//dp[i][j]表示前i个景点剩余时间为j最大的满意度之和
void init() {
    s++;
    e++;
    //Floyd init
    for (int i = 1; i <= n + 2; ++i) {
        for (int j = 1; j <= n + 2; ++j) {
            d[i][j] = (i == j ? 0 : INF);
        }
    }
    memset(dp, -1, sizeof(dp));
}

int main() {
    ios::sync_with_stdio(0);

    int T;
    cin >> T;
    for (int cs = 1; cs <= T; ++cs) {
        printf("Case #%d:\n", cs);
        cin >> n >> m >> t >> s >> e;
        init();
        for (int i = 1; i <= n; ++i) {
            cin >> p[i].c;
            p[i].id = i;
        }
        for (int i = 1; i <= n; ++i) {
            cin >> p[i].s;
        }
        p[n + 1] = {-1, 0, n + 1};//超级起点
        p[n + 2] = {101, 0, n + 2};//超级终点

        for (int i = 1, u, v, w; i <= m; ++i) {
            cin >> u >> v >> w;
            u++;v++;
            d[u][v] = d[v][u] = min(d[u][v], w);
        }

        //先计算景点间的最短路 不包括超级起点和超级汇点
        for (int k = 1; k <= n; ++k) {
            for (int i = 1; i <= n; ++i) {
                for (int j = 1; j <= n; ++j) {
                    d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
                }
            }
        }

        //超级点到各个点的距离
        for (int i = 1; i <= n; ++i) {
            d[n + 1][i] = d[i][n + 1] = d[s][i];
            d[n + 2][i] = d[i][n + 2] = d[e][i];
        }
        d[n + 1][n + 2] = d[n + 2][n + 1] = d[s][e];

        sort(p + 1, p + n + 3);
        
        dp[1][t] = 0;//第一个肯定是超级起点
        for (int i = 1; i <= n + 2; ++i) {
            for (int k = 0; k <= t; ++k) {
                for (int j = 1; j < i; ++j) {
                    int u = p[j].id;
                    int v = p[i].id;//用来查找两点间的最短路
                    int cost = d[u][v] + p[i].c;
                    if (d[u][v] != INF && p[i].s > p[j].s && k + cost <= t && dp[j][k + cost] != -1) {
                        dp[i][k] = max(dp[i][k], dp[j][k + cost] + p[i].s);
                    }
                }
            }
        }

        int ans = 101;
        for (int i = 0; i <= t; ++i) {
            ans = max(ans, dp[n + 2][i]);
        }
        printf("%d\n", ans - 101);//要减去超级终点的满意度
    }
    return 0;
}