2020牛客暑期多校训练营（第二场） F、Fake Maxpooling （单调队列）

最新推荐文章于 2020-09-09 18:54:01 发布
最新推荐文章于 2020-09-09 18:54:01 发布
阅读量137 收藏
点赞数
分类专栏： 单调队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaoxinxin1234/article/details/107334861
版权
本文介绍了一道编程题目，涉及求解一个nm矩阵中大小为kk子矩阵最大值之和的问题。利用lcm计算和单调队列优化，实现了n*m log n的时间复杂度解法，避免了超时。同时提到了两种其他解决方案，包括不同数组处理和预处理gcd查询的方法。
摘要由CSDN通过智能技术生成

题目链接

题面：
在这里插入图片描述

题意：
给定一个nm的矩阵，其中aij = lcm( i , j )。
求所有大小为kk的子矩阵的最大值的和。

官方题解：
在这里插入图片描述

不过我的lcm是，n*m log n 求的。。。
还好没T。

代码：
①、
2304ms

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<string>
#include<queue>
#include<bitset>
#include<map>
#include<unordered_map>
#include<set>
#define ui unsigned int
#define ll long long
#define llu unsigned ll
#define ld long double
#define pr make_pair
#define pb push_back
#define lc (cnt<<1)
#define rc (cnt<<1|1)
#define len(x)  (t[(x)].r-t[(x)].l+1)
#define tmid ((l+r)>>1)
using namespace std;

const int inf=0x3f3f3f3f;
const ll lnf=0x3f3f3f3f3f3f3f3f;
const double dnf=1e18;
const int mod=1e9+7;
const double eps=1e-8;
const double pi=acos(-1.0);
const int hp=13331;
const int maxn=5100;
const int maxm=100100;
const int up=100000;

int a[maxn][maxn],b[maxn][maxn];
int c[maxn],q[maxn];

int gcd(int a,int b)
{
    if(a==0||b==0) return a|b;
    return gcd(b,a%b);
}

int lcm(int a,int b)
{
    return a/gcd(a,b)*b;
}

int main(void)
{
    int n,m,k;
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
            a[i][j]=lcm(i,j);
    }

    for(int i=1;i<=m;i++)
    {
        int l=1,r=0;
        for(int j=1;j<=n;j++)
        {
            while(l<=r&&q[l]<=j-k) l++;
            while(l<=r&&a[q[r]][i]<=a[j][i]) r--;
            q[++r]=j;
            b[j][i]=a[q[l]][i];
        }
    }

    ll ans=0;
    for(int i=1;i<=n;i++)
    {
        int l=1,r=0;
        for(int j=1;j<=m;j++)
        {
            while(l<=r&&q[l]<=j-k) l++;
            while(l<=r&&b[i][q[r]]<=b[i][j]) r--;
            q[++r]=j;
            if(i>=k&&j>=k)ans=ans+b[i][q[l]];
        }
    }
    printf("%lld\n",ans);
    return 0;
}

②、
开三个数组就会MLT。
888ms

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<string>
#include<queue>
#include<bitset>
#include<map>
#include<unordered_map>
#include<set>
#define ui unsigned int
#define ll long long
#define llu unsigned ll
#define ld long double
#define pr make_pair
#define pb push_back
#define lc (cnt<<1)
#define rc (cnt<<1|1)
#define len(x)  (t[(x)].r-t[(x)].l+1)
#define tmid ((l+r)>>1)
using namespace std;

const int inf=0x3f3f3f3f;
const ll lnf=0x3f3f3f3f3f3f3f3f;
const double dnf=1e18;
const int mod=1e9+7;
const double eps=1e-8;
const double pi=acos(-1.0);
const int hp=13331;
const int maxn=5100;
const int maxm=100100;
const int up=100000;

int a[maxn][maxn],b[maxn][maxn];
int c[maxn],q[maxn];

