#bzoj2239#猜谜语（DP）_bzoj 2239 题解-优快云博客

本文链接：https://blog.youkuaiyun.com/its_elaine/article/details/75948737

本文介绍了一种通过插入最少数量的运算符使数字串运算结果等于目标值的算法。该算法采用动态规划方法，分为仅考虑乘法和同时考虑加法与乘法两个阶段进行求解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

2239: 【三校集训第四场】猜谜语

时间限制: 1 Sec 内存限制: 128 MB

题目描述

给出一个长度为N的数字字符串和一个数字T，要求插入最少的加号或者乘号，使得数字字符串的运算结果为T。运算符*号优先级高于+号，运算数可以有任意个前导0.

输入

输入不超过5组数据，每组数据两行。

每组数据的第一行为长度N,只包含0~9的数字字符串；第二行为一个数字T。

输入T<0表示输入结束。

输出

输出一个数字单独占一行，表示最少需要添加的运算符（+号或*号）数，无解输出-1.

样例输入

样例输出

提示

对于30%的数据，有1<=N<=10,0<=T<=50.

对于50%的数据，有1<=N<=15,0<=T<=200.

对于全部的数据，有1<=N<=20,0<=T<=250.

DP题，

分为两步：

第一步处理只有乘号的情况：

定义状态f[i][j][k]表示从第i个数字到第j个数字运算结果为k时所需要添加的最少乘号个数，

则有：f[i][j][k]=min(f[i][j][k],f[i][p][x]+1 | i<=p<j,k整除x且x=k/num[p+1][j])

Num[p+1][j]为从第p+1个数字到第j个数字组成的数的值。

初始值为f[i][j][num[i][j]]=0

第二步，处理有乘号和加号的情况：

定义状态G[i][j]表示前i个字符运算结果为j时需要添加的最少的运算符个数，则有：

G[i][j]=min(G[k][j-x]+f[k+1][i][x]+1)

其中0<=k<i;0<=x<=j，初始值g[i][j]=f[0][i][j]

容易出错的数据有

123

此时结果为0.

输入

00000000000000000

此时结果为0

输入

992299

此时结果为5

Code:

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

const int INF = 0x3f3f3f3f;

int T;
char In[30];
int Dp[30][300], num[30][30], G[30][30][300];

int main(){
    //Dpreopen("guess.in", "r", stdin);
    //Dpreopen("guess.out", "w", stdout);
    while(~scanf("%s%d", In, &T) && T >= 0){
        int N = strlen(In);
        memset(Dp, 0x3f, sizeof Dp );
        memset(G, 0x3f, sizeof G );
        memset(num, -1, sizeof num );
        for(int i = 1; i <= N; ++ i)
            for(int j = i; j <= N; ++ j){
                int tmp = 0;
                for(int k = i; k <= j; ++ k)
                    tmp = tmp * 10 + In[k - 1] - 48;
                num[i][j] = tmp;
                if(tmp <= T && tmp >= 0)
                    G[i][j][tmp] = 0;
            }
            G[0][0][0] = 0;
            for(int i = 1; i <= N; ++ i)
                for(int j = i; j <= N; ++ j)
                    for(int k = i + 1; k <= j; ++ k){
                        if(! num[k][j])	G[i][j][0] = min(G[i][j][0], 1);
                        G[i][j][0] = min(G[i][j][0], G[i][k - 1][0] + 1);
                        for(int x = 1; x <= T; ++ x)
                            if(num[k][j] && num[k][j] >= 0 && x % num[k][j] == 0)
                                G[i][j][x] = min(G[i][j][x], G[i][k - 1][x / num[k][j]] + 1);
                    }
            Dp[0][0] = 0;
            for(int i = 1; i <= N; ++ i)
                for(int k = 0; k <= T; ++ k)
                    for(int j = 1; j <= i; ++ j)
                        for(int k1 = 0; k1 <= k; ++ k1)
                            Dp[i][k] = min(Dp[i][k], Dp[j - 1][k1] + G[j][i][k - k1] + 1);
            if(Dp[N][T] == INF)  puts("-1");
            else printf("%d\n", Dp[N][T] - 1);
    }
    return 0;
}