2019牛客多校第三场F题题解

最新推荐文章于 2020-07-19 00:10:11 发布
最新推荐文章于 2020-07-19 00:10:11 发布
阅读量188 收藏
点赞数
分类专栏： 数据结构 优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43083173/article/details/97398464
版权

二维st表解法：

#include<bits/stdc++.h>
#define endl '\n'
#define css(n) cout<<setiosflags(ios::fixed)<<setprecision(n);
#define sd(a) scanf("%d",&a)
#define sld(a) scanf("%lld",&a)
#define m(a,b) memset(a,b,sizeof a)
#define pb push_back
#define lson id<<1
#define rson id<<1|1
typedef long long ll;
using namespace std;
const int maxn = 550,modd = 1e9 + 7,inf = 0x3f3f3f3f,INF = 0x7fffffff;
inline ll min(ll a,ll b){return a < b ? a : b;}
inline ll max(ll a,ll b){return a > b ? a : b;}
inline ll gcd(ll a,ll b){ return b==0? a: gcd(b,a%b); }
inline ll exgcd(ll a,ll b,ll &x,ll &y){ ll d; (b==0? (x=1,y=0,d=a): (d=exgcd(b,a%b,y,x),y-=a/b*x)); return d; }
inline ll qpow(ll a,ll n){ll sum=1;while(n){if(n&1)sum=sum*a%modd;a=a*a%modd;n>>=1;}return sum;}
inline ll qmul(ll a,ll n){ll sum=0;while(n){if(n&1)sum=(sum+a)%modd;a=(a+a)%modd;n>>=1;}return sum;}
inline ll inv(ll a) {return qpow(a,modd-2);}//求逆元
inline ll madd(ll a,ll b){return (a%modd+b%modd)%modd;}//加后取模
inline ll mmul(ll a,ll b){return a%modd * b%modd;}//乘后取模
int n,m,t;
int h[maxn][maxn];
int lg[maxn],p[20],ans;
int fmx[20][20][maxn][maxn],fmi[20][20][maxn][maxn];
void pre()
{
    lg[0]=-1,p[0]=1;
  for(int i=1;i<=19;i++)  p[i]=p[i-1]<<1;
  for(int i=1;i<maxn;i++) lg[i]=lg[i>>1]+1;
}
 
void get_st(int n,int m)//对1~n，1~m的h处理
{
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
    fmi[0][0][i][j]=fmx[0][0][i][j]=h[i][j];
    for(int ii=0;p[ii]<=n;ii++)
    for(int jj=0;p[jj]<=m;jj++)
  {
    if(ii==0&&jj==0) continue;
    for(int i=1;i+p[ii]-1<=n;i++)
    for(int j=1;j+p[jj]-1<=m;j++)
    {
      if(ii)
      {
        fmi[ii][jj][i][j] = min(fmi[ii-1][jj][i][j],fmi[ii-1][jj][i+p[ii-1]][j]);
        fmx[ii][jj][i][j] = max(fmx[ii-1][jj][i][j],fmx[ii-1][jj][i+p[ii-1]][j]);
      }
      else
      {
        fmi[ii][jj][i][j] = min(fmi[ii][jj-1][i][j],fmi[ii][jj-1][i][j+p[jj-1]]);
        fmx[ii][jj][i][j] = max(fmx[ii][jj-1][i][j],fmx[ii][jj-1][i][j+p[jj-1]]);
      }
    }
  }
}
 
int ask_max(int x1,int y1,int x2,int y2)
{
    int r=lg[x2-x1+1],c=lg[y2-y1+1];
    int a=x2-(1<<r)+1,b=y2-(1<<c)+1;
    return max(max(fmx[r][c][x1][y1],fmx[r][c][x1][b]),max(fmx[r][c][a][y1],fmx[r][c][a][b]));
}
 
int ask_min(int x1,int y1,int x2,int y2)
{
    int r=lg[x2-x1+1],c=lg[y2-y1+1];
    int a=x2-(1<<r)+1,b=y2-(1<<c)+1;
    return min(min(fmi[r][c][x1][y1],fmi[r][c][x1][b]),min(fmi[r][c][a][y1],fmi[r][c][a][b]));
}
 
