SGU167 I-country

嗯以前在某个DP专题了发过这道题，但是当时没码代码，现在重发一篇题解

思考阶段如何划分:
由已经处理的行数向下扩展，但是仅有行数我们无法描述状态空间
那我们再加入已经选过的格子数，这样我们似乎可以确定我们已经完成了多少行，哪些格子已经选过
但是这是凸连通块，我们靠以上两个信息还远远不够
那么我们想一想如何使阶段转移完成后最终得到的是凸连通块，再加入什么信息？
我们可以再加入每行的左端点和右端点，确定下一行端点的范围，以满足单调性
那么我们还可以再加入轮廓的单调类型
加起来5维
f[i,j,l,r,x,y]
表示前i行，选了j个格子，其中第i行选了第l到r的格子，左轮廓的单调性是x,右轮廓的单调性是r时，能构成的凸连通块的最大权值和
行数和格子数可以作为dp的“阶段”，每次转移到下一行，同时选出的格子递增，符合“阶段线性增长”的特点

然后我们会发现，我们在进行状态转移的时候，需要第i行中l到r的区间和，显然边转移边计算需要不低的复杂度，于是我们可以预处理出表示每一行的前缀和数组A，这样在计算时，l到r的区间和就可以表示为A[i][r]-A[i][l]，在转移结束时，再定义两个变量p,q，表示当前行的左端点l和右端点r
然后我们来写一下状态转移方程试试：
根据我们的分析，我们可以得到4种可能状态：//1表示递减，0表示递增
1.左边界列号递减，右边界列号递增（两边界都处于扩张状态）
f[i,j,l,r,1,0] = A[i][r]-A[i][l] + max{f[i-1,j-(r-l+1),p,q,1,0]};//j>r-l+1>0
`　　　　 = A[i][r]-A[i][l] + max{f[i-1,0,0,0,1,0]};//j=r-l+1>0
2.左右边界列号都递减（左边界扩张，右边界收缩）
f[i,j,l,r,1,1] = A[i][r]-A[i][l] + max{max{f[i-1,j-(r-l+1),p,q,1,y]}(0<=y<=1)}
3.左右边界列号都递减（左边界收缩，右边界扩张）
f[i,j,l,r,0,0] = A[i][r]-A[i][l] + max{{f[i-1,j-(r-l+1),p,q,x,0](0<=x<=1)}}
4.左边界列号递增，右边界列号递减（两边界都处于收缩状态）
f[i,j,l,r,0,1] = A[i][r]-A[i][l] + max{max{max{f[i-1,j-(r-l+1),p,q,x,y]}(0<=y<=1)}(0<=x<=1)}(p<=l<=r<=q)
对于2,3,4的max嵌套max，可能有点难以理解
我们来想一下，我们要进行收缩，那么我们这个收缩的状态是怎么得来的?
答：由上一行扩张或收缩而来
所以当收缩右边界时，我们先比较的是上一行右边界标记扩张和右边界标记收缩的最大值，再和当前行比较
左边界收缩时同理。
这样我们就能推出2和3。
进而我们想4这种情况。
左右边界同时进行收缩，我们就要嵌套3次，先由上述确定右边界状态，再由已确定右边界状态来确定左边界状态，最后由已确定的左边界状态和右边界状态来确定当前行
//此处状态单指标记为收缩或扩张，即上一行的左/右边界由上上一行的左/右边界扩张或收缩得到

本题还要求输出方案。
在动态规划需要给出方案时，通常做法是额外使用一些与DP状态大小相同的数组记录下来每个状态，通过递归返回最初的状态，然后逐层退出的同时输出方案

 #include<bits/stdc++.h>
 using namespace std;
 int f[][][][][][];
 int lcw[][][][][][];//What did you choose on the left
 int rcw[][][][][][];//What did you choose on the right
 int lud[][][][][][];//The left is up or down
 int rud[][][][][][];//The right is up or down
 int n, m, k;

 int ans = , ie, le, re, xe, ye;

 int i, j, l, r, il, ir, x, y;

 int a[][], b[][];

 inline int read() {
     int x = , y = ;
     char ch = getchar();
     while(!isdigit(ch)) {
         if(ch == '-') y = -;
         ch = getchar();
     }
     while(isdigit(ch)) {
         x = (x << ) + (x << ) + ch - '';
         ch = getchar();
     }
     return x * y;
 }

 inline void update(int val, int L, int R, int X, int Y) {
     if(val < f[i][j][l][r][x][y]) return;
     f[i][j][l][r][x][y] = val;
     lcw[i][j][l][r][x][y] = L, rcw[i][j][l][r][x][y] = R;
     lud[i][j][l][r][x][y] = X, rud[i][j][l][r][x][y] = Y;
 }

 void print(int i, int j, int l, int r, int x, int y) {
     if(!j) return;
     print(i - , j - (r - l + ), lcw[i][j][l][r][x][y], rcw[i][j][l][r][x][y], lud[i][j][l][r][x][y], rud[i][j][l][r][x][y]);
     for(j = l; j <= r; ++j) printf("%d %d\n", i, j);
 } 

 int main() {
     freopen("input.in", "r", stdin);
     freopen("output.out", "w", stdout);
     memset(f, 0xcf, sizeof(f));
     n = read(), m = read(), k = read();
     for(i = ; i <= n; ++i)
         for(int j = ; j <= m; ++j) {
             a[i][j] = read();
             b[i][j] = b[i][j - ] + a[i][j];
         }
     for(i = ; i <= n; ++i)
         for(j = ; j <= k; ++j)
             for(l = ; l <= m; ++l)
                 for(r = l; r <= m; ++r) {//后两个维度，0表示递增，1表示递减
                     int len = r - l + , pow;
                     if(len > j) break;
                     pow = b[i][r] - b[i][l - ];
                     for(x = ; x < ; ++x)
                         for(y = ; y < ; ++y)
                             update(pow, m, , x, y);
                     x = y = ;
                     for(int p = l; p <= r; ++p)
                         for(int q = p; q <= r; ++q)
                             update(f[i - ][j - len][p][q][][] + pow, p, q, , );
                     x = y = ;
                     for(int p = ; p <= l; ++p)
                         for(int q = r; q <= m; ++q) {
                             update(f[i - ][j - len][p][q][][] + pow, p, q, , );
                             update(f[i - ][j - len][p][q][][] + pow, p, q, , );
                             update(f[i - ][j - len][p][q][][] + pow, p, q, , );
                             update(f[i - ][j - len][p][q][][] + pow, p, q, , );
                         }
                     x = , y = ;
                     for(int p = l; p <= r; ++p)
                         for(int q = r; q <= m; ++q) {
                             update(f[i - ][j - len][p][q][][] + pow, p, q, , );
                             update(f[i - ][j - len][p][q][][] + pow, p, q, , );
                         }
                     x = , y = ;
                     for(int p = ; p <= l; ++p)
                         for(int q = l; q <= r; ++q) {
                             update(f[i - ][j - len][p][q][][] + pow, p, q, , );
                             update(f[i - ][j - len][p][q][][] + pow, p, q, , );
                         }
                 }
     for(i = ; i <= n; ++i)
         for(l = ; l <= m; ++l)
             for(r = l; r <= m; ++r)
                 for(x = ; x < ; ++x)
                     for(y = ; y < ; ++y) {
                         if(ans < f[i][k][l][r][x][y]) {
                             ans = f[i][k][l][r][x][y];
                             ie = i, le = l, re = r,
                             xe = x, ye = y;
                         }
                     }
     printf("Oil : %d\n", ans);
     print(ie, k, le, re, xe, ye);
     return ;
 }