[NOIP2007] 矩阵取数游戏

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

【输入格式】

    输入文件game.in包括n+1行：
第1行为两个用空格隔开的整数n和m。
第2-n+l行为n*m矩阵，其中每行有m个用单个空格隔开的非负整数。

【输出格式】
   输出文件game.out仅包含1行，为一个整数，即输入矩阵取数后的最大得分。

【输入输出样例1】
 
输入：
2 3
1 2 3
3 4 2

输出：
82

【输入输出样例l解释】
第1次：第1行取行首元素，第2行取行尾元素，本次得分为1*2¹+2*2¹=6
第2次：两行均取行首元素，本次得分为2*2²+3*2²=20
第3次：得分为3*2^3+4*2^3=56。总得分为6+20+56=82

【输入输出样例2】

输入：
1 4
4 5 0 5

输出：
122

【输入输出样例3】

输入：
2 10
96 56 54 46 86 12 23 88 80 43
16 95 18 29 30 53 88 83 64 67

输出：
316994

【限制】
60％的数据满足：1<=n，m<=30，答案不超过10^16
100％的数据满足：l<=n，m<=80，0<=a_ij<=1000

【分析】

这道题的最优子结构性质&子问题重叠都非常明显，很容易写出区间动规的状态转移方程：

F_L,i,j = max{(F_L,i-1,j + 2 ^x *a_L,i-1), (F_L,i,j+1+ 2 ^x*a _L,j+1)}

 

 证明比较简单，这里不作为讨论重点。。。 再来看数据范围：m最大可达80，a _i,j最大可达1000，明显超过了int64的范围（听Pascal党说还有 int128这种数据类型？），我们c++没办法，只好高精度压位。。考虑到“乘法”中只有“高精度*int”这里可以把乘法无耻地改成倍增→_→排除了 乘法，压位的时候不妨多压几位节约资源（实测结果：压8位高精耗时314ms）

 

 

 1 #include <cstdio>
 2  #define MOD 100000000
 3  using  namespace std;
 4  int M[ 81][ 81]={ 0}, n, m;
 5  struct big
 6 {
 7      int num[ 5], len;
 8     big() { len =  1;num[ 0]= 0; }
 9     big( int k) {
10         len =  1, num[ 0]=k % MOD, k/=MOD;
11          while(k)
12             num[len++] = k % MOD, k /= MOD;
13     }
14     big&  operator+=( const big& b) {
15          int m= 0,i;
16          for(i= 0;i<len || i<b.len || m;++i) {
17              if(i<len) m += num[i];
18              if(i<b.len) m += b.num[i];
19             num[i] = m % MOD;
20             m /= MOD;
21         }
22          if(i > len)len = i;
23          return * this;
24     }
25     big  operator +( const big& b) {
26         big ans = * this;ans += b;
27          return ans;
28     }
29     big  operator *( int b) const {
30         big ans =  0,k = * this;
31          while(b) {
32              if(b& 1)ans += k;
33             k += k;
34             b >>=  1;
35         }
36          return ans;
37     }
38      bool  operator >( const big& b) const {
39          if(len!=b.len) return len > b.len;
40          int i = len;
41          while(--i>= 0)
42              if(num[i]!=b.num[i]) return num[i] > b.num[i];
43          return  0;
44     }
45 }s[ 81][ 81];
46  int main()
47 {
48      int i,j,t;
49     scanf( " %d%d ",&n,&m);
50     big Ans, po2[ 81]={ 1};
51      for(i= 1;i<=m;++i)
52         po2[i] = po2[i- 1]* 2;
53      for(i= 0;i<n;++i)
54          for(j= 0;j<m;++j)
55             scanf( " %d ",M[i]+j);
56      for(t= 0;t<n;++t) {
57         big temp,ans;
58         s[ 0][m] =  0;
59          for(j = m- 1;j>= 0;--j)
60             s[ 0][j] = s[ 0][j+ 1] + po2[m-j] * M[t][j];
61         ans = s[ 0][ 0];
62          for(i =  1;i <= m;++i)
63             s[i][m] = s[i- 1][m] + po2[i] * M[t][i- 1];
64          if(s[m][m] > ans)ans = s[m][m];
65          for(i =  1;i < m;++i) {
66              for(j = m- 1;j>=i;--j) {
67                  if(s[i- 1][j]+po2[m+i-j]*M[t][i- 1] > s[i][j+ 1]+po2[m+i-j]*M[t][j])
68                     s[i][j] = s[i- 1][j]+po2[m+i-j]*M[t][i- 1];
69                  else s[i][j] = s[i][j+ 1]+po2[m+i-j]*M[t][j];
70             }
71              if(s[i][i] > ans)ans = s[i][i];
72         }
73         Ans += ans;
74     }
75     i = Ans.len;
76     printf( " %d ",Ans.num[--i]);
77      while(i)
78         printf( " %08d ",Ans.num[--i]);
79      return  0;
80 }

动态规划 + 高精度

转载于:https://www.cnblogs.com/Asm-Definer/p/3900062.html