单调栈/单调队列/RMQ

在上上周的交友大会中，队长大人提到了st算法，然后仔细的发呆了一个星期，于是就开始做队长的专题了， 6天后的我总算在此专题做题数目和队长一样了。。明早没课，准备通宵把这几天的零散的记忆整理一下。

HDU 3530 Subsequence

一开始想为何不能m和k一起放到while语句里进行处理

nowmax和nowmin保存了i之前的最大和最小值，假设此时已经出现不满足k和m的序列（A）了（比k大or比m小or both），然后我们往后找，发现了一个比序列（A）的min更小的值（me），此时nowmax - nowmin就会上升，就可能会出现满足k和m的序列。要是出现了一个比（A）max更大的值（me），此时m上升，同理。

要是我们把m和k放在一起，就会在找到（me）之前就把序列给kill了。

然后，从上面的推理中可以看出k是硬道理，而m存在可能性，所以代码就是这样

#include <cstdio>
#include <iostream>
#include <deque>
#include <algorithm>
using namespace std;
const int MAXN = 1000010;
int a[MAXN];
deque<int>nowmax;
deque<int>nowmin;
int main()
{
int n , m , k;
while(~scanf("%d%d%d" , &n , &m ,&k))
{
int nowme = 0;
int ans = 0;
nowmax.clear();
nowmin.clear();
for(int i = 0; i < n ; ++ i)
{
scanf("%d" , &a[i]);
while(!nowmax.empty() && a[nowmax.back()] < a[i])//维护当前最大的
{
nowmax.pop_back();
}
while(!nowmin.empty() && a[nowmin.back()] > a[i])//维护当前最小的
{
nowmin.pop_back();
}
nowmin.push_back(i);
nowmax.push_back(i);
while(!nowmax.empty() && !nowmin.empty() && a[nowmax.front()] - a[nowmin.front()] > k)//去除不符合k的
{
if(nowmax.front() < nowmin.front())//此时我的位置应该是在nowmax和nowmin中最远的一个
{
nowme = nowmax.front() + 1;
nowmax.pop_front();
}
else
{
nowme = nowmin.front() + 1;
nowmin.pop_front();
}
}//出来之后如果nowmax或者nowmin为空，说明当前区间没有一个符合条件的，如果是因为发现了符合条件k，那么k就判断其是否符合条件m
if(!nowmax.empty() && !nowmin.empty() && a[nowmax.front()] - a[nowmin.front()] >= m)//如果符合m的话
{
ans = max(ans , i - nowme + 1);
}
}
printf("%d\n", ans);
}

return 0;
}

HDU 3706 Second My Problem First

这道题就是问区间的最大值，这里之间用单调队列模拟了，要是先处理出所有的ai%b然后st跑一遍，感觉会爆炸。。

#include <cstdio>
#include <iostream>
#include <deque>
#include <algorithm>
#include <cmath>
using namespace std;
struct mymin
{
int x;
int v;
mymin(int a , int b)
{
x = a;
v = b;
}
};
deque<mymin>nowmin;
int main()
{
int n , a , b;
while(~scanf("%d%d%d" , &n , &a , &b))
{
int t = a % b;//因为a是要用来判断距离的，所以不能让a变化
nowmin.clear();
int test = 1;
int ans = 1;
for(int i = 1; i <= n ; ++ i)
{
test = (long long)test * t % b;
while(!nowmin.empty() && nowmin.front().x < i - a)
{
nowmin.pop_front();
}
while(!nowmin.empty() && nowmin.back().v >= test)
{
nowmin.pop_back();
}
nowmin.push_back(mymin(i , test));
ans = (long long)ans * nowmin.front().v % b;
}
printf("%d\n", ans);
}
return 0;
}

hdu 4122 Alice’s mooncake shop

简单的用单调队列模拟一下，算个日期就好了。。但是这道题要是hour的数量级再大一点，估计就gg了。。