bool ok(int x1,int y1,int x2,int y2)
{
    int mx=ask_max(x1,y1,x2,y2);
    int mi=ask_min(x1,y1,x2,y2);
    return mx-mi<=m;
}
int main()
{
//  std::ios::sync_with_stdio(0);
//  std::cin.tie(0);std::cout.tie(0);
    pre();
    sd(t);
    while(t--)
    {
        sd(n);sd(m);
        ans=0;
        for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
        sd(h[i][j]);
        get_st(n,n);
        for(int i=1;i<=n;i++)
        for(int j=i;j<=n;j++)
        {
            if((j-i+1)*n<ans) continue;
            int ll=1;
            int rr;
            if(ans==0) rr=1; else rr=ans/(j-i+1)+1;
            while(rr<=n)
            {
                if((j-i+1)*(n-ll+1)<=ans) break;
                if(ok(ll,i,rr,j))
                {
                    ans=max(ans,(j-i+1)*(rr-ll+1));
                    rr++;
                }
                else
                {
                    ll++;rr++;
                }
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

deque写的单调队列解法：

#include<bits/stdc++.h>
#define endl '\n'
#define css(n) cout<<setiosflags(ios::fixed)<<setprecision(n); 
#define sd(a) scanf("%d",&a)
#define sld(a) scanf("%lld",&a)
#define m(a,b) memset(a,b,sizeof a)
#define pb push_back 
#define lson id<<1
#define rson id<<1|1
typedef long long ll;
using namespace std;
const int maxn = 550,modd = 1e9 + 7,inf = 0x3f3f3f3f,INF = 0x7fffffff;
inline ll min(ll a,ll b){return a < b ? a : b;}
inline ll max(ll a,ll b){return a > b ? a : b;}
inline ll gcd(ll a,ll b){ return b==0? a: gcd(b,a%b); }
inline ll exgcd(ll a,ll b,ll &x,ll &y){ ll d; (b==0? (x=1,y=0,d=a): (d=exgcd(b,a%b,y,x),y-=a/b*x)); return d; }
inline ll qpow(ll a,ll n){ll sum=1;while(n){if(n&1)sum=sum*a%modd;a=a*a%modd;n>>=1;}return sum;}
inline ll qmul(ll a,ll n){ll sum=0;while(n){if(n&1)sum=(sum+a)%modd;a=(a+a)%modd;n>>=1;}return sum;}
inline ll inv(ll a) {return qpow(a,modd-2);}//求逆元 
inline ll madd(ll a,ll b){return (a%modd+b%modd)%modd;}//加后取模 
inline ll mmul(ll a,ll b){return a%modd * b%modd;}//乘后取模 
int n,m,t;
typedef pair<int,int> pr;
deque<pr> add;
deque<pr> down;
int h[maxn][maxn];
int fmx[maxn];
int fmi[maxn];
int ans;
int main()
{
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);std::cout.tie(0);
	sd(t);
	while(t--)
	{
		sd(n);sd(m);
		ans=0; 
		for(int i=1;i<=n;i++)for(int j=1;j<=n;j++) sd(h[i][j]);
		for(int i=1;i<=n;i++)//上边界 
		{
			for(int j=1;j<=n;j++)
			{
				fmx[j]=0;fmi[j]=INF;
			 } 
			for(int j=i;j<=n;j++)//下边界 
			{
				for(int k=1;k<=n;k++)
				{
					fmx[k]=max(fmx[k],h[j][k]);
					fmi[k]=min(fmi[k],h[j][k]);
				}
				if((j-i+1)*n<=ans) continue;
				add.clear();down.clear();
				int ll=1;
				for(int k=1;k<=n;k++)
				{
					while(!add.empty()&&add.front().second<ll) add.pop_front();
					while(!down.empty()&&down.front().second<ll) down.pop_front();
					while(!add.empty()&&add.back().first<=fmx[k]) add.pop_back();
					while(!down.empty()&&down.back().first>=fmi[k]) down.pop_back();
					add.push_back(pr(fmx[k],k));down.push_back(pr(fmi[k],k));
					while(ll<=k&&!add.empty()&&!down.empty()&&add.front().first-down.front().first>m)
						{
							int zzz=min(add.front().second,down.front().second);
							ll=zzz+1;
							while(!add.empty()&&add.front().second<ll) add.pop_front();
				        	while(!down.empty()&&down.front().second<ll) down.pop_front();
						}
						ans=max(ans,(j-i+1)*(k-ll+1));
				 } 
			 } 
		}
		printf("%d\n",ans);
	 } 
	return 0;
}

数组模拟的单调队列解法（极快，1200+ms）

#include <iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=550;
const int INF = 0x3f3f3f3f;
int fda[550];
int fxi[550];
int a[550][550];
inline int read(){
   int s=0,w=1;
   char ch=getchar();
   while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
   while(ch>='0'&&ch<='9') s=s*10+ch-'0',ch=getchar();
   return s*w;
}
int q1[550][2];
int q2[550][2];
int q1l,q1r,q2l,q2r;
int n,m,t;
int main(){
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            scanf("%d",&a[i][j]);
        }
    }
    ll ans=0;
    for(int i=1;i<=n;i++)
    {
        for(int q=1;q<=n;q++){
            fda[q]=0;
            fxi[q]=INF;
        }
        for(int j=i;j<=n;j++)//下边界
        {
            for(int q=1;q<=n;q++){
                fda[q]=max(a[j][q],fda[q]);
                fxi[q]=min(a[j][q],fxi[q]);
            }
            int l=1;
            q1l=1,q1r=0,q2l=1,q2r=0;
            if((j-i+1)*n<ans) continue;
            for(int k=1;k<=n;k++)
            {
                while(q1r>=q1l&&q1[q1r][0]<=fda[k])
                {
                    q1r--;
                }
                q1r++;
                q1[q1r][0]=fda[k];
                q1[q1r][1]=k;
                while(q2r>=q2l&&q2[q2r][0]>=fxi[k]){
                    q2r--;
                }
                q2r++;
                q2[q2r][0]=fxi[k];
                q2[q2r][1]=k;
                    while(l<=k&&q1[q1l][0]-q2[q2l][0]>m)
                    {
                        if(q1[q1l][1]>q2[q2l][1])
                        {
                            l=q2[q2l][1]+1;
                            q2l++;
                            if(q2r<q2l) break;
                        }
                        else if(q1[q1l][1]<q2[q2l][1])
                        {
                            l=q1[q1l][1]+1;
                            q1l++;
                            if(q1r<q1l) break;
                        }else
                        {
                            l=q1[q1l][1]+1;
                            q1l++;
                            q2l++;
                            if(q1r<q1l) break;
                            if(q2r<q2l) break;
                        }
                      
                }
                ans=max(ans,(ll)(j-i+1)*(ll)(k-l+1));
  
            }
        }
    }
    printf("%lld\n",ans);
    }
}
V4yne.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2019牛客暑期多校训练营（第三场）F 单调队列+暴力枚举
W349652743的博客
07-26 147
题意：问你最大数字-最小数字<=k的最大矩阵的面积 题解：首先枚举上下边界，计算出每一列的最大元素和最小元素，就能把j-i+1行的元素压缩到一行。 然后枚举r用两个单调队列维护最大值最小值，如果最大值-最小值>k就更新左边界，同时更新单调队列的队头 #include <bits/stdc++.h> using namespace std; typedef long ...
2019年牛客多校第三场 F（暴力+思维+模拟单调队列）
weixin_43843730的博客
07-26 199
2019年牛客多校第三场 F（暴力+思维+模拟单调队列） 题意：找一个最大子矩阵，在这个子矩阵中最大的元素减去最小的元素，差值小于K。 题解： A：首先，暴力遍历每一列，找到每一列的最大值，最小值。（这里不是简单的遍历） 比如有3*3的矩阵，第1行所有列（每一列的最大值，最小值），第1-2行所有列（每一列的最大值，最小值），第1-3行；第2行，第2-3行，第3行。等等以此类推记录 B：然后，开始从...
2019牛客多校第三场F-Planting Trees（单调队列）
qq_41648012的博客
07-28 240
#include<bits/stdc++.h> using namespace std; const int MAX_N=500+5; int n,m; int a[MAX_N+1][MAX_N+1]; int b1[MAX_N+1],b2[MAX_N+1]; int q1[MAX_N+1],q2[MAX_N+1]; void solve(){ int res=0; ...
2019牛客多校第三场 F.Planting Trees（单调队列）
Cymbals的博客
07-29 320
题目明确表示要用n3的的算法做。 因此枚举矩阵的上下边界和右边界，再用两个单调队列维护左边界。 #include <bits/stdc++.h> using namespace std; typedef long long ll; const int maxn = 505; int t, n, m, num[maxn][maxn]; int maxx[maxn], minn[m...
2019牛客暑期多校训练营（第三场）F：Planting Trees（单调队列）
菜鸡成长史
07-25 345
【题意】 给定区域大小n*n的网格和m，要求输出最大的矩形满足任意两个位置的差值不超过m的面积。 【题解】 思路：枚举上下边界和右边界，用两个单调队列维护最小左边界，更新最大面积。如何维护？以最大值为例，因为如果当前的最大最小值不满足<=m，那么我们需要更小的最大值，所以需要的单调队列是递减的，因此在维护的时候我们每次入队时弹出比当前最大值小的元素。 【代码】 #include&...
2019 牛客多校 第三场 F Planting Trees（单调队列，子矩阵最大-最小 ≤ m的最大子矩阵大小）
Error Man 的博客
07-25 402
Planting Trees The semester is finally over and the summer holiday is coming. However, as part of your university's graduation requirement, you have to take part in some social service during the hol...
2020牛客暑期多校集训营第二场题解.pdf
01-20
### 2020牛客暑期多校集训营第二场题解 #### Gromah 题目解析 在本次解析中，我们将逐一探讨各题目的关键算法思想和技术细节。 ### A. All with Pairs (全部配对) 本题讨论了如何利用哈希表来解决一对对字符串的...
2018牛客暑期多校第二场题解
09-28
### 2018牛客暑期多校第二场题解 #### 题目一：健身计划（laofudasuan） **题目大意** 白云正在制定一个健身计划，每秒可以选择步行1米或者跑步k米（k为常数），但不能连续两秒都跑步。当白云累计行走的距离在[L,R...
2020牛客暑期多校第一场讲课笔记版本题解1
08-03
3. 有向图的生成树计数(Domino Flip Graphs): 提到了Domino翻转图中的距离计算，可以通过"Lagrange Duality"证明，答案是b的转置乘以矩阵A的逆再乘以b。这在图论和网络流问题中常见。 4. 二次型(Quadratic Form): ...
2019牛客暑期多校训练营（第三场）F
PL博客
07-26 158
题目链接：https://ac.nowcoder.com/acm/contest/883/F 思路：枚举上下边界，以及右边界即可。那么在我们知道上下边界时，怎样快速地计算最大的矩阵呢，注意到我们枚举右边界时是 从左到右的，左边的数我们知道了，就要想办法充分利用这些信息，假设对于每一列的最大值以及最小值我们都是知道的，那么用两个单调队列分别维护最小值最大值，最小值递增，最大值递减。那么在...
暑假牛客多校赛第三场F.Planting Trees(单调队列)
Slime
07-26 229
F.Planting Trees 传送门 The semester is finally over and the summer holiday is coming. However, as part of your university’s graduation requirement, you have to take part in some social service during th...
2019牛客暑假多校训练营（第三场）
haohaoxuexilmy的博客
07-26 187
B：求一串01序列的最长子串，要求0、1个数相等。 把1看做-1，求一遍前缀和，如果s[r]-s[l-1]==0,满足条件，记录最开始的是s[l]在的位置。 #include<bits/stdc++.h> using namespace std; const int N =1000*100+10; char s[N]; int f[N]; int n; map<int,...
牛客多校第三场 F Sum Of Digit（线段树区间合并）
Lee_w_j__的博客
07-27 464
链接：https://www.nowcoder.com/acm/contest/141/F 来源：牛客网   题目描述 Eddy likes to play with digits. However, as you may know, Eddy is a programmer not a normal human. Thus, he likes to play with hexadecimal...
【牛客网 2019 多校第三场】 F - Planting Trees （思维，枚举）
t14 的博客
07-26 129
题目 思路 疯狂想法：6层for循环，O(N6)算法。 于是，看这句话： It is guaranteed that the sum of N3over all cases does not exceed 25 ⋅107 肯定是让你想O(N3)算法。 首先，枚举子矩阵的上下边界，维护上下边界的最大最小值。 然后接着枚举右边界。 可左边界怎么办呢，反正不能还枚举吧。 左边界显然具有单调不降性。 二分...
2019牛客多校第三场 F.Planting Trees
weixin_30312659的博客
07-25 144
题目链接 题目链接 题解 题面上面很明显的提示了需要严格\(O(n^3)\)的算法。 先考虑一个过不了的做法，枚举右下角的\((x,y)\)，然后二分矩形面积，枚举其中一边，则复杂度是\(O(n^3 \log n^2)\)的。 考虑另外一个做法，同样是枚举右下角\((x,y)\)，然后枚举一边长度，显然现在只需要知道左边最远能延伸到哪，这个玩意显然是有单调性的，那么尺取一下，套个单调队列判断即可。...
2019牛客第三场 F Planting Trees
binarycopycode
07-26 229
上次cf做了一道二维单调队列，于是在这里也枚举右下角的点用二维单调队列，结果好像不行，，， 最后题解是直接枚举上下边界，然后从左到右单调队列扫过去记录，记录当前右边界下最远的左边界可以在哪 中间超时，加了很多优化，结果是最后在mi[i]赋初值的地方出了问题，以前一直做1e5的题目，用maxl作最大值，结果这里数值大小是1e5，maxl只有500。。。 #include<bits/st...
2020牛客暑期多校训练营（第三场）F.Fraction Construction Problem(扩展欧几里得) 一个详细的题解
REXWind的博客
07-19 1947
题目大意： 给两个正整数a和b； 要求找到四个正整数c,d,e,f，满足ab=cd+ef\frac{a}{b}=\frac{c}{d}+\frac{e}{f}ba​=dc​+fe​ #include<iostream> #include<cstring> #include<cstdio> #include<algorithm> #include<vector> #include<map> #include<queue> #i
牛客暑期多校第二场题解：动态规划与环形DP应用
本资源是2018年牛客暑期多校第二场的ACM题解文档，主要涉及三个编程问题的解题思路和方法。 第一个问题是关于动态规划（Dynamic Programming，简称DP）的应用。题目名为"laofudasuan"，背景是白云健身的模拟。问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值