jzoj 4019. 【雅礼联考DAY02】Path dp

Description

给定一个 n∗ m 的网格，你在左下角 (n,1)，你只能往前走或者右拐，障碍和走过的点不能走。求走到 (y,x) 的方案数 mod k 的值。

Input

第一行输入 n,m,k (n,m ≤ 100,k ≤ 10^9 )。第二行输入 x,y，意这里是x 列 y 行，以下 n 行 m 行的字符矩阵 + 表示可以走， * 表示障碍。

Output

输出一个数，表示方案数 mod k 的值。

Sample Input

3 5 10
4 2
+++++
++*++
++++*

Data Constraint

n,m ≤ 100,k ≤ 10^9.

分析：
好神奇的一道题。
设$f[p][i][j][k][l]$为左上角为$(i,j)$，右下角为$(k,l)$，不走出这个矩阵，方向为p的方案数。

若$p=0$，则是以左上角为起点，右方向为正方向；若$p=1$，则以右上角为起点，下方向为正方向；若$p=2$，则以右下角为起点，左方向为正方向；若$p=3$，则以左下角角为起点，上方向为正方向。

左图为从$p=0$方向开始的一种走法。

先无视障碍，考虑转移：
如右图，显然我们可以在蓝色区域的任意一点右转，方案数即为下面橙色区域的方案数。因为我们要求不走出矩形，所以在第一个位置右转的矩形为$(x_1+1,y_1,x_2,y_1)$，最右边的矩形为$(x_1+1,y_1,x_2,y_2)$。而我们右转后相当于以方向$p=1$（右上角下方向）进入橙色矩阵。

即有，

$$f[0][i][j][k][l]=\sum_{t=j}^{l}f[1][i+1][j][k][t]$$

这样的复杂度为$O(n^5)$。显然不行。

然后我们发现这样太暴力了，没有利用好所有的状态。

我们发现$f[0][i][j][k][l-1]=\sum_{t=j}^{l-1}f[1][i+1][j][k][t]$，只需要在他的基础上加上$f[1][i+1][j][k][l]$即可转移，不需要枚举$t$。

即，

$$f[0][i][j][k][l]=f[0][i][j][k][l-1]+f[1][i+1][j][k][l]$$

对于其他3个方向同样推导。

时间复杂度变为$O(n^4)$，但是空间上还是达到了$O(n^4)$。

我们发现，每次的状态转移都是从少一行或少一列的矩阵转移过来的，所以可以设一维状态为行和列的和，状态变为，$f[p][d][i][j][k]$表示方向为$p$，行和列的长度和为$d$，左上角为$(i,j)$，右下角为$(k,d+i+j-k)$的方案数。然后$d$这一维就可以滚动了。

至于有障碍，那就要保证在转弯前走的那段路上没有障碍，即dp式要在满足$(i,j)$到$(i,l)$没有障碍，否则$f[1][i+1][j][k][l]$就没有贡献。

对于$p=0$来说，我们计算时要判断$(i,l)$是不是终点，是就+1就可以了。

时间复杂度为$O(n^4)$，空间复杂度为$O(n^3)$。

代码：

#include <iostream>
#include <cstdio>
#include <cmath>

const int maxn=101;

using namespace std;

int n,m,x,y;
int f[2][maxn][maxn][maxn][4];
int p;
int lef[maxn][maxn],up[maxn][maxn];

int gett()
{
    int c;
    while(c=getchar(), c<=32);
    return c=='*';
}

void init()
{
    char s[107],ch;
    scanf("%d%d%d\n",&n,&m,&p);
    scanf("%d%d\n",&y,&x);
    for (int i=1;i<=n;i++)
    {
        for (int j=1;j<=m;j++)
        {
            int c=gett();
            lef[i][j]=lef[i][j-1]+c;
            up[i][j]=up[i-1][j]+c;
        }
    }   
}

int main()
{
    init();         
    int g=0;    
    for (int d=0;d<=n+m-2;d++)
    {       
        for (int i=x;(i>0) && (x-i)<=d;i--)
        {
            for (int j=y;(j>0) && ((x-i)+(y-j)<=d);j--)
            {
                for (int k=x;(k<=n) && ((k-i)+(y-j)<=d);k++)
                {                   
                    int l=d+i+j-k;
                    if (l>m) continue;
                    f[g^1][i][j][k][0]=f[g][i][j][k][0]+(lef[i][l]==lef[i][j-1])*f[g][i+1][j][k][1];
                    f[g^1][i][j][k][1]=f[g][i][j][k-1][1]+(up[k][l]==up[i-1][l])*f[g][i][j][k][2];
                    f[g^1][i][j][k][2]=f[g][i][j+1][k][2]+(lef[k][l]==lef[k][j-1])*f[g][i][j][k-1][3];
                    f[g^1][i][j][k][3]=f[g][i+1][j][k][3]+(up[k][j]==up[i-1][j])*f[g][i][j+1][k][0]; 
                    f[g^1][i][j][k][0]+=((i==x) && (l==y) && (lef[i][l]==lef[i][j-1]));
                    f[g^1][i][j][k][1]+=((k==x) && (l==y) && (up[k][l]==up[i-1][l]));
                    f[g^1][i][j][k][2]+=((k==x) && (j==y) && (lef[k][l]==lef[k][j-1]));
                    f[g^1][i][j][k][3]+=((i==x) && (j==y) && (up[k][j]==up[i-1][j]));
                    for (int r=0;r<4;r++)
                    {
                        f[g^1][i][j][k][r]%=p;
                    }
                }
            }
        }
        g^=1;
    }
    printf("%d",f[g][1][1][n][3]);
}