#include <cstdio>
#include <deque>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
using namespace std;
int ding[1000010];
int p[1000010];
void finddate(string month , int day ,int year , int  hour , int r)
{
int finmonth;
if(month == "Jan")
finmonth = 1;
else if(month == "Feb")
finmonth = 2;
else if(month == "Mar")
finmonth = 3;
else if(month == "Apr")
finmonth = 4;
else if(month == "May")
finmonth = 5;
else if(month == "Jun")
finmonth = 6;
else if(month == "Jul")
finmonth = 7;
else if(month == "Aug")
finmonth = 8;
else if(month == "Sep")
finmonth = 9;
else if(month == "Oct")
finmonth =10;
else if(month == "Nov")
finmonth = 11;
else
finmonth = 12;
int finhour = (day - 1) * 24 + hour + 1;
for(int i = 2000 ; i < year ; ++ i)
{
if(i % 400 == 0 || (i % 4 == 0 && i % 100 != 0))
{
finhour += 366 * 24;
}
else
{
finhour += 365 * 24;
}
}
for(int i = 1 ; i < finmonth ; ++ i)
{
if(i == 1 || i == 3 || i == 5 || i ==7 || i == 8 || i == 10 || i == 12)
{
finhour += 31 * 24;
}
else if(i != 2)
{
finhour += 30 *24;
}
else
{
if(year % 400 == 0 || (year % 4 == 0 && year % 100 != 0))
{
finhour += 29 * 24;
}
else
{
finhour += 28 * 24;
}
}
}
ding[finhour] += r;
}
struct mine
{
int x;
int v;
mine(int a , int b)
{
x = a;
v = b;
}
};
deque<mine>mymin;
int main()
{
int n , m;
while(~scanf("%d%d" , &n , &m))
{
if(n == 0 && m == 0)
break;
memset(ding, 0 , sizeof(ding));
while(n --)
{
string month;
int day , year , h , r;
cin>>month;
scanf("%d%d%d%d" , &day , &year , &h , &r);
finddate(month , day , year , h , r);
}
int t , s;
scanf("%d%d" , &t , &s);
long long ans = 0;
mymin.clear();
for(int i = 1; i <= m ; ++ i)
{
scanf("%d", &p[i]);
while(!mymin.empty() && mymin.front().x < i - t)
{
mymin.pop_front();
}
int test = p[i] - i * s;
while(!mymin.empty() && mymin.back().v >= test)
{
mymin.pop_back();
}
mymin.push_back(mine(i , test));
if(ding[i])
{
ans += ding[i] * (mymin.front().v + s * i);
}
}
printf("%I64d\n" ,ans);
}
return 0;
}

poj 1821 Fence

不折不扣的三个半天。。这道题。。

觉得是本专题目前做到过的最难的题目了。。

#include <cstdio>
#include <iostream>
#include <deque>
#include <cstring>
#include <string>
using namespace std;
struct myworks
{
int l;
int p;
int s;
}work[110];
int dp[100010];//前n面墙的最大金钱
struct maxer
{
int x;
int v;
maxer(int a , int b)
{
x = a;
v = b;
}
};
int main()
{
int  n , k;
while(~scanf("%d%d" , &n , &k))
{
for(int i = 1; i <= k ; ++ i)
{
scanf("%d%d%d" , &work[i].l , &work[i].p , &work[i].s);
}
memset(dp , 0 ,sizeof(dp));
deque<maxer>nowmax[110];//用来表示，每一个工人他的刷墙起点
for(int i = 0; i <= k ; ++ i)
{
nowmax[i].clear();
}
for(int i = 1; i <= n ; ++ i)
{
for(int j = 1; j <= k ; ++ j)
{
if(work[j].s - work[j].l + 1 <= i && work[j].s + work[j].l - 1 >= i)//选出可以刷这面墙的工人
{
while(!nowmax[j].empty() && nowmax[j].front().x < i - work[j].l + 1)//如果这名工人从一开始刷的墙不能到达当前的墙，若他要刷这面墙，那么，他的起点就要改变
{
nowmax[j].pop_front();
}
if(work[j].s >= i)//工人刷墙起点的抉择，起点必须是小于等于s。
{
int test = dp[i - 1] - work[j].p * (i - 1);//工人的钱，因为此时已经处理好dp【i - 1】，dp【i】 = dp[i - 1] + work[i].p = dp[i - 1] - work[j].p * (i - 1) + work[j].p * i所以可以当做这名工人从头以work[j].p * (i - 1) 的钱干起，然后干到终点,这一点最关键了，比如，dp【i- a】是工人A干的，要是dp【i】也是工人A干的话，那么nowmax【a】。front（）。v应该是相等的，然而，要是dp【i】时A的test大了，说明中间有更好的工人替代了A。同时也解决了：要是这面墙被工人A刷了，把工人B的起点给占领了,那么B就刷不了后面的墙，此时要抉择是否值得刷这面墙
while(!nowmax[j].empty() && nowmax[j].back().v < test)//要是有更好的工人，那么就选择更好的工人，把A从front到i的之间的记录kill掉
{
nowmax[j].pop_back();
}
nowmax[j].push_back(maxer(i , test));//此时的nowmax【j】。front是j工人可以到达i的最大价值
}
if(!nowmax[j].empty() && nowmax[j].front().x + work[j].l - 1 >= i && work[j].s <= i)//枚举所有符合条件的work，得出最大值
dp[i] = max(nowmax[j].front().v + work[j].p * i, dp[i]);
}
}
dp[i] = max(dp[i - 1] , dp[i]);//这里很重要，要是这面墙没人刷的了，那么这面墙我就不刷，要是要实现刷这面墙，就不能让实力派A刷这面墙，要必须让超级无敌大蒟蒻me刷这面墙，当然不让me刷喽。。
}
printf("%d\n" , dp
);
}
return 0;
}

