（注意大数模拟）最佳加法表达式

传送门：最佳加法表达式

11:最佳加法表达式

描述

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

输入

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

输出

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

样例输入

2
123456
1
123456
4
12345

样例输出

102
579
15

提示

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

来源

Guo Wei

题解：该题处理思路先放一个加号：可以先放最右边的加号，右边固定，左边放加号最小。

要避免重复计算：将数预处理存起来，Num(i,j)表示从第i个数字到第j个数字所组成的数。

状态数组V[i][j]表示i个加号放到前j个数字中间，所能得到的最佳表达式的值。

 

#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;
    }


//另一种写法
/*
    BigInt operator+(const BigInt &n){
        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;
            carry=result.num[i]/10;
            result.num[i]=result.num[i]%10;
        }
        if(carry!=0){
            result.num[ml]=carry;
            result.len=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;i<len;++i)
            num[len-1-i]=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;  //从下标为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);  //在前j个数之前加0个加号，所形成的最小表达式的值就是这前j个数字串连成的数值

        for(int i=1;i<=m;++i){
            for(int j=1;j<=n;++j){
                if(j-1<i)
                    V[i][j]=inf; //j个数最多加j-1个加号，如果加号的数目i>j-1，表达式都形不成，而这个肯定不是最佳表达式的最小值，所以我们初始化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;
}