AtCoder-abc265_f Manhattan Cafe

Manhattan Cafe#

dp 前缀和优化

很容易想到 $dp$ 的状态

$dp[i][j][k]$ 表示前 $i$ 个点，$r_x$ 与 $p_x$ 的差值和为 $j$，$r_x$ 与 $q_x$ 的差值和为 $k$

这样的话直接枚举第 $i$ 组点中，我们取的点的位置，能够做到 $O(D)$ 的复杂度转移

总的时间复杂度为 $O(nD^3)$，显然超时

考虑转移的时间进行优化，我们会发现选取的位置不同，会有不同的规律，假设 $p_i = 1$，$q_i = 4$

如果选取的点 $r_i$ 在 $[1， 4]$，那么 $|p_i-x_i|+|q_i-x_i| = |p_i - q_i|$，也就是 $dp[i][j][k] = \sum dp[i-1][j-x][k-y],$ $x+y=|p_i - q_i|$，此时一定是从一个 $j'+k'$ 为定值的之前的状态转移过来，这个定值就是 $j+k-|p_i-q_i|$

如果选取的点在 $[1, 4]$ 之外，那么与上一个转移相反，这种是从满足 $j'-k'$ 为定值的状态转移过来，这个定值就是 $|p_i-q_i|$

上述转移文字可能不清楚，可以自己列表格，对每个离散点判断一下他应该从什么状态转移过来，就可以理解

因此考虑做两个对角线前缀和，每次 $O(1)$ 转移

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
const int maxn = 1e3 + 10;
typedef long long ll;
const ll mod = 998244353;
ll dp[maxn][maxn], dig[maxn][maxn], a_dig[maxn][maxn];

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, d;
    cin >> n >> d;
    vector<int>q(n), p(n);
    for(int i=0; i<n; i++) cin >> q[i];
    for(int i=0; i<n; i++) cin >> p[i]; 
    dp[0][0] = 1;
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<=d; j++)
        {
            for(int k=0; k<=d; k++)
            {
                dig[j][k] = a_dig[j][k] = dp[j][k];
                if(j && k < d)
                    dig[j][k] += dig[j - 1][k + 1];
                if(j && k)
                    a_dig[j][k] += a_dig[j - 1][k - 1];
            }
        }
        for(int j=0; j<=d; j++)
        {
            for(int k=0; k<=d; k++)
            {
                int s = abs(p[i] - q[i]);
                dp[j][k] = 0;
                if(k + j >= s)
                {
                    int l = max(0, j - s), r = k + j - s - max(0, k - s);
                    if(l == 0) dp[j][k] += dig[r][k - s + j - r];
                    else dp[j][k] += dig[r][k - s + j - r] - dig[l - 1][k - s - l + j + 1];
                }
                if(k > s && j)
                    dp[j][k] += a_dig[j - 1][k - 1 - s];
                if(j > s && k)
                    dp[j][k] += a_dig[j - 1 - s][k - 1];
                dp[j][k] %= mod;
            }
        }
    }
    ll ans = 0;
    for(int i=0; i<=d; i++)
        for(int j=0; j<=d; j++)
            ans += dp[i][j];
    cout << ans % mod << endl;
    return 0;
}