HDU 5576 Expection of String (DP, 前缀和维护) 2015年上海现场赛E题

题目大意：

就是现在给出一个串, 只包含一个*号, 表示乘法, 剩下的是数字

于是对于这个乘法式子, 当*某一边没有数字的时候视为那一侧的数字是0

现在进行K次操作, 每次操作随机选择两个不同的位置交换

为最后表达式的值的期望, 乘上(C[n][2])^K的结果, n是串的长度, 结果对于10^9 + 7取模

大致思路：

这个可能的状态表示是从学长那边听到的...然后当了一下小白鼠推了一下...然后发现可以用前缀和优化复杂度说不定能过...然后居然真的AC了....

用dp[i][j][a][b]表示当前进行了i次变换, *在j位置, a位置乘上b位置的数(不看是什么位, 只看两个数字相乘的结果)的所有可能情况的和

处理前将*位置与其他数的乘积视为0

那么转移方程式可以分类讨论出来....这个递推式写在代码注释里了...

受到内存限制改了几次...不过递推式的原型也保留在代码里了

时间复杂度O(K*n^3)

不过这个代码交C++ TLE了... G++ 1.7sAC, 应该有更好的解法

代码如下：

Result  :  Accepted     Memory  :  36640 KB     Time  :  1747 ms

/*
 * Author: Gatevin
 * Created Time:  2015/11/28 19:01:07
 * File Name: Yukinoshita_Yukino.cpp
 */
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;

/*
 * 用dp[i][j][a][b]表示当前进行了i次变换, *出现在j位置, 第a位置与第b位置上的数可能乘积的和
 * 初始化dp[0][center][a][b] = s[a]*s[b], center是*开始的位置, 当a或者b与center相同时视为0
 * 转移时, 考虑dp[i][j][a][b]:
 * 当j, a, b互不相同时
 * dp[i][j][a][b] =     dp[i - 1][j][a][b]*C[n - 3][2] //取j, a, b以外的位置交换
 *                  +   dp[i - 1][j][a][b]             //取位置a, b交换
 *                  + ∑dp[i - 1][j][a][x]             //取位置x, b交换, x != b && x != a && x != j
 *                  + ∑dp[i - 1][j][x][b]             //取位置x, a交换, x != a && x != b && x != j
 *                  + ∑dp[i - 1][k][a][b]             //取位置k, j交换, k != j && k != a && k != b
 *                  +   dp[i - 1][a][j][b]             //取位置a, j交换
 *                  +   dp[i - 1][b][a][j]             //取位置b, j交换
 * 当j == a时
 * dp[i][j][j][b] =     dp[i - 1][j][j][b]*C[n - 2][2] //取位置j, b以外的位置交换
 *                  + ∑dp[i - 1][j][j][x]             //取位置x与b交换 x != b && x != j
 *                  + ∑dp[i - 1][x][x][b]             //取位置x与j交换 x != b && x != j
 *                  +   dp[i - 1][b][b][j]             //取位置b与j交换 b != j
 * 当j == b时同j == a类似只是b换成a而已
 * 在求出dp[K][1~n][1~n][1~n]之后根据乘号的位置判断合理性就可以计算最后的答案
 * 然后由于直接计算时O(Kn^4), 考虑到可以使用前缀和维护, 时间复杂度降低到O(Kn^3)
 */

const lint mod = 1e9 + 7;
const int MOD = 1e9 + 7;
char s[100];
int K, n;
int dp[55][55][55][55];
int sum[55][55][55][3];//sum最后一维的0, 1, 2分别表示三种不同的前缀和
int S[55][55][2];//S最后一维的2也是前缀和
//原本sum和S数组都是要再多一维55的, 由于内存限制以及那一维只需要使用n就省去了

lint C[55][55];
lint ten[55];

void Add(int& x, int val)
{
    x += val;
    if(x >= MOD) x -= MOD;
}

int Mod(int x)
{
    if(x >= MOD) return x - MOD;
    return x;
}

