HDU 5396 区间DP 数学 Expression

题意：有n个数字，n-1个运算符，每个运算符的顺序可以任意，因此一共有 (n - 1)! 种运算顺序，得到 (n - 1)! 个运算结果，然后求这些运算结果之和 MOD 1e9+7.

分析：

类比最优矩阵链乘，枚举区间[l, r]中最后一个运算符的位置k。

如果运算符为乘法的话，那么根据乘法分配率这个乘法会分配进去。

这个区间中一共有r - l个运算符，其中最后一个运算符已经定了是第k个，左区间[l, k]有k - l个运算符，右区间[k + 1, r]有 r - k - 1 个运算符。

而且左、右区间运算符的先后顺序确定以后，两个区间之间的顺序是互不影响的，因此这样相同的结果一共有C(r - l - 1, k - l)

因此答案还要乘上这个数，d(i, j) += d(i, k) * d(k + 1, r) * C(r - l - 1, k - l) | op[k] = *

但如果是加减法的话就不能直接按照运算符进行区间合并了。

对于左区间的确定的一个运算顺序，右区间一共有 (r - k - 1)! 个运算结果，所以答案累加一个 d(l, k) * (r - k - 1)!

同样地，对于右区间一个确定的操作顺序，左区间对应有 (k - l)! 个运算结果，答案累加一个 d(k + 1, r) * (k - l)!

最后确定两个区间 r - l - 1 个运算符的顺序，最终答案乘上 C(r - l - 1, k - l)

最后总结一下答案就是：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 using namespace std;

 typedef long long LL;

 const int maxn =  + ;
 const LL MOD = ;

 int n;
 LL a[maxn];
 LL fac[maxn], C[maxn][maxn];
 char op[maxn];

 int vis[maxn][maxn];
 LL d[maxn][maxn];

 LL dp(int l, int r)
 {
     if(vis[l][r]) return d[l][r];
     LL& ans = d[l][r];
     ans = ;
     vis[l][r] = true;
     if(l == r) return ans = a[l];
     if(l +  == r)
     {
         if(op[l] == '*') return ans = a[l] * a[r] % MOD;
         if(op[l] == '+') return ans = (a[l] + a[r]) % MOD;
         if(op[l] == '-') return ans = (((a[l] - a[r]) % MOD) + MOD) % MOD;
     }
     for(int k = l; k < r; k++)
     {
         LL t1 = dp(l, k), t2 = dp(k + , r);
         LL t;
         if(op[k] == '*')
         {
             t = t1 * t2 % MOD;
             t = t * C[r - l - ][k - l];
             ans = (ans + t) % MOD;
             continue;
         }

         t1 = t1 * fac[r - k - ] % MOD;
         t2 = t2 * fac[k - l] % MOD;
         if(op[k] == '+') t = (t1 + t2) % MOD;
         else t = (((t1 - t2) % MOD) + MOD) % MOD;
         t = t * C[r - l - ][k - l];
         ans = (ans + t) % MOD;
     }

     return ans;
 }

 int main()
 {
     fac[] = ;
     for(int i = ; i < maxn; i++) fac[i] = fac[i - ] * i % MOD;
     for(int i = ; i < maxn; i++) C[i][] = C[i][i] = 1LL;
     for(int i = ; i < maxn; i++)
         for(int j = ; j < i; j++) C[i][j] = (C[i-][j] + C[i-][j-]) % MOD;

     while(scanf("%d", &n) ==  && n)
     {
         for(int i = ; i <= n; i++) scanf("%I64d", a + i);
         scanf("%s", op + );
         memset(vis, false, sizeof(vis));
         memset(vis, , sizeof(vis));
         printf("%I64d\n", dp(, n));
     }

     return ;
 }

代码君