程序设计与算法（二）测验汇总011：最佳加法表达式（DP、高精度）

本文链接：https://blog.csdn.net/Hrbust_cx/article/details/78077770

总时间限制: 1000ms 内存限制: 65536kB

描述

给定n个1到9的数字，要求在数字之间摆放m个加号(加号两边必须有数字），使得所得到的加法表达式的值最小，并输出该值。例如，在1234中摆放1个加号，最好的摆法就是12+34,和为36

输入

有不超过15组数据
每组数据两行。第一行是整数m，表示有m个加号要放( 0<=m<=50)
第二行是若干个数字。数字总数n不超过50,且 m <= n-1

输出

对每组数据，输出最小加法表达式的值

样例输入

样例输出

102
579
15

提示

要用到高精度计算，即用数组来存放long long 都装不下的大整数，并用模拟列竖式的办法进行大整数的加法。

解题分析

假定数字串长度为n，添加完加号后，表达式的最后一个加号添加在第i个数字后面，那么整个表达式的最小值，就等于在前i个数字中插入m-1个加号所能形成的最小值，加上第i+1到第n个数字所组成的数的值（i从1开始算）。

设V(m,n)表示在n个数字中插入m个加号所能形成的表达式最小值，那么：

if(m==0)
V(m,n)=Num(1,n);
else if(n-1 < m)
V(m,n)= $\infty$ ;
else
V(m,n)=min(V(m-1,i)+Num(i+1,n))(i=m…n-1);

Num(i,j)表示从第i个数字到第j个数字所组成的数。数字编号从1开始算。此操作复杂度为O(j-i+1)，可以预处理后存起来。

因为每个状态由m，n决定，总的状态数即mn，乘计算每个状态所需时间为O(n)，得总时间复杂度：O(m $n^2$ )。

若n比较大，long long不够存放运算过程中的整数，则需要使用高精度计算（用数组存放大整数，模拟列竖式做加法），复杂度为O(m $n^3$ )。

AC代码

#include<iostream>
#include<string>
#include<cstring>
using namespace std;

struct BigInt{
    int num[110];
    int len;
    BigInt operator+(const BigInt &n){
        //重载+，使得a+b在a,b都是BigInt变量的时候能成立
        int ml=max(len,n.len);
        int carry=0;//进位
        BigInt result;
        for(int i=0;i<ml;++i){
            result.num[i]=num[i]+n.num[i]+carry;
            if(result.num[i]>=10){
                carry=1;
                result.num[i]-=10;
            }
            else
                carry=0;
        }
        if(carry==1){
            result.len=ml+1;
            result.num[ml]=1;
        }
        else
            result.len=ml;
        return result;
    }
    bool operator<(const BigInt &n){
        if(len>n.len)
            return false;
        else if(len<n.len)
            return true;
        else{
            for(int i=len-1;i>=0;--i){
                if(num[i]<n.num[i])
                    return true;
                else if(num[i]>n.num[i])
                    return false;
            }
            return false;
        }
    }
    BigInt(){
        len=1;
        memset(num,0,sizeof(num));
    }
    BigInt(const char *n,int L){
        //由长度为L的char数组构造大整数，n里面的元素取值范围从1到9。
        memset(num,0,sizeof(num));
        len=L;
        for(int i=0;n[i];++i)
            num[len-i-1]=n[i]-'0';
    }
};

ostream &operator<<(ostream &o,const BigInt &n)
{
    for(int i=n.len-1;i>=0;--i)
        o<<n.num[i];
    return o;
}

const int MAXN=60;
char a[MAXN];
BigInt Num[MAXN][MAXN];//Num[i][j]表示从第i个数字到第j个数字所构成的整数
BigInt V[MAXN][MAXN];//V[i][j]表示i个加号放到前j个数字中间，所能得到的最佳表达式的值

int main()
{
    int m,n;
    BigInt inf;//无穷大
    inf.num[MAXN-2]=1;
    inf.len=MAXN-1;

    while(cin>>m){
        cin>>a+1;
        n=strlen(a+1);
        for(int i=1;i<=n;++i)
            for(int j=i;j<=n;++j)
                Num[i][j]=BigInt(a+i,j-i+1);
        for(int j=1;j<=n;++j)
            V[0][j]=BigInt(a+1,j);

        for(int i=1;i<=m;++i){
            for(int j=1;j<=n;++j){
                if(j-1<i)
                    V[i][j]=inf;
                else{
                    BigInt tmpMin=inf;
                    for(int k=i;k<j;++k){
                        BigInt tmp=V[i-1][k]+Num[k+1][j];
                        if(tmp<tmpMin)
                            tmpMin=tmp;
                    }
                    V[i][j]=tmpMin;
                }
            }
        }
        cout<<V[m][n]<<endl;
    }
    return 0;
}