poj 2559 Largest Rectangle in a Histogram

这道题去年寒假用dp做的，现在学了新知识，发现还是dp优秀。

#include <cstdio>
#include <iostream>
#include <deque>
#include <algorithm>
using namespace std;
int h[100010];
struct mine
{
int l;
int r;
}me[100010];
deque<int>lefts;
deque<int>rights;
int main()
{
int n;
while(~scanf("%d", &n) && n)
{
for(int i = 1; i <= n ; ++ i)
{
scanf("%d" , &h[i]);
}
lefts.clear();
rights.clear();
for(int i = 1; i <= n ; ++ i)
{
while(!lefts.empty() && h[i] <= h[lefts.back()])//从左往右跑，查找每个h【i】的最大延伸长度，之所以可以用单调队列，是应为这道题，小的h【i】，可以切断前后的联系，只要看准小的h【i】就可以了
{
lefts.pop_back();
}
if(lefts.empty())
{
me[i].l = 1;
}
else
{
me[i].l = lefts.back() + 1;
}
lefts.push_back(i);
}
for(int i = n ; i >= 1 ; -- i)
{
while(!rights.empty() && h[i] <= h[rights.back()])//同
{
rights.pop_back();
}
if(rights.empty())
{
me[i].r = n;
}
else
{
me[i].r = rights.back() - 1;
}
rights.push_back(i);
}
long long ans = 0;//这里wa最不能忍了。。。。
for(int i = 1 ; i <= n ; ++ i)
{
ans = max(ans , (long long)(me[i].r - me[i].l + 1) * h[i]);
}
printf("%I64d\n" , ans);
}
return 0;
}

这是现在的我写的dp。。和寒假差不多的样子。。

因为，我们知道了，前一个me - 1的最大延伸长度，如果me比它小，自然可以延伸下去，到时候就看可不可以跨出边界了，else 我立刻就知道它的边界了

#include <cstdio>
#include <iostream>
#include <deque>
#include <stack>
using namespace std;
int h[100010];
struct zy
{
int l;
int r;
}me[100010];
int main()
{
int n;
while(~scanf("%d", &n) && n)
{
for(int i = 1; i <= n ; ++ i)
{
scanf("%d", &h[i]);
}
h[0] = -1;
h[n + 1] = -1;
for(int i = 1; i <= n ; ++ i)
{
int now =  i - 1;
while(h[i] <= h[now])
{
now = me[now].l;
}
me[i].l = now;
}
for(int i = n ; i >= 1 ; -- i)
{
int now =  i + 1;
while(h[i] <= h[now])
{
now = me[now].r;
}
me[i].r = now;
}
long long ans = -0x3f3f3f3f;
for(int i = 1; i <= n ; ++ i)
{
ans = max(ans , (long long)h[i] * (me[i].r - me[i].l - 1));
}
printf("%I64d\n", ans);
}
return 0;
}

codeforces 91B - Queue

很郁闷的读错题了，导致浪费好久好久orz。。

因为问的是最远的，所以维护序列递减就可以了。因为那些比当前判断值大的数字根本没有判断的意义。复杂度计算是nlogn ，那就二分查找一下就好了，，然后计算一下距离就可以了

