[USACO15OPEN]回文的路径Palindromic Paths 2.0版

题目描述

农夫FJ的农场是一个N*N的正方形矩阵（2\le N\le 5002≤N≤500），每一块用一个字母作标记。比如说：

ABCD
BXZX
CDXB
WCBA 

某一天，FJ从农场的左上角走到右下角，当然啦，每次他只能往右或者往下走一格。FJ把他走过的路径记录下来。现在，请你把他统计一下，所有路径中，回文串的数量（从前往后读和从后往前读一模一样的字符串称为回文串）。

输入输出格式

输入格式：

第一行包括一个整数N，表示农场的大小，接下来输入一个N*N的字母矩阵。

输出格式：

Please output the number of distinct palindromic routes Bessie can take,

modulo 1,000,000,007.

输出一个整数，表示回文串的数量。

输入输出样例

输入样例#1：

4
ABCD
BXZX
CDXB
WCBA

输出样例#1：

12
题解：动态规划
设f[i][j][k]为起点开始竖方向向下走到i，横向走到j，从终点向上走到k，可知l=i+j-k
f[i][j][k]->f[i+1][j][k]&f[i][j+1][k]&f[i+1][j][k+1]&f[i][j+1][k+1](颜色相同)
最后答案就是i+j=n时的最大值
时空间复杂度都是O(n^3)但还有优化
可以把第一维换成步数，f[i][j][k]表示走i步，向下到i，向上到k
f[i][j][k]->f[i+1][j+1][k]&f[i+1][j+1][k+1]&f[i+1][j][k+1]&f[i+1][j][k]
用滚动数组消去一个n
此题巨坑，时间卡的紧，多谢YZD大佬指点才过
要点：若f[now][j][k]=0就不转移

还有一个超级玄学优化，将滚动数组的第一位放到第三维，每次开始前不清空f[][][nxt],改为在i<n时，转移后将
f[][][now]清空。比原来快1000ms

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<iostream>
 using namespace std;
 typedef long long lol;
 int Mod=;
 lol f[][][];
 int now,nxt,n,m;
 lol ans;
 char a[][];
 void get(int i)
 {
     int x=;
     char ch=getchar();
     while (ch<'A'||ch>'Z') ch=getchar();
     while (ch>='A'&&ch<='Z')
     {
         x++;
         a[i][x]=ch;
         ch=getchar();
     }
 }
 int main()
 {
     register int i,j,k;
     //freopen("b.in","r",stdin);
     //freopen("b.out","w",stdout);
     cin>>n;
     m=n;
     for (i=; i<=n; i++)
     {
         get(i);
     }
     if (a[][]!=a[n][m])
     {
         cout<<<<endl;
         return ;
     }
     f[][n][]=;
     now=;
     nxt=;
     for (i=; i<=n; i++)
     {
         swap(now,nxt);
         for (j=; j<=i; j++)
         {int b=n-i+;
             for (k=n; k>=b; k--)
             if(f[j][k][now])
             {
                 int y1=i-j+,y2=m-i+n-k+;
                 //printf("%d %d %d %d %d\n",i,j,y1,k,y2);
                 f[j][k][now]%=Mod;
                 if (j+<=n&&k->=&&a[j+][y1]==a[k-][y2])
                     f[j+][k-][nxt]+=f[j][k][now];

                 if (j+<=n&&y2->=&&a[j+][y1]==a[k][y2-])
                     f[j+][k][nxt]+=f[j][k][now];

                 if (y1+<=m&&k->=&&a[j][y1+]==a[k-][y2])
                     f[j][k-][nxt]+=f[j][k][now];

                 if (y1+<=m&&y2->=&&a[j][y1+]==a[k][y2-])
                     f[j][k][nxt]+=f[j][k][now];
                 if (i<n)
                 f[j][k][now]=;
             }
         }
     }
     for (i=; i<=n; i++)
         ans=(ans+f[i][i][now])%Mod;
     cout<<ans%Mod;
 }