矩阵取数游戏

题目描述 Description
【问题描述】
帅帅经常跟同学玩一个矩阵取数游戏：对于一个给定的n*m 的矩阵，矩阵中的每个元素aij均
为非负整数。游戏规则如下：
1. 每次取数时须从每行各取走一个元素，共n个。m次后取完矩阵所有元素；
2. 每次取走的各个元素只能是该元素所在行的行首或行尾；
3. 每次取数都有一个得分值，为每行取数的得分之和，每行取数的得分= 被取走的元素值*2i，
其中i 表示第i 次取数（从1 开始编号）；
4. 游戏结束总得分为m次取数得分之和。
帅帅想请你帮忙写一个程序，对于任意矩阵，可以求出取数后的最大得分。

输入描述 Input Description
第1行为两个用空格隔开的整数n和m。
第2~n+1 行为n*m矩阵，其中每行有m个用单个空格隔开的非负整数。

输出描述 Output Description
输出 仅包含1 行，为一个整数，即输入矩阵取数后的最大得分。

样例输入 Sample Input
2 3
1 2 3
3 4 2

样例输出 Sample Output
82

数据范围及提示 Data Size & Hint
样例解释

第 1 次：第1 行取行首元素，第2 行取行尾元素，本次得分为1*21+2*21=6
第2 次：两行均取行首元素，本次得分为2*22+3*22=20
第3 次：得分为3*23+4*23=56。总得分为6+20+56=82

【限制】
60%的数据满足：1<=n, m<=30, 答案不超过1016
100%的数据满足：1<=n, m<=80, 0<=aij<=1000

一道很经典的区间动态规划，主要的思路呢就是一行一行地去处理，然后在用区间
动态规划的套路：枚举区间，从小到大地构造最优解，最后再套上高精度模板就AC啦！OvO

//由于100%数据范围超出long long 故采用高精 
//由题意可知，越往后取得数字，乘的值越大
//可以反向来看，从中间往两边取数，每次都在原来数字之和*2+现取数，如此便可不预处理2的n次方 
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=80+10;
struct BIGNUM {
    int num[maxn],len;
    BIGNUM(){memset(num,0,sizeof(num));len=1;}
    BIGNUM operator = (const char str[]) {
        len=strlen(str);
        for(int i=0;i<len;i++)
            num[i]=str[len-i-1]-'0';
        while(num[len-1]==0&&len>1) len--;
        return *this;
    }
    BIGNUM operator = (const int n) {
        int tmp=n;
        len=1;
        do {
            num[len-1]=tmp%10;
            tmp/=10;len++;
        }while(tmp>0);
        while(num[len-1]==0&&len>1) len--;
        return *this;
    }
    BIGNUM operator + (const BIGNUM &rhs) const {
        BIGNUM tmp;
        tmp.len=max(len,rhs.len)+1;
        for(int i=0;i<tmp.len;i++) {
            tmp.num[i]+=num[i]+rhs.num[i];
            tmp.num[i+1]=tmp.num[i]/10;
            tmp.num[i]%=10;
        }
        while(tmp.num[tmp.len-1]==0&&tmp.len>1) tmp.len--;
        return tmp;
    }
    BIGNUM operator * (const BIGNUM &rhs) const {
        BIGNUM tmp;
        tmp.len=len+rhs.len;
        for(int i=0;i<len;i++)
            for(int j=0;j<rhs.len;j++) {
                tmp.num[i+j]+=num[i]*rhs.num[j];
                tmp.num[i+j+1]+=tmp.num[i+j]/10;
                tmp.num[i+j]%=10;
            }
        while(tmp.num[tmp.len-1]==0&&tmp.len>1) tmp.len--;
        return tmp;
    }
    bool operator < (const BIGNUM &rhs) const {
        if(len>rhs.len) return false;
        if(len<rhs.len) return true;
        for(int i=len-1;i>=0;i--)
            if(num[i]!=rhs.num[i]) return num[i]<rhs.num[i];
        return false;
    }
    void print() {
        for(int i=len-1;i>=0;i--) printf("%d",num[i]);
    }
}dp[maxn][maxn];
BIGNUM ans;
int a[maxn];
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    BIGNUM pow;
    pow=2;
    for(int i=1;i<=n;i++) {
        memset(dp,0,sizeof(dp));
        for(int j=1;j<=m;j++) {
            scanf("%d",&a[j]);
            dp[j][j]=a[j]*2;
        }
        for(int x=2;x<=m;x++)
            for(int l=1;l<=m;l++) {
                int r=l+x-1;
                if(r>m) continue;
                dp[l][r]=max(dp[l+1][r]*pow+dp[l][l],dp[l][r-1]*pow+dp[r][r]);
            }
        ans=ans+dp[1][m];
    }
    ans.print();
    return 0;
}
高精模板
int main()
{
    int n,m;
    cin>>m>>n;
    bigint  a[105];
    bigint  tot,f[maxn][maxn];
    bigint  q,p;
    for(int num=1;num<=m;num++)
    {
    for(int i=1;i<=n;i++)
    cin>>a[i]; 
    for(int i=1;i<=n;i++)
    f[i][i]=a[i]+a[i];//预处理
    for(int l=1;l<=n-1;l++)
    for(int i=1;i<=n&&i+l<=n;i++)
    {
        int j=i+l;//因为是用高精做的，所以没有max。状态转移方程是：f[i][j]=max(a[i]+f[i+1][j] , a[j]+f[i][j-1])*2
        p=a[i]+f[i+1][j];//用乘2来算的话会跑的比西方记者还快[OvO]
        q=a[j]+f[i][j-1];
        if(p<q)
        f[i][j]=q+q;
        else
        f[i][j]=p+p;
    }
    tot=f[1][n]+tot;
    memset(&a,0,sizeof(a));
    memset(&f,0,sizeof(f));
    memset(&q,0,sizeof(q));
    memset(&p,0,sizeof(p));
    }
    cout<<tot;
    return 0;
}