#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <algorithm>
#include <deque>
#include <vector>
using namespace std;
vector<int>savemin;
vector<int>num;
int a[100010];
int ans[100010];
int main()
{
int n;
scanf("%d" , &n);
for(int i = 1; i <= n ; ++ i)
{
scanf("%d" , &a[i]);
}
savemin.push_back(a
);
num.push_back(n);
ans
= -1;
for(int i = n - 1; i >= 1; -- i)
{
if(a[i] <= savemin.back())
{
ans[i] = -1;
savemin.push_back(a[i]);
num.push_back(i);
}
else
{
int p = savemin.rend() - lower_bound(savemin.rbegin() , savemin.rend() , a[i]);
ans[i] = num[p] - i - 1;
}
}
for(int i = 1; i <= n ; ++ i)
{
printf("%d" , ans[i]);
if(i == n)
printf("\n");
else
printf(" ");
}
return 0;
}

codeforces 372 C Watching Fireworks is Fun

这道题就是单调队列的简单模拟了，因为st会爆炸。dp保存上个时代的最优值，最优的来自左边（包括自己）或者右边（包括自己）于是，就左跑一遍又跑一遍就好了，然后得到了cf上可以跑e9这个惊人的消息。。

但是感觉自己的复杂度实在是太高了，然而懒惰的我不知道怎么优化。。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <deque>
#include <cmath>
using namespace std;
long long dp[150010];
long long test[150010];
int main()
{
long long n , m , d;
scanf("%I64d%I64d%I64d" , &n , &m , &d);
long long a , b , t;
scanf("%I64d%I64d%I64d" , &a , &b , &t);
for(int i = 1; i <= n ; ++ i)
{
dp[i] = b - abs(a - i);
}
deque<long long>findmax;
long long oldt = t;
for(int i = 1; i < m ; ++ i)
{
scanf("%I64d%I64d%I64d" ,&a , &b , &t);
findmax.clear();
long long chat= t - oldt;
oldt = t;
for(int j = 1; j <= n ; ++ j)
{
while(!findmax.empty() && findmax.front() <  j - d * chat)
{
findmax.pop_front();
}
while(!findmax.empty() && dp[findmax.back()] <= dp[j])
{
findmax.pop_back();
}
findmax.push_back(j);
test[j] = dp[findmax.front()];
}
findmax.clear();
for(int j = n; j >= 1 ; -- j)
{
while(!findmax.empty() && findmax.front() >  j + d * chat)
{
findmax.pop_front();
}
while(!findmax.empty() && dp[findmax.back()] <= dp[j])
{
findmax.pop_back();
}
findmax.push_back(j);
test[j] = max(dp[findmax.front()] , test[j]);
}
for(int j = 1; j <= n ; ++ j)
{
dp[j] = test[j] + b - abs(a - j);
}
}
long long ans = -0x3f3f3f3f;
for(int i = 1; i <= n; ++ i)
{
ans = max(ans , dp[i]);
}
printf("%I64d\n" ,ans);
return 0;
}

codeforces 251 A Points on Line

这道题，就是计算组合数，为了防止重复，那就在组合数里面确定最大的那个数，然后另外两个组合一下。。

#include <cstdio>
#include <iostream>
#include <deque>
using namespace std;
deque<int>me;
int main()
{
int n , k;
scanf("%d%d" , &n , &k);
int test;
scanf("%d", &test);
me.push_back(test);
long long ans = 0;
for(int i = 1; i < n ; ++ i)
{
scanf("%d" , &test);
while(!me.empty() && test - me.front() > k)
{
me.pop_front();
}
if(me.size() > 1)
ans += (long long)me.size() * (me.size() - 1) / 2;
me.push_back(test);
}
printf("%I64d\n" , ans);
return 0;
}

codeforces 253 D. Table with Letters - 2

这道题想了近3小时。。。 因为一开始没想到矩阵中套矩阵的合适方法

联系到上面有一道works的题目，瞬间的懂了。。who【id】表示当前这个字母所拥有的a，这样就出来了。。

