2020牛客暑期多校训练营（第二场）赛后补题+证明自用

2020牛客暑期多校训练营（第二场）

赛后补题+证明自用

D Duration

题意：给两个时间，计算这两个时间相差的秒数

Solution：将两个时间转换成秒，然后作差取绝对值

Code:

#include<bits/stdc++.h>
using namespace std;
int main(){
	int h1,m1,s1,h2,m2,s2;
	scanf("%d:%d:%d",&h1,&m1,&s1);
	scanf("%d:%d:%d",&h2,&m2,&s2);
	int sum1=h1*3600+m1*60+s1;
	int sum2=h2*3600+m2*60+s2;
	cout<<abs(sum1-sum2);
}

F Fake Maxpooling

题意：给出矩阵的行数$n$和列数$m$，矩阵$A_{ij}=lcm(i,j)$，求每个大小为$k\ast k$的子矩阵最大值的和

前置知识：单调队列

所谓单调队列，就是具有单调性质和队列性质的数据结构

单调队列可以保证，对于任何数而言，只会在队列中出现一次，一旦这个数对最后答案没有贡献了，就要及时地将其删除

一般来说，单调队列有如下两种操作：

1、入队：如果一个数加入队列后满足队列的单调性质，就可以将其入队

2、出队：对于一个数而言，如果之后新加入的点比它更有潜力，所谓潜力也就是：拓展性更强，生存能力高，节点入队时间短，那么这个数就要出队

因此单调队列的时间复杂度为$O(n)$，这种算法代码短，思路好想，符合人类思维

单调队列是dp算法必备的优化手段，在ACM，大公司面试题目中频频出现，所以我们有必要学会这种看似高端大气，实则简易易懂的数据结构

单调队列的算法步骤：

1、对于一个新来的数，它要想从队尾入队，必须满足题目的特定条件

2、对于一个队头的数，如果新来的数不仅比它更有潜力，而且自身价值还比它高，那么队头出队

参考资料：https://www.acwing.com/blog/content/150/

例题：NC51001 Sliding Window

题意：给一个长度为$n$的数组，求每个长度为$k$的子数组的最大值和最小值

在线测评：https://ac.nowcoder.com/acm/problem/51001

Code:

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=1e6+5;
int a[N],qu[N],l=0,r=1;
signed main(){
    signed n,k;
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
    qu[0]=1;
    if(k==1) printf("%lld ",a[qu[0]]);
    for(int i=2;i<=n;i++){
        if(i-qu[l]+1>k&&l<r) l++;
        while(r>l&&a[qu[r-1]]>=a[i]) r--;
        qu[r++]=i;
        if(i>=k) printf("%lld ",a[qu[l]]);
    }
    printf("\n");
    qu[0]=1,l=0,r=1;
    if(k==1) printf("%lld ",a[qu[0]]);
    for(int i=2;i<=n;i++){
        if(i-qu[l]+1>k&&l<r) l++;
        while(r>l&&a[qu[r-1]]<=a[i]) r--;
        qu[r++]=i;
        if(i>=k) printf("%lld ",a[qu[l]]);
    }
    return 0;
}

回归正题，对于这道题而言，先横向把每一行长度为$k$的区间最大值找出来，再纵向把长度为$k$的区间的最大值找出来，这样最后求得的就是$k\ast k$的子矩阵的最大值，最后累加求和即可

#include<bits/stdc++.h>
using ll=long long;
#define js ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
using namespace std;
inline int gcd(int a,int b){
    return b==0?a:gcd(b,a%b);
}
int a[5005][5005],b[5005][5005];
deque<int> dq;
int main(){
    js;
    int n,m,k;
    cin>>n>>m>>k;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            a[i][j]=i*j/gcd(i,j);
        }
    }
    for(int i=1;i<=n;i++){
        while(!dq.empty()) dq.pop_back();
        dq.push_back(0);
        for(int j=1;j<k;j++){
            while(!dq.empty()&&a[i][dq.back()]<=a[i][j]) dq.pop_back(); 
            dq.push_back(j);
        }
        for(int j=k;j<=m;j++){
            while(dq.size()&&dq.front()<=j-k) dq.pop_front();
            while(!dq.empty()&&a[i][dq.back()]<=a[i][j]) dq.pop_back();
            dq.push_back(j);
            b[i][j]=max(b[i][j],a[i][dq.front()]);
        }
    }
    ll ans=0;
    for(int j=k;j<=m;j++){
        while(!dq.empty()) dq.pop_back();
        dq.push_back(0);
        for(int i=1;i<k;i++){
            while(!dq.empty()&&b[dq.back()][j]<=b[i][j]) dq.pop_back();
            dq.push_back(i);
        }
        for(int i=k;i<=n;i++){
            while(dq.size()&&dq.front()<=i-k) dq.pop_front();
            while(!dq.empty()&&b[dq.back()][j]<=b[i][j]) dq.pop_back();
            dq.push_back(i);
            ans+=b[dq.front()][j];
        }
    }
    cout<<ans;
}