void init()
{
    C[0][0] = 1;
    for(int i = 1; i <= 50; i++)
    {
        C[i][0] = C[i][i] = 1;
        for(int j = 1; j < i; j++)
        {
            C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
            if(C[i][j] >= mod) C[i][j] -= mod;
        }
    }
    
    ten[0] = 1;
    for(int i = 1; i < 55; i++)
        ten[i] = ten[i - 1]*10LL % mod;
}

int main()
{
    int T;
    scanf("%d", &T);
    init();
    for(int cas = 1; cas <= T; cas++)
    {
        scanf("%d", &K);
        scanf("%s", s + 1);
        n = strlen(s + 1);
        if(n == 1 && s[1] == '*')//s = "*"
        {
            printf("Case #%d: 0\n", cas);
            continue;
        }
        //memset(dp, 0, sizeof(dp));
        //memset(sum, 0, sizeof(sum));
        for(int i = 0; i <= n; i++)
        {
            memset(dp[i], 0, sizeof(dp[i]));
            memset(sum[i], 0, sizeof(sum[i]));
            memset(S[i], 0, sizeof(S[i]));
        }
        
        int center = -1;
        for(int i = 1; i <= n; i++)
            if(s[i] == '*')
            {
                center = i;
                s[i] = '0';
                break;
            }
        for(int i = 1; i <= n; i++)
            for(int j = i + 1; j <= n; j++)
            {
                dp[0][center][i][j] += (s[i] - '0')*(s[j] - '0');
                dp[0][center][j][i] += (s[i] - '0')*(s[j] - '0');
            }
        for(int j = 1; j <= n; j++)
            for(int a = 1; a <= n; a++)
                for(int b = 1; b <= n; b++)
                    //sum[0][j][a][b][2] = sum[0][j][a][b - 1][2] + dp[0][j][a][b];
                    sum[0][j][a][2] += dp[0][j][a][b];
        
        for(int j = 1; j <= n; j++)
            for(int b = 1; b <= n; b++)
                for(int a = 1; a <= n; a++)
                    //sum[0][j][a][b][1] = sum[0][j][a - 1][b][1] + dp[0][j][a][b];
                    sum[0][j][b][1] += dp[0][j][a][b];
        
        for(int a = 1; a <= n; a++)
            for(int b = 1; b <= n; b++)
                for(int j = 1; j <= n; j++)
                    //sum[0][j][a][b][0] = sum[0][j - 1][a][b][0] + dp[0][j][a][b];
                    sum[0][a][b][0] += dp[0][j][a][b];
        
        for(int b = 1; b <= n; b++)
            for(int j = 1; j <= n; j++)
                //sum[0][j][j][b][3] = sum[0][j - 1][j - 1][b][3] + dp[0][j][j][b];
                S[0][b][0] = S[0][b][0] + dp[0][j][j][b];
        for(int a = 1; a <= n; a++)
            for(int j = 1; j <= n; j++)
                //sum[0][j][a][j][4] = sum[0][j - 1][a][j - 1][4] + dp[0][j][a][j];
                S[0][a][1] = S[0][a][1] + dp[0][j][a][j];
        
        
        for(int i = 1; i <= K; i++)
            for(int j = 1; j <= n; j++)
            {
                for(int a = 1; a <= n; a++)
                    for(int b = 1; b <= n; b++)
                    {
                        if(j != a && j != b && a != b)
                        {
                            Add(dp[i][j][a][b], (int)(dp[i - 1][j][a][b]*C[n - 3][2] % mod));
                            Add(dp[i][j][a][b], dp[i - 1][j][a][b]);
                            
                            //Add(dp[i][j][a][b], dp[i - 1][j][a][x]);//x != j, a, b
                            Add(dp[i][j][a][b], (int)(((lint)sum[i - 1][j][a][2] - dp[i - 1][j][a][a] - dp[i - 1][j][a][b] - dp[i - 1][j][a][j] + 3LL*mod) % mod));
                            
                            //Add(dp[i][j][a][b], dp[i - 1][j][x][b]);//x != j, a, b
                            Add(dp[i][j][a][b], (int)(((lint)sum[i - 1][j][b][1] - dp[i - 1][j][j][b] - dp[i - 1][j][a][b] - dp[i - 1][j][b][b] + 3*mod) % mod));
                            
                            //Add(dp[i][j][a][b], dp[i - 1][k][a][b]);//k != j, a, b
                            Add(dp[i][j][a][b], (int)(((lint)sum[i - 1][a][b][0] - dp[i - 1][j][a][b] - dp[i - 1][a][a][b] - dp[i - 1][b][a][b] + 3*mod) % mod));
                            
                            Add(dp[i][j][a][b], dp[i - 1][a][j][b]);
                            Add(dp[i][j][a][b], dp[i - 1][b][j][a]);
                        }
                        if(j == a && a != b)
                        {
                            Add(dp[i][j][j][b], (int)(dp[i - 1][j][j][b]*C[n - 2][2] % mod));
                            
                            //Add(dp[i][j][j][b], dp[i - 1][j][j][x]); // x != b && x != j
                            Add(dp[i][j][j][b], (int)(((lint)sum[i - 1][j][j][2] - dp[i - 1][j][j][b] - dp[i - 1][j][j][j] + 2*mod) % mod));
                            
                            //Add(dp[i][j][j][b], dp[i - 1][x][x][b]); // x != b && x != j
                            Add(dp[i][j][j][b], (int)(((lint)S[i - 1][b][0] - dp[i - 1][b][b][b] - dp[i - 1][j][j][b] + 2*mod) % mod));
                            
                            Add(dp[i][j][j][b], dp[i - 1][b][b][j]);
                        }
                        if(j == b && a != b)
                        {
                            Add(dp[i][j][a][j], (int)(dp[i - 1][j][a][j]*C[n - 2][2] % mod));
                            
                            //Add(dp[i][j][a][j], dp[i - 1][j][x][j]); // x != b && x != j
                            Add(dp[i][j][a][j], (int)(((lint)sum[i - 1][j][j][1] - dp[i - 1][j][b][j] - dp[i - 1][j][j][j] + 2*mod) % mod));
                            
                            //Add(dp[i][j][a][j], dp[i - 1][x][a][x]); // x != b && x != j
                            Add(dp[i][j][a][j], (int)(((lint)S[i - 1][a][1] - dp[i - 1][b][a][b] - dp[i - 1][j][a][j] + 2*mod) % mod));
                            
                            Add(dp[i][j][a][j], dp[i - 1][a][j][a]);
                        }
                        /*
                        sum[i][j][a][b][2] = Mod(sum[i][j][a][b - 1][2] + dp[i][j][a][b]);
                        sum[i][j][a][b][1] = Mod(sum[i][j][a - 1][b][1] + dp[i][j][a][b]);
                        sum[i][j][a][b][0] = Mod(sum[i][j - 1][a][b][0] + dp[i][j][a][b]);
                        */
                        sum[i][j][a][2] = Mod(sum[i][j][a][2] + dp[i][j][a][b]);
                        sum[i][j][b][1] = Mod(sum[i][j][b][1] + dp[i][j][a][b]);
                        sum[i][a][b][0] = Mod(sum[i][a][b][0] + dp[i][j][a][b]);
                        if(j == a) //sum[i][j][j][b][3] = Mod(sum[i][j - 1][j - 1][b][3] + dp[i][j][j][b]);
                            S[i][b][0] = Mod(S[i][b][0] + dp[i][j][j][b]);
                        if(j == b) //sum[i][j][a][j][4] = Mod(sum[i][j - 1][a][j - 1][4] + dp[i][j][a][j]);
                            S[i][a][1] = Mod(S[i][a][1] + dp[i][j][a][j]);
                    }
            }
        int ans = 0;
        for(int cen = 1; cen <= n; cen++)
            for(int a = 1; a < cen; a++)
                for(int b = cen + 1; b <= n; b++)
                {
                    Add(ans, (int)(dp[K][cen][a][b]*ten[cen - a - 1 + n - b] % mod));
                }
        printf("Case #%d: %I64d\n", cas, ans);
    }
    return 0;
}