动态规划-最佳加法表达式

总时间限制: 

1000ms

 

内存限制: 

65536kB

描述

给定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 都装不下的大整数，并用模拟列竖式的办法进行大整数的加法。

解题思路

1.找子问题：

在n个数字中插入m个加号所能形成的表达式的最小值

2.确定状态：

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

3.确定初始状态值：

V (0,n) = n个数字构成的整数

4.找出状态转移方程：

V(m,n)=Min{V(m-1,i)+Num(i+1,n)} (i=m...n-1)

Num(i,j)表示从第i个数字到第j个数字所组成的数。可以预处理后存起来。

我的代码（非高精度计算）

#include <iostream>

#include <cstring>

using namespace std;

int cnt,len;

char a[52];

int num[52][52] = {-1};

int GetNum(int s, int e)

{

    int n=0;

    for(int i = s; i <= e; ++i)

        n = n*10 + a[i] - '0';

    return n;

}

int MinValue(int m, int n)

{

    if(m == 0)

        return num[1][n];

    else{

        int tmp=9999999;

        for(int i = m; i < n; ++i){ //最后一个加号放在第i个数后面

            tmp = min(tmp, MinValue(m-1, i) + num[i+1][n]);

        }

        return tmp;

    }

}

int main()

{

    while(cin >> cnt >> a){

        len = strlen(a);

        for(int i = 0; i < len; ++i)

            for(int j = i; j < len; ++j)

                num[i+1][j+1] = GetNum(i, j);

        cout << MinValue(cnt, len) << endl;

    }

    return 0;

}

加上高精度计算的不会写，以下为老师代码（运行起来好像不对）：

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

}