NOIP2007 矩阵取数游戏（区间DP）

传送门

这道题第一眼看上去可能让人以为是贪心……不过贪心并不行，因为每次的操作是有2的幂次方的权值的。这样的话直接每次贪心最小的就目光短浅。所以那我们自然想到了DP。

据说这是一道很正常的区间DP？

区间DP的基本思想，就是先处理出小区间的最优解，再由多个小区间合并成一个大区间。

不过这道题的想法略微有些不同。首先从题目描述上来看，每行的取数是独立的，对于每一行我们来分析一下。

首先，因为题目中说只能取一行元素当前的首个元素或者末尾元素。既然如此，我们假设dp[i][j]表示选取区间i～j所能获得的最大值。

这样的话，dp[i][j]就只能从两方面转移过来。一是dp[i+1][j],二是dp[i][j-1].这样的话，我们考虑一下转移时候的状态。因为每次转移所获的的分数是当前选取的数值乘以2^选举的次数，所以我们可以这么想，对于一个内部的区间，它在被转移的时候，本身是要被*2的。之后这种状态就会被继续跟随着*2，所以选到最后必然是符合题意的。

所以说DP的方程就是dp[i][j] = min(dp[i+1][j]*2 + a[i] * 2,dp[i][j-1]*2 + a[j]*2);

DP方程说完了，之后说该怎么DP。我们知道区间DP的思想是先算小区间，之后合并成大区间，所以我们可以从0～n-1枚举区间长度，之后枚举区间的左右端点进行转移。

还有就是这道题要使用高精度……不过可以选择自己写一个高精乘，高精加，和高精度比较的struct，直接封装起来。这样就可以了。

看一下代码（因为高精模板是抄的……高精减可以忽略……）

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#define rep(i,a,n) for(ll i = a;i <= n;i++)
#define per(i,n,a) for(ll i = n;i >= a;i--)
#define enter putchar('\n')

using namespace std;
const int M = ;
typedef long long ll;

int read()
{
    int ans = ,op = ;
    char ch = getchar();
    while(ch < '' || ch > '')
    {
        if(ch == '-') op = -;
        ch = getchar();
    }
    while(ch >= '' && ch <= '')
    {
        ans *= ;
        ans += ch - '';
        ch = getchar();
    }
    return ans * op;
}

struct big
{
    int len,num[];
    big()
    {
        len = ;
        memset(num,,sizeof(num));
    }
    big(int p)
    {
        len = ;
        while(p) num[++len] = p % ,p /= ;
    }
    void init(int p)
    {
        len = ;
        while(p) num[++len] = p % ,p /= ;
    }
    big operator + (const big &g) const
    {
        big ans;
        int s = max(len,g.len);
        ans.len = s;
        rep(i,,s)
        {
            ans.num[i] += num[i] + g.num[i];
            if(ans.num[i] >= ) ans.num[i] -= ,ans.num[i+]++;
        }
        if(ans.num[s+]) ans.len++;
        return ans;
    }
    big operator - (const big &g) const
    {
        big ans;
        int s = max(len,g.len);
        ans.len = s;
        rep(i,,s) ans.num[i] = num[i] - g.num[i];
        rep(i,,s) if(ans.num[i] < ) ans.num[i+]--,ans.num[i] += ;
        if(ans.num[s+] != ) ans.len++;
        return ans;
    }
    big operator * (const big &g) const
    {
        big ans;
        int s1 = len,s2 = g.len;
        rep(i,,s1)
        rep(j,,s2) ans.num[i+j-] += num[i] * g.num[j];
        int s = s1 + s2 - ,k = ;
        while(ans.num[k] || k <= s)
        {
            ans.num[k+] += ans.num[k] / ;
            ans.num[k] = ans.num[k] % ;
            k++;
        }
        if(!ans.num[k]) k--;
        ans.len = k;
        return ans;
    }
    friend big bmax(const big &f,const big &g)
    {
        if(f.len < g.len) return g;
        else if(f.len > g.len) return f;
        else
        {
            per(i,f.len,)
            {
                if(f.num[i] < g.num[i]) return g;
                else if(f.num[i] > g.num[i]) return f;
            }
        }
        return f;
    }
    void out()
    {
        if(!len) printf("0\n");
        per(i,len,) printf("%d",num[i]);enter;
    }
};
big a,b,c,f[][],dp[][][],ans,pow2[],now;

int n,m;

int main()
{
    n = read(),m = read();
    pow2[].init();
    rep(i,,m) pow2[i] = pow2[i-] * pow2[];
    rep(i,,n)
    rep(j,,m) f[i][j].init(read());
    rep(i,,n)
    {
        rep(p,,m)
        rep(q,,m-p)
        {
            dp[i][q][p+q] = bmax((dp[i][q+][p+q] * pow2[] + pow2[] * f[i][q]),(dp[i][q][p+q-] * pow2[] + pow2[] * f[i][p+q]));//注意第一维只是起计数作用，无实际意义。
//            now = dp[i][q][p+q],now.out();
        }
        ans = ans + dp[i][][m];
    }
    ans.out();
    return ;
}