#include <cstdio>
#include <deque>
#include <iostream>
using namespace std;
char way[410][410];
long long a[410][410];
int main()
{
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
int n , m , key;
scanf("%d%d%d" , &n , &m, &key);
for(int i = 1; i <= n ; ++i)
{
scanf("%s" , way[i] + 1);
for(int j = 1; j <= m; ++ j)
{
if(way[i][j] == 'a')
{
a[i][j] = a[i - 1][j] + 1;
}
else
{
a[i][j] = a[i - 1][j];
}
}
}
deque<int>who[26];
long long ans = 0;
for(int i = 1; i < n ; ++ i)
{
for(int j = i + 1 ; j <= n; ++ j)
{
for(int k = 0; k < 26 ; ++ k)
{
who[k].clear();
}
int sum = 0;
for(int k = 1 ; k <= m; ++ k)
{
sum = sum + a[j][k] - a[i - 1][k];
if(way[i][k] == way[j][k])
{
int id = way[i][k] - 'a';
while(!who[id].empty() && sum - who[id].front() > key)
{
who[id].pop_front();
}
ans += who[id].size();
who[id].push_back(sum - a[j][k] + a[i - 1][k]);
}
}
}
}
printf("%I64d\n" ,ans);
return 0;
}

poj 2823 Sliding Window

水题。。

但是看discuss有人用一维st。。好厉害。。

#include <cstdio>
#include <iostream>
#include <deque>
using namespace std;
int a[1000010];
int testmax[1000010];
int testmin[1000010];
deque<int>leftmax,rightmax,leftmin,rightmin;
int main()
{
int n , k;
while(~scanf("%d%d" , &n ,&k))
{
for(int i = 1; i <= n ; ++ i)
{
scanf("%d" ,&a[i]);
}
leftmin.clear();
leftmax.clear();
for(int i = 1; i <= n; ++ i)
{
while(!leftmax.empty() && leftmax.front() <= i - k)
{
leftmax.pop_front();
}
while(!leftmax.empty() && a[leftmax.back()] <= a[i])
{
leftmax.pop_back();
}
leftmax.push_back(i);
testmax[i] = a[leftmax.front()];
}
for(int i = 1; i <= n; ++ i)
{
while(!leftmin.empty() && leftmin.front() <= i - k)
{
leftmin.pop_front();
}
while(!leftmin.empty() && a[leftmin.back()] >= a[i])
{
leftmin.pop_back();
}
leftmin.push_back(i);
testmin[i] = a[leftmin.front()];
}
for(int i = k; i <= n; ++ i)
{
printf("%d" , testmin[i]);
if(i != n )
printf(" ");
else
printf("\n");
}
for(int i = k; i <= n; ++ i)
{
printf("%d" , testmax[i]);
if(i != n )
printf(" ");
else
printf("\n");
}
}
return 0;
}

下面是一维st的解释。。感觉就是很一般的dp。。。

#include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;
int dpmax[1000010];
int dpmin[1000010];
int main()
{
int n , k;
while(~scanf("%d%d" , &n , &k))
{
for(int i = 1; i <= n ; ++ i)
{
scanf("%d" , &dpmax[i]);
dpmin[i] = dpmax[i];
}
for(int i = 1 ; i <= k / 2 ; i = (i << 1))//代表的是区间的长度 - 1 以为自己还要算进来，区间长度为2的时候（i==1）。为何是二进制呢？我认为，首先是和位运算联系起来，然后就是。当处理好长度1 的是后，我们只能先处理长度2，得到的比如说max（1,2），max（3,4），现在当处理长度3的时候，就是max（处理好的（1，2），3），但是我们已经处理好（3,4），这样在处理max（max（1,2），max（3，4））的时候，就把max（1,2,3）处理好了。如果比如说题目给的长度是3，那么就不可以处理长度是2的时候。。因为把4牵扯进来了。。所以，需要知道的长度就是k/2；
{
for(int j = 1 ; j + i <= n ; ++ j)//枚举区间的起点
{
dpmax[j] = max(dpmax[j] , dpmax[j + i]);
dpmin[j] = min(dpmin[j] , dpmin[j + i]);
}
}
int key = (int)(log(k * 1.0) / log(2.0));
for(int i = 1; i <= n - k + 1; ++ i)
{
printf("%d" , min(dpmin[i] , dpmin[i + k - (1 << key)]));//一个代表左端点的值，一个代表右端点的值。画两个相交的圆就知道了。。，对于为何是key。比如我的区间长度是x，那么此时，front + k / 2 ，back - k / 2 , 这两段比较是最好的，但是为了配合上面的方法，我现在已知的是比k / 2小但是最接近k / 2的 2的x次方，那么就可以数学推导出x <= log(k) / log(2) - 1;,此时，因为log(k) / log(2)会有偏差，于是就在两边+1，这样就可以最近似的表示区间了。。
if(i == n - k + 1)
printf("\n");
else
printf(" ");
}
for(int i = 1; i <= n - k + 1 ; ++ i)
{
printf("%d" , max(dpmax[i] , dpmax[i + k - (1 << key)]));
if(i == n - k + 1)
printf("\n");
else
printf(" ");
}

}
return 0;
}

