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

最新推荐文章于 2018-11-08 16:13:24 发布
最新推荐文章于 2018-11-08 16:13:24 发布
阅读量3.3k 收藏 3
点赞数 3
分类专栏： ACM_Dynamic_Programming HDU 文章标签： HDU 5576 Expection of String 2015年上海现场赛E题 DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gatevin/article/details/50087853
版权

题目大意：

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

于是对于这个乘法式子, 当*某一边没有数字的时候视为那一侧的数字是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;
}





Gatevin
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Expection of String HDU - 5576 暴力dp
zstu_zy的博客
07-19 359
Frog has just learned how to multiply two numbers. Now he wants to do some exercise. He wrote a string on the paper, which only contains digits and a single × as the operator. If the × appears at the...
HDU-5576-数位DP（记忆化搜索）
lyc1635566ty的博客
08-02 1016
题意：一个字符串由数字和*号组成，每次操作可以交换其中任意两个数字，问K次操作后，所有可能结果的和 思路：可以针对其中三个数进行操作 操作分为1.三个数内的操作 2..三个数外的操作 3.三个数内的一个数和外面的数的操作 然后就可以递归求解，再加一个记忆化搜索 #include const long long mod=1000000007; using namespace std; i
hdu 5576 dp
07-19 116
题目大意：给你一个长度为 n 的 字符串表示一个乘法，一次操作随机选两个字符进行交换，进行m次操作，让你求出所有可能操作 的答案和。 (1 <= n, m <= 50) 思路：巨难。。 对于固定位置的三个字符来说，把中间的看成*, 两边的为a，b， 这个产生的贡献为，a * b * C，C只与a, b和 * 的位置有关， 所以我们只要求出a*b的贡献就好啦。 ...
HDU 4055 Number String：前缀和优化dp【增长趋势——处理重复选数】
a1392136的博客
11-01 356
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4055 题意： 　　给你一个由'I', 'D', '?'组成的字符串，长度为n，代表了一个1~n+1的排列中（数字不重复），相邻数字的增长趋势。（'I'为增，'D'为减，'?'为未知） 　　问你符合条件的数列有多少种。 题解： 　　表示状态： 　　　　dp[i][j] = c...
DP.rar_DP_hdu_动态规划_动态规划 C++
09-20
描述中提到的“动态规划DP题解”和“POJ HDU部分动态规划DP题解”，说明这个压缩包包含了针对HDU和POJ（Problemset Online Judge）平台上一些动态规划题目的解答。POJ是一个著名的在线编程竞赛平台，其中包含了大量...
hdu.rar_HDU 1089.cpp_OJ题求和_hdu_horsekw5_杭电obj
最新发布
09-24
【标题】"hdu.rar_HDU 1089.cpp_OJ题求和_hdu_horsekw5_杭电obj" 提供的信息是关于一个压缩文件，其中包含了一个名为 "HDU 1089.cpp" 的源代码文件，这个文件是为了解决杭州电子科技大学（Hangzhou Dianzi ...
HDU 递归题详解大全（含代码）
02-11
蟠桃记 1 折线分割平面 2 不容易系列之一 2 骨牌铺方格 3 不容易系列之(3)—— LELE的RPG难题 3 Children’s Queue 3 献给杭电五十周年校庆的礼物 3 钥匙计数之二 3 钥匙计数之一 3 母牛的故事 3 ...
HDU DP 题集
04-24
20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程(multistep decision process)的优化问题时，提出了著名的最优化原理(principle of optimality)，把多阶段过程转化为一系列单阶段问题，利用各阶段之间...
codeforces712D Memory and Scores(前缀和优化dp)
SeasonJoe的博客
11-25 641
题意： 两个人玩取数游戏,第一个人分数一开始是a,第二个分数一开始是b,接下来t轮,每轮两人都选择一个[-k,k]范围内的整数,加到自己的分数里,求有多少种情况使得t轮结束后a的分数比b高。 (1 ≤ a, b ≤ 100, 1 ≤ k ≤ 1000, 1 ≤ t ≤ 100) 要点： 一开始没想到是dp，实际上可以用dp[i][j]表示第i轮比一开始多得到j分的方案数，所以一开始a，b
思维题：抽屉原理 hdu 5776 sum & 51Nod 1103 N的倍数
Fighting!
07-31 1245
思维题：抽屉原理 hdu 5776 sum & 51Nod 1103 N的倍数 题目链接：  hdu 5776 sum 、 51nod 1103 N的倍数 hdu5576 sum题意：给定长度为N的整数序列，问该序列是否存在一个连续的子区间的和为M的倍数。 (1≤n≤100000, 1≤m≤5000). 51nod 1103 N的倍数 题意： 一个长度为N的数组A，从A中选出若干个数，
HDU-4055 Number String （dp+前缀和优化）
碳酸钙的01妖精的博客
08-13 424
Problem Description The signature of a permutation is a string that is computed as follows: for each pair of consecutive elements of the permutation, write down the letter 'I' (increasing) if ...
HDU 5550 dp + 前缀和优化
Bahuia的博客
11-06 564
题意：有个大楼有n层，每层都有两种人，一种喜欢的打球，一种喜欢游泳，现在要你在每一层要么开设球馆，要么开设游泳馆，分配完毕以后，打球的要到球馆，游泳的要到游泳馆，问最优分配下，所有人要移动的最短距离和是多少？思路：dp[i][0/1]表示第i层布置为0或1，且i+1层为1或0（与第i层相反）的最小代价。 dp[i][0]可以由dp[j][1]转移过来，其中j小于i，那么我们考虑j+1到i的这些层要
HDU - 5776 sum （抽屉原理/鸽巢原理）
hxxjxw的博客
11-08 460
题目大意：       有n个数，问存不存在连续子序列之和是m的倍数 题解：       抽屉原理       如果前缀和存在%m后==0的不用再考虑，YES       如果存在余数为1~m-1的个数大于一个时我们也能保证为YES （此时这两段区间作差一定是m的倍数） #include&lt;cstdio&gt; #include&lt;algorithm&gt; #inclu...
hdu5550(计数DP+前缀和)
qkoqhh
11-02 279
题意：每层楼有ai个人打羽毛球，有bi个人游泳，每层楼只能建造一个羽毛球场或者游泳馆，如果当前楼层没有羽毛求场，这ai个人就要到最近有羽毛球场的楼层打羽毛球，每个人产生的代价为楼层差，游泳的类似，求最小代价 这个貌似并没有用到什么很特殊的技巧可是就是莫名地难想。。不造为什么。。 首先由于楼层上下的情况都会对当前楼层产生影响，所以不能一层一层地往上考虑。。 那就只能一段一段考虑了。。对一段区间...
2015 ACM-ICPC 上海赛区邀请赛 解题报告 (Silver)
CD's Coding
05-31 2849
前言 ACM/ICPC(Association for Computing Machinery – International Collegiate Programming Contest, 美国计算机协会-国际大学生程序设计竞赛)是由国际计算机界历史悠久、颇具权威性的组织ACM主办的年度竞赛活动，是世界上公认规模最大、水平最高的国际大学生程序设计竞赛。
冬令营整理
Yves___的专栏
01-29 1473
写在前面这次冬令营还是获益匪浅的。 把每份讲稿的知识点和值得研究的东西列一下吧。多项式导论By picks 多项式乘法：分治乘法、FFT、Cantor’s Algorithm 形式幂级数、幂级数方程、多项式复合 多项式代数：多项式除法、多项式逆元、模意义下的复合、点值、插值、线性组合、欧几里得、中国剩余定理等 多项式的因式分解问题（前面所有内容的大荟萃） 形式语言与自动机By 茹逸中 形式语言和
HDU 3336 Count the string 后缀数组 或 (KMP + DP)
Gatevin的专栏
05-04 788
题目大意： 就是现在给出一个长度不超过20W的字符串S, 对于这个字符串求其所有前缀在串中出现次数的和, 结果对10007取模 大致思路： 很容易想到后缀数组, 找到sa[i] = 0的那个就是串S, 那么找出这个位置向两边能扩展到的长度即可, 就是利用一下height数组就行了, 没什么难度= = 还是不清楚的话看代码细节吧 代码如下： Result  :  Acce
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值