Zero Path

最新推荐文章于 2026-01-02 10:17:02 发布

原创最新推荐文章于 2026-01-02 10:17:02 发布 · 263 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#动态规划 #算法

该博客讨论了如何使用动态规划解决一个关于在含有-1和1的矩阵中从左上角走到右下角，路径和可能为0的问题。作者提出了两种不同的DP解决方案，一种是通过bitset进行空间优化，另一种是寻找最小值和最大值来判断0是否可达。这两种方法都涉及到对路径和的连续变化性质的利用。

Zero Path

Problem - C - Codeforces

题意

给你一个 $n\times m$ 的只含 $- 1/1$ 的矩阵，每次只能向右或向下走，问你从左上角走到右下角的路径权值和是否可能为 $0$

思路

$d p$

有一个暴力 $d p$ 的想法设 $f [i] [j]] [k]$ ：表示走到 $(i, j)$ 且和为 $k$ 的情况，但是空间太大时间也太复杂了，这个时候可以用到 $bi t se t$ 来优化以下用每一位来表示一个数，这个时候如果开数组还是空间还是太大了，因此仿照背包优化的方法，我们把 $i$ 这一维砍去，即从前往后枚举 $j$ 的时候每次先向 $(i, j + 1)$ 转移再向 $(i + 1, j)$ 转移，这样就能保证每次操作的时候都是前一维的状态了，时间复杂度会砍 $1/30$ 左右，因此暴力可过了

Code

降维

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 1e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
    e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
int d = 2001;
int a[1010][1010];
bitset<4020> f[1010];
int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    int T;
    cin >> T;
    while (T -- ) {
        cin >> n >> m;
        for (int i = 1; i <= n; i ++) 
            for (int j = 1; j <= m; j ++)
                cin >> a[i][j];
        for (int i = 1; i <= m; i ++)  f[i].reset();
        f[1][d+a[1][1]] = true;
        for (int i = 1; i <= n; i ++)
            for (int j = 1; j <= m; j ++) {
                if (j + 1 <= m) {
                    if (a[i][j + 1] == -1) f[j + 1] |= (f[j] >> 1);
                    else f[j + 1] |= (f[j] << 1);
                }
                if (i + 1 <= n) {
                    if (a[i + 1][j] == -1) f[j] >>= 1;
                    else f[j] <<= 1;
                }
            }

        cout << (f[m][d] ? "YES" : "NO") << '\n';                
    }
    return 0;
}

如果你在里边开二维 $v ec t or$ 的话是不会爆空间的

思路

思维， $d p$

考虑首先 $n + m - 1$ 一定是个偶数，否则 $+ 1, - 1$ 不可能变成零，我们 $d p$ 出左上角到右下角的最小值和最大值，如果 $0$ 在它们中间就一定有解，因为对于最大值你每次扭以下路径要不不变要不减小中间一定会减到 $0$ ，换句话说类似于零点定理，由于我们的值是连续变化的，因此 $0$ 如果在最大值和最小值之间，则一定有一种方法变成 $0$

Code

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 1e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
    e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
int d = 2001;
int a[1010][1010];
int b[1010][1010], c[1010][1010];

int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    int T;
    cin >> T;
    while (T -- ) {
        cin >> n >> m;
        for (int i = 1; i <= n; i ++) 
            for (int j = 1; j <= m; j ++)
                cin >> a[i][j], b[i][j] = c[i][j] = 0;

       
        if ((n + m - 1) & 1) {
			cout << "NO\n";
			continue ;
		}
        for (int i = 1; i <= n; i ++)
            for (int j = 1; j <= m; j ++) {
                if (a[i][j] == -1) {
                    b[i][j] += max(b[i - 1][j], b[i][j - 1]) + 1;
                    c[i][j] += max(c[i - 1][j], c[i][j - 1]);
                }
                else {
                    b[i][j] += max(b[i - 1][j], b[i][j - 1]);
                    c[i][j] += max(c[i - 1][j], c[i][j - 1]) + 1;
                }                
            }
 
        if (b[n][m] >= (n + m - 1) / 2 && c[n][m] >= (n + m - 1) / 2) cout << "YES\n";
        else cout << "NO\n";                        
    }
    return 0;
}