MAZE（2019牛客暑期多校训练营（第二场）E，线段树 + 矩阵乘法）

最新推荐文章于 2025-02-07 22:52:24 发布

原创最新推荐文章于 2025-02-07 22:52:24 发布 · 236 阅读

0 ·

CC 4.0 BY-SA版权

-------------基本算法------------- 同时被 3 个专栏收录

44 篇文章

订阅专栏

-------------图论------------

28 篇文章

订阅专栏

线段树

22 篇文章

订阅专栏

本文介绍了一种解决迷宫中特定路径计数问题的方法，通过动态规划与矩阵运算结合，实现了高效的方案数计算，并提供了完整的C++代码实现。

一.题目链接：

MAZE

二.题目大意：

给一个 n × m 大小由{0,1}构成的矩形，Q 次询问.

0 可以走，1 不可以走.

每次走只能向下，左，右方向，且不能走重复的位置.

每次询问有三个整数：q，a，b.

当 q 为 1 时，将点（a，b）取反.

当 q 为 2 时，求出从点（1，a）走到点（n，b）的方案数 % （1e9 +7）.

三.分析：

先考虑一个点的方案数求解.

这里的最后一步为向左，向右或向下.

可推得：包含点（a，b）同行的某一段区间全为 0.

不妨设这段区间为 [l, r]， f[i][j]为从点（1,1）到达（i，j）的方案数.

立即推： $f[i][j] = \sum^{r}_{k = l} f[i - 1][k]$

所以 f[i][j] 是上一行方案数的线性组合.

现在考虑第 i 行各个元素的方案数.

同理可得： $\begin{pmatrix} f[i][1] &f[i][2] &.... &f[i][m] \end{pmatrix}^{T} = A _{i}\begin{pmatrix} f[i -1][1] &f[i - 1][2] &.... &f[i - 1][m] \end{pmatrix}^{T}$

整理可得： $\begin{pmatrix} f[i][1] &f[i][2] &.... &f[i][m] \end{pmatrix}^{T} = A _{i} A _{i -1}... A _{2}\begin{pmatrix} f[1][1] &f[1][2] &.... &f[1][m] \end{pmatrix}^{T}$

其中 $f[1][1]=f[1][2]=...=f[1][m] = 1$

因此，不妨设 $A_{1} = \begin{bmatrix} 1 & ... & 1\\ ...& &...\\ 1& ...& 1 \end{bmatrix}$ ， $A = A_{1}A_{2}...A_{n}$

根据矩阵乘法可知：从点（1，a）到点（n，b）的方案数为 $A_{a,b}$

四.代码实现：

#include <set>
#include <map>
#include <ctime>
#include <queue>
#include <cmath>
#include <stack>
#include <bitset>
#include <vector>
#include <cstdio>
#include <sstream>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#define eps 1e-6
#define lc k * 2
#define rc k * 2 + 1
#define pi acos(-1.0)
#define ll long long int
using namespace std;

const int M = (int)5e4;
const ll mod = (ll)1e9 + 7;
const ll inf = 0x3f3f3f3f3f;

int n, m, Q;
int maze[M + 5][15];

struct node
{
    ll D[15][15];
}tree[M * 4 + 5];

node mul(node a, node b)
{
    struct node c;
    memset(c.D, 0, sizeof(c.D));
    for(int i = 1; i <= m; ++i)
    {
        for(int j = 1; j <= m; ++j)
        {
            for(int k = 1; k <= m; ++k)
            {
                c.D[i][j] = (c.D[i][j] + a.D[i][k] * b.D[k][j] % mod) % mod;
            }
        }   
    }
    return c;
}

void build(int k, int l, int r)
{
    if(l == r)
    {
        for(int i = 1; i <= m; ++i)
        {
            for(int j = i; j <= m && !maze[l][j]; ++j)
                tree[k].D[i][j] = 1;
            for(int j = i; j >= 1 && !maze[l][j]; --j)
                tree[k].D[i][j] = 1;
        }
        return;
    }
    int mid = (l + r) >> 1;
    build(lc, l, mid);
    build(rc, mid + 1, r);
    tree[k] = mul(tree[lc], tree[rc]);
}

void update(int k, int l, int r, int a, int b)
{
    if(l == r && l == a)
    {
        memset(tree[k].D, 0, sizeof(tree[k].D));
        for(int i = 1; i <= m; ++i)
        {
            for(int j = i; j <= m && !maze[l][j]; ++j)
                tree[k].D[i][j] = 1;
            for(int j = i; j >= 1 && !maze[l][j]; --j)
                tree[k].D[i][j] = 1;
        }
        return;
    }
    int mid = (l + r) >> 1;
    if(a <= mid)
        update(lc, l, mid, a, b);
    else
        update(rc, mid + 1, r, a, b);
    tree[k] = mul(tree[lc], tree[rc]);
}

int main()
{
    scanf("%d %d %d", &n, &m, &Q);
    for(int i = 1; i <= n; ++i)
    {
        for(int j = 1; j <= m; ++j)
            scanf("%1d", &maze[i][j]);
    }
    build(1, 1, n);
    int q, a, b;
    while((Q--))
    {
        scanf("%d %d %d", &q, &a, &b);
        if(q == 1)
        {
            maze[a][b] = !maze[a][b];
            update(1, 1, n, a, b);
        }
        else if(q == 2)
        {
            printf("%lld\n", tree[1].D[a][b]);
        }
    }
    return 0;
}