int main(void)
{
    int n,m,k;
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(!b[i][j])//i,j互质
            {
                for(int k=1;k*i<=n&&k*j<=m;k++)
                    b[k*i][k*j]=k,a[k*i][k*j]=i*j*k;
            }
        }
    }

    for(int i=1;i<=m;i++)
    {
        int l=1,r=0;
        for(int j=1;j<=n;j++)
        {
            while(l<=r&&q[l]<=j-k) l++;
            while(l<=r&&a[q[r]][i]<=a[j][i]) r--;
            q[++r]=j;
            b[j][i]=a[q[l]][i];
        }
    }

    ll ans=0;
    for(int i=1;i<=n;i++)
    {
        int l=1,r=0;
        for(int j=1;j<=m;j++)
        {
            while(l<=r&&q[l]<=j-k) l++;
            while(l<=r&&b[i][q[r]]<=b[i][j]) r--;
            q[++r]=j;
            if(i>=k&&j>=k)ans=ans+b[i][q[l]];
        }
    }
    printf("%lld\n",ans);
    return 0;
}

③、O（值域预处理），O（1）查询的gcd
1292ms

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<string>
#include<queue>
#include<bitset>
#include<map>
#include<unordered_map>
#include<set>
#define ui unsigned int
#define ll long long
#define llu unsigned ll
#define ld long double
#define pr make_pair
#define pb push_back
#define lc (cnt<<1)
#define rc (cnt<<1|1)
#define len(x)  (t[(x)].r-t[(x)].l+1)
#define tmid ((l+r)>>1)
using namespace std;

const int inf=0x3f3f3f3f;
const ll lnf=0x3f3f3f3f3f3f3f3f;
const double dnf=1e18;
const int mod=1e9+7;
const double eps=1e-8;
const double pi=acos(-1.0);
const int hp=13331;
const int maxn=5100;
const int maxm=100100;
const int up=100000;

int prime[maxn],fac[maxn][3],gcd[110][110],cnt=0;
bool ha[maxn];
int a[maxn][maxn],b[maxn][maxn];
int c[maxn],q[maxn];
int ppt;

void Prime(int n)
{
    ppt=sqrt(n)+1;
    fac[1][0]=fac[1][1]=fac[1][2]=1;
    ha[1]=true;
    for(int i=2;i<=n;i++)
    {
        if(!ha[i])
        {
            prime[cnt++]=i;
            fac[i][0]=fac[i][1]=1;
            fac[i][2]=i;
        }
        for(int j=0;j<cnt&&i*prime[j]<=n;j++)
        {
            int now=i*prime[j];
            ha[now]=true;
            fac[now][0]=fac[i][0]*prime[j];
            fac[now][1]=fac[i][1];
            fac[now][2]=fac[i][2];
            if(fac[now][0]>fac[now][1]) swap(fac[now][0],fac[now][1]);
            if(fac[now][1]>fac[now][2]) swap(fac[now][1],fac[now][2]);
            if(i%prime[j]==0) break;
        }
    }
    for(int i=0;i<=ppt;i++) gcd[i][0]=gcd[0][i]=i;
    for(int i=1;i<=ppt;i++)
        for(int j=1;j<=i;j++)
            gcd[i][j]=gcd[j][i]=gcd[j][i%j];
}

int gg(int a,int b)
{
    int ans=1;
    for(int i=0;i<=2;i++)
    {
        int now=0;
        if(fac[a][i]>ppt)
        {
            if(b%fac[a][i]==0) now=fac[a][i];
            else now=1;
        }
        else now=gcd[fac[a][i]][b%fac[a][i]];
        b/=now;
        ans*=now;
    }
    return ans;
}

