Codeforces 1517D. Explorer Space（思维+DP）

传送门

---

题目大意

给出一个$n\ast m(1\le n,m\le 500)$的棋盘，任意一个点和周围的四个点都有一条无向带权边，现在需要求出所有点向外走$k(1\le k\le 20)$步然后回来的最小路径权值和，每个点以及每条边都可以经过多次。

解题思路

首先四联通的棋盘上，任何一个闭合回路的路径长度一定都是偶数。也就是说如果$k$为奇数那么所有的点一定无解，否则所有的点一定有解。

一个结论：从某点走$k$步得出的最短闭合回路一定是先向外走$\frac{k}{2}$步然后再原路返回。证明：闭合回路不外乎路径重复的闭合回路和路径不重复的闭合回路，若路径不重复的偶数长度的闭合回路是最优解，那么起点到中点的权值和一定等于中点再到起点的权值和，否则我们可以采用其中一半闭合回路重复一次取代原闭合回路得到最优解，因此无论如何最优解一定可以在路径重复的闭合回路中取得。

设$dp[i][j][k]$代表从点$u=(i,j)$出发向外走$k$步的最优解，状态转移方程为 d p [ i ] [ j ] [ k ] = m i n { d p [ x ] [ y ] [ k − 1 ] + w ( u , v ) } , u → v dp[i][j][k] = min\{dp[x][y][k - 1] + w(u, v)\}, u \rightarrow v dp[i][j][k]=min{dp[x][y][k−1]+w(u,v)},u→v，初始时设置$dp[i][j][?]=inf,dp[i][j][0]=0$。

唯一麻烦是存图，我定义$0,1,2,3$分别代表上、右、下、左四个方向，每个点向四个方向的边$g[i][j][0/1/2/3]$和搜索方向数组$d[4][2]$一一对应。

记忆化搜索和正常的循环预处理均可以。

#include <bits/stdc++.h>

using namespace std;
#define ENDL "\n"
typedef pair<int, int> pii;
const int inf = 0x3f3f3f3f;
typedef long long ll;
const int Mod = 1e9 + 7;
const int maxn = 1e6 + 10;

int n, m, k;
int g[505][505][4], dp[505][505][12];
const int d[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};

bool check(int x, int y) {
    if (x <= 0 || y <= 0 || x > n || y > m) return 0;
    return 1;
}

int dfs(int x, int y, int z) {
    if (dp[x][y][z] != inf) return dp[x][y][z];
    if (z == 0) return dp[x][y][z] = 0;
    int &ans = dp[x][y][z];
    for (int i = 0, r, c; i < 4; i++) {
        r = x + d[i][0], c = y + d[i][1];
        if (check(r, c)) ans = min(ans, g[x][y][i] + dfs(r, c, z - 1));
    }
    return ans;
}

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n >> m >> k;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j < m; j++) {
            cin >> g[i][j][1];
            g[i][j + 1][3] = g[i][j][1];
        }
    }
    for (int i = 1; i < n; i++) {
        for (int j = 1; j <= m; j++) {
            cin >> g[i][j][2];
            g[i + 1][j][0] = g[i][j][2];
        }
    }
    if (k & 1) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) cout << "-1" << ' ';
            cout << ENDL;
        }
        return 0;
    }
    k /= 2;
    memset(dp, 0x3f, sizeof dp);
    //记忆化搜索
    // for (int i = 1; i <= n; i++)
    //     for (int j = 1; j <= m; j++) dfs(i, j, k);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++) dp[i][j][0] = 0;
    for (int p = 1; p <= k; p++) {
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++)
                for (int x = 0, r, c; x < 4; x++) {
                    r = i + d[x][0], c = j + d[x][1];
                    if (check(r, c))
                        dp[i][j][p] =
                            min(dp[i][j][p], g[i][j][x] + dp[r][c][p - 1]);
                }
    }

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) cout << dp[i][j][k] * 2 << ' ';
        cout << ENDL;
    }
    return 0;
}