题意

n*m的矩阵，每次从每一行中选择一个元素，即：每次选n个（每一行只能选择最左边或最右边），一直取m次把矩阵中所有元素取完。且有一个计算公式：
每次取数都有一个得分值，为每行取数的得分之和，每行取数的得分 = 被取走的元素值 * ，其中i表示第i次取数（从1开始编号）；
求出可能的最大得分值。

题解

开始天真的觉得直接就是高精度+一个简单模拟（每次对一行中的最左边的元素和最右边元素进行比较，选择小的，然后对选择的元素标记为已选），这种模拟显然是不行的，样例2就明显行不通了。
正解：区间dp+高精度
由于每一行的选择与其他行无关，于是可以对每行单独考虑。
状态转移方程：dp[i][j]=max(dp[i][j+1]+2^k * a[x][i] , dp[i-1][j]+2^k * a[x][j]）

AC代码

看了下题解，没有java老大哥的一席之地，于是用java BigInteger写了份代码：

import java.math.BigInteger;
import java.util.*;

public class Main {
    static BigInteger powarr[]=new BigInteger[90];
    static BigInteger[][] a=new BigInteger[90][90];
    static BigInteger[][] dp=new BigInteger[90][90];
    static int n,m;
    //预处理pow(2,i);
    public static void init(){
        BigInteger x=BigInteger.valueOf(1);
        for(int i=1;i<=80;i++){
            x=x.multiply(BigInteger.valueOf(2));
            powarr[i]=x;
        }
    }
    public static BigInteger max(BigInteger a,BigInteger b){
        if(a.compareTo(b)==1) return a;
        else return  b;
    }

    /**
     * 由于每一行都是独立的，于是分别用区间dp
     * dp[i][j]=max(dp[i+1][j]+2^k*a[x][i] , dp[i][j-1]+2^k*a[x][j]);
     * 其中len=m,k=1;len=m-1,k=2;即：k=m-len+1;
     * @param x
     * @return
     */
    public static BigInteger solve(int x){
        //dp数组初始化
        for(int i=0;i<90;i++){
            for(int j=0;j<90;j++)
                dp[i][j]=BigInteger.valueOf(0);
        }
        for(int len=1;len<=m;len++){
            for(int i=1;i<=m-len+1;i++){
                int j=i+len-1;
                dp[i][j]=max(dp[i+1][j].add(powarr[m-len+1].multiply(a[x][i])),dp[i][j-1].add(powarr[m-len+1].multiply(a[x][j])));
            }
        }
        return dp[1][m];
    }
    public static void main(String args[]) {
        init();
        Scanner scan=new Scanner(System.in);
        n=scan.nextInt();
        m=scan.nextInt();
        for(int i=1;i<=n;i++) {
            for (int j = 1; j <= m; j++) {
                a[i][j] = scan.nextBigInteger();
            }
        }

        BigInteger ans=BigInteger.valueOf(0);
        for(int i=1;i<=n;i++){
            ans=ans.add(solve(i));
        }
        System.out.println(ans);
    }
}