int main(void)
{
    int n,m,k;
    scanf("%d%d%d",&n,&m,&k);
    Prime(max(n,m));
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            a[i][j]=i*j/gg(i,j);
        }
    }
    for(int i=1;i<=m;i++)
    {
        int l=1,r=0;
        for(int j=1;j<=n;j++)
        {
            while(l<=r&&q[l]<=j-k) l++;
            while(l<=r&&a[q[r]][i]<=a[j][i]) r--;
            q[++r]=j;
            b[j][i]=a[q[l]][i];
        }
    }

    ll ans=0;
    for(int i=1;i<=n;i++)
    {
        int l=1,r=0;
        for(int j=1;j<=m;j++)
        {
            while(l<=r&&q[l]<=j-k) l++;
            while(l<=r&&b[i][q[r]]<=b[i][j]) r--;
            q[++r]=j;
            if(i>=k&&j>=k)ans=ans+b[i][q[l]];
        }
    }
    printf("%lld\n",ans);
    return 0;
}
_Shmily
关注
专栏目录
2020牛客暑期多校集训营第二场题解.pdf
01-20
### 2020牛客暑期多校集训营第二场题解 #### Gromah 题目解析 在本次解析中，我们将逐一探讨各题目的关键算法思想和技术细节。 ### A. All with Pairs (全部配对) 本题讨论了如何利用哈希表来解决一对对字符串的...
2020多校联赛第二场F题：Fake Maxpooling
m0_45920074的博客
07-18 422
本题题意： 给一个n×m的矩阵，对于第i行第j列的 Aij 等于i与j的最小公倍数，求该矩阵中每个k×k大小的子矩阵中最大值的和。 #include <iostream> #include<string.h> using namespace std; int m,n,k; int a[5001][5001]; int gcd(int a,int b) { if(!b) return a; return gcd(b,a%b);//最大公约数 } in.
2020牛客多校 第二场 F-Fake Maxpooling （快速lcm + 二维单调队列）
Carizy的博客
07-20 245
题目链接: F-Fake Maxpooling Description 给出 n, m, k 求矩阵 a[n][m] 中 k方阵大小的区域内的最大值的和，a[i][j] = lcm(i, j)。 Sample Input 3 4 2 Sample Output 38 More Info 1 <= n, m <= 5000 1 <= k <= {n, m} Method 可以暴力产生最小公倍数矩阵，可以花费时间换空间; 我就是补题的时候因为空间被卡的，蒟蒻哭泣 也可以用空间换时间
2020牛客暑期多校训练营（第二场）F.Fake Maxpooling
qcccc_的博客
07-15 164
这个题目就是用一个二维单调队列，但是比赛的时候就是没有想到，更奇葩的是我居然连题目都读错了，读成了求在nm矩阵里找一个kk大小的使得这个kk的矩阵的值的和最大，而题目本来的意思是求每一个kk矩阵里面的最大值然后加起来，lcj做出来后说是二维单调队列我当时一脸懵逼，首先我是读错了题目，然后是二维单调队列没看见过，不知道长哪样，我还是太菜了。 #include<iostream> #include<stdio.h> #include<math.h> #include&lt.
2020牛客暑期多校训练营（第二场）F——Fake Maxpooling
NGUP_LEE的博客
07-17 184
题目大意： 给定 n、m、k,可以确定一个n行m列的二维矩阵 a，并且这个矩阵，a[i][j]=i*j/gcd(i,j),求在这个矩阵中所有的大小为k矩阵的最大值的和 两种方法： 单调队列，可以用deque也可以用数组模拟，维护k范围中每一列的最大值和每一行的最大值，最后求解 dfs，因为每个点的值都是确定的，可以直接从a[k][k]开始搜，找到一个小矩阵的最大值后，再找另外一个的，当然如果k==1的话，就不需要搜了 单调队列法 #include<iostream> #inclu...
牛客多校2020年第二场F-Fake Maxpooling
qq_44641782的博客
07-13 257
题目大意：有一个矩阵A，其中Aij=LCM(i,j)。问在该矩阵中所有的k子矩阵的最大值的和。 解题思路：先暴力求出目标矩阵，然后利用单调栈维护最大值下标。最后将答案加上即可。 代码： #pragma GCC optimize(2) #include <bits/stdc++.h> #include <unordered_map> using namespace std; std::mt19937 rnd(233); #define pp pair<int,int> #d
2020牛客暑期多校训练营 (第二场) FakeMaxpooling(单调队列)
菜鸡的学习记录
09-09 121
题意：给一个n * m的矩阵，其中a[i][j]=lcm(i,j) (lcm指最小公倍数)。 再给一个k，求n * m的矩阵中，所有k阶矩阵中最大值之和。 思路：二维滑动窗口。 我们用ma[i][j]来表示第i行中，从第j-k+1个数 到 第j个数的最大值。即一个区间长度为k的最大值。先处理好每一行中的每一个长度为k的子区间的最大值。 这样的话，我们就把一个k * k的矩阵的最大值，现在把每行的最大值求出来了。 把一个k * k矩阵每行的最大值放在了这个矩阵中每行的第k个位置。 这样的话，我们只需要对每一列
2020牛客多校二 F. Fake Maxpooling (二维单调队列)
gongyuandaye的博客
07-19 242
题意：n * m的矩阵，Ai,j=lcm(i, j)，给出k，求所有k * k子矩阵中最大值之和。 题解：二维单调队列 先用单调队列处理列上的每段的最大值，再处理行上的。 求lcm的时间太多了，看了看别人的代码，可以用下面这种方法，因为先处理的永远包含质数。 if (!a[i][j]) for (int k = 1; k * i <= n && k * j <= m; ++k) a[k * i][k * j] = i * j * k; #define _CRT_SECUR
2020牛客暑期多校训练营（第二场）F Fake Maxpooling（二维滑动窗口）
张洪基
07-13 353
时间限制：C/C++ 3秒，其他语言6秒 空间限制：C/C++ 262144K，其他语言524288K 64bit IO Format: %lld 题目描述 Given a matrix of size n\times mn×m and an integer {k}k, where A_{i,j} = lcm(i, j)A i,j =lcm(i,j), the least common multiple of {i}i and {j}j. You should determine the sum of th
2020牛客多校第二场F题Fake Maxpooling
xiongyuqing的博客
07-14 255
Fake Maxpooling 题意： 一个n×m的矩阵，矩阵元素的值为行数和列数的最小公倍数(least common multiple,LCM)，求所有k×k的子矩阵里最大值的和。 思路： （正解为单调队列） 找到子矩阵里行列数互质且乘积最大的那个数。k×k的循环找到这个数肯定会超时的。从正确代码里看到一个机智做法：从子矩阵里最大的那个点也就是右下角开始dfs向上向左搜索，遇到gcd(a,b)==1就return a*b，然后取最大的再返回，这样比一行一列的k×k循环要快很多，因为最大的元素肯定更靠近右
2020牛客暑期多校训练营（第二场）F Fake Maxpooling
ylwhxht的博客
07-20 149
2020/7/14 哎，+17的滋味你不知。题目卡构造lcm矩阵，暴力求矩阵复杂度是nmlogn，就是这个logn被卡住了，赛中加了一个特判减了一半复杂度勉强过去。正解是题解中给出的利用筛法构造lcm矩阵 for (int i = 1; i <= n; i ++) for (int j = 1; j <= m; j ++) if (!Gcd[i][j]) for (int k = 1; k * i <= n && k * j <= m; k ++) G
2020牛客多校第二场 F Fake Maxpooling (单调队列)
林黛玉到拔垂杨柳的博客
07-21 182
Fake Maxpooling 题目链接：https://ac.nowcoder.com/acm/contest/5667/F 来源：牛客网 题目大意： 有一个矩阵，他的元素为A[i][j]=lcm(i,j) ,然后给出一个k，问这个矩阵里所有k*k大小的子矩阵里最大值的和。 思路： 子矩阵里最值的和 / 区间最值的和 的问题求解，很容易联想到单调队列上，然后子矩阵的话，要压缩一下矩阵，分成两维求，先求行最值，然后求列最值，然后累加答案即可。 求矩阵lcm给出一个线性筛的做法，具体见代码。 Code： #
矩阵求和
weixin_30411997的博客
04-24 256
经过重重笔试面试的考验，小明成功进入 Macrohard 公司工作。今天小明的任务是填满这么一张表：表有 n 行 n 列，行和列的编号都从1算起。其中第 i 行第 j 个元素的值是 gcd(i, j)的平方，gcd 表示最大公约数，以下是这个表的前四行的前四列：1 1 1 11 4 1 41 1 9 11 4 1 16 小明突然冒出一个奇怪的想法，他想知道这张表中所有元素的...
牛客多校第五场F题 take （思维）
yjt9299的博客
08-02 289
链接：https://www.nowcoder.com/acm/contest/143/F 来源：牛客网   题目描述 Kanade has n boxes , the i-th box has p[i] probability to have an diamond of d[i] size. At the beginning , Kanade has a diamond of 0 size...
2020牛客暑期多校训练营（第二场）F . Fake Maxpooling (二维单调队列 )
hddddh的博客
07-13 316
链接： F . Fake Maxpooling 题意： 给定一个 n * m 的 矩阵 矩阵元素的值为 lcm( i , j ) ,求每个大小为 k * k 的子矩阵 中 的最大值之和。 思路： 考虑 一维 求每一行每k 个元素的最大值 ，很容易想到单调队列（滑动窗口），可以维护每个长度为 k 的区间的最大值，但这里是二维的，其实只要在一维的基础上 再对列做单调队列。因为在一维单调队列的基础上，我们已经求得了第 i 行 第 j个元素为起点长度为 k 的区间的最大值 ，在求整个区间时就只要用我们已经得到的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值