FZU 1894 志愿者选拔

简单的用单调队列模拟一下就好了。。

#include <cstdio>
#include <iostream>
#include <deque>
using namespace std;
char flag[10];
struct mine
{
int x;
int me;
mine(int a, int b)
{
x = a;
me = b;
}
};
deque<mine>all;
int main()
{
int T;
scanf("%d" , &T);
while(T --)
{
scanf("%s" , flag);
all.clear();
int cnt = 0;
int num = 0;
while(1)
{
scanf("%s" ,flag);
if(flag[0] == 'E')
break;
else if(flag[0] == 'C')
{
char name[10];
int test;
scanf("%s" , name);
scanf("%d" , &test);
while(!all.empty() && all.back().me <= test)
{
all.pop_back();
}
cnt ++ ;
all.push_back(mine(cnt , test));
}
else if(flag[0] == 'Q')
{
if(all.empty())
printf("-1\n");
else
printf("%d\n" , all.front().me);
}
else
{
num ++;
while(!all.empty() && all.front().x <= num)
{
all.pop_front();
}
}
}
}
return 0;
}

poj 2019 Cornfields

这道题二维的st算法，说白了，就是一维。。

没处理完一个横的，就处理所有的竖的 i，j代表区间长度2的i次，2的j次

我也不是很懂：为何用deque写一直wa ，但是指针写，就可以很快的过。。。

#include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;
int dpmax[255][255][8][8];
int dpmin[255][255][8][8];
int main()
{
int n, b, k;
scanf("%d%d%d", &n , &b ,&k);
for(int i = 0 ; i < 9 ;++ i)
{
for(int j = 0 ; j < 9 ; ++ j)
{
for(int x = 1 ; x + (1 << i) - 1<= n ; ++ x)
{
for(int y = 1; y + (1 << j) - 1 <= n ; ++ y)
{
if(i == 0)
{
if(j == 0)
{
scanf("%d", &dpmax[x][y][i][j]);
dpmin[x][y][i][j] = dpmax[x][y][i][j];
}
else
{
dpmax[x][y][i][j] = max(dpmax[x][y][i][j - 1] , dpmax[x][y + (1 << (j - 1))][i][j - 1]);
dpmin[x][y][i][j] = min(dpmin[x][y][i][j - 1] , dpmin[x][y + (1 << (j - 1))][i][j - 1]);
}
}
else
{
dpmax[x][y][i][j] = max(dpmax[x][y][i - 1][j] , dpmax[x + (1 << (i - 1))][y][i - 1][j]);
dpmin[x][y][i][j] = min(dpmin[x][y][i - 1][j] , dpmin[x + (1 << (i - 1))][y][i - 1][j]);
}
}
}
}
}
int key = (int)(log(b * 1.0) / log(2.0));
while(k -- )
{
int sx , sy;
scanf("%d%d", &sx , &sy);
int ex = sx + b - 1;
int ey = sy + b - 1;
printf("%d\n", max(max(dpmax[sx][sy][key][key] , dpmax[ex - (1 << key) + 1][ey - (1 << key) + 1][key][key]) , max(dpmax[ex - (1 << key) + 1][sy][key][key] , dpmax[sx][ey - (1 << key) + 1][key][key])) - min(min(dpmin[sx][sy][key][key] , dpmin[ex - (1 << key) + 1][ey - (1 << key) + 1][key][key]) , min(dpmin[ex - (1 << key) + 1][sy][key][key] , dpmin[sx][ey - (1 << key) + 1][key][key])));
}
return 0;
}

一个星期的时间。。一半是在忙这个。。我好菜啊。。。。。