Codeforces Round #833 (Div. 2)

题目链接

A. The Ultimate Square

题意：

给你一个n，表示有n块砖，第i块砖是1*(i/2)，这里是上取整，问你最大能组合成的正方形的边长是多少

思路：

观察样例就会发现是n/2上取整，下面看代码：

#include<bits/stdc++.h>
using namespace std;
void solve(){
    int x;
    scanf("%d",&x);
    printf("%d\n",(x+1)/2);
}
int main(){
    int _;
    for(cin>>_;_;_--) solve();
    return 0;
}

B. Diverse Substrings

题意：

给你一个字符串，一个字符串是好串的定义就是每个字符出现的次数都不超过这个字符串中不同数的数量，现在问你有多少个子串是好串

思路：

因为每个字符的取值是0~9，所以根据鸽巢原理，好字符串的长度最长为100，所以直接暴力就行，下面看代码：

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5+10;
int cnt[N][11];
char s[N];
bool check(int l,int r){
    int zhong = 0,siz = 0;
    for(int i=0;i<=9;i++){
        int t = cnt[r][i] - cnt[l-1][i];
        if(t){
            zhong ++;
            siz = max(siz,t);
        }
    }
    return siz <= zhong;
}
void solve(){
    int n;
    scanf("%d%s",&n,s+1);
    for(int i=1;i<=n;i++){
        for(int j=0;j<=9;j++){
            cnt[i][j] = cnt[i-1][j] + (s[i] - '0' == j);
        }
    }
    long long ans = 0;
    for(int i=1;i<=n;i++){
        for(int j=0;j<=100 && i+j<=n;j++){
            int r = i+j;
            if(check(i,r)) ans ++; 
        }
    }
    printf("%lld\n",ans);
}
int main(){
    int _;
    for(cin>>_;_;_--) solve();
    return 0;
}

C. Zero-Sum Prefixes

题意：

给你一个长度为n的数组，一个数组的分数就是其前缀和为0的下标，现在你可以进行一步操作，选择一个取值为0的数，然后将他变为任意数，现在问你分数最大是多少

思路：

一个数改了，他只会影响到后面的数的前缀和，我们可以把0看作是分界线，每个0只管他后面的数，就是与下一个0之间的数，可以统计一下这段区间内哪一个数最多，然后成为这个数的相反数，这样一定是最优的，不用在乎下一个0以后的前缀和是怎么变的，因为只是相当于做了个偏移而已，但是要特判一下0出现最多的情况，这个一定是最优先的，因为填的这个数也为0，下面看代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 2e5+10;
int a[N],s[N];
bool st[N];
int cnt[N];
void solve(){
    int n;
    scanf("%lld",&n);
    vector<int> e;
    for(int i=1;i<=n;i++){
        scanf("%lld",&a[i]);
        s[i] = s[i-1] + a[i];
        if(!a[i])
            e.push_back(i);
    }
    e.push_back(n+1);
    int ans = 0;
    for(int i=0;i<e.size()-1;i++){
        int l = e[i],r = e[i+1],res = 0;
        map<int,int> mp;
        int t = 0;
        for(int j=l;j<r;j++){
            s[j] = s[j-1] + a[j];
            mp[s[j]]++;
            if(mp[s[j]] > t){
                t = mp[s[j]];
                res = -s[j];
            }
        }
        if(mp[0] == t) res = 0;
        if(t <= 1) a[l] = -s[l-1];
        else a[l] = res;
        for(int j=l;j<=r;j++) s[j] = s[j-1] + a[j];
    }
    for(int i=1;i<=n;i++){
        s[i] = s[i-1] + a[i];
        ans += !s[i];
    }
    printf("%lld\n",ans);
}
signed main(){
    int _;
    for(cin>>_;_;_--) solve();
    return 0;
}

D. ConstructOR

题意：

给你三个数a,b,d,让你找出来一个数x，使得a|x能被d整除，b|x能被d整除

思路：

刚看到这个题的时候是一脸懵，然后队友们讲出了他们的神仙思路，就是或的话最后一位是不会变的，这里可以判断是否有解，如果d的最后一位比a或b的最后一位小的话，那就是无解的，怎么或也不好使，然后考虑把a,b这两种情况合并成一种，假设d的最后一个1是在第t位，那么剩下的30-t位先都给他添上1，这样或完以后就都是一个数了，然后就是推公式了，看下图

假设p是x的前30位，一共有60位，然后q是d往后移d位的结果，化简完公式后发现是方框里面的结果，我们知道扩展欧几里得的用法就是求解的，ax+by=gcd(a,b)，如果a和b互质，那么就能求出来x和y，我们发现q的最后一位是1，也就是奇数，奇数和一个2的幂次是一定互质的，上面黑框里面的式子能化成(p+1)(2^30-t)+nq = 1,那么正好符合扩展欧几里得的形式，a是(2^30-t)，b是q，正好就是求x，跑一遍exgcd就出来了，下面看代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
int ksm(int x,int n,int mod){
    int ans = 1;
    while(n){
        if(n&1) ans = ans * x % mod;
        n >>= 1;
        x = x * x % mod;
    }
    return ans;
}
inline int lowbit(int x){
    return x & -x;
}
int exGcd(int a, int b, int &x, int &y)
{
    if(b == 0)
    {
        x = 1;
        y = 0;
        return a;
    }
 
    int g = exGcd(b, a % b, x, y);
    int temp = x;
    x = y;
    y = temp - a / b * y;
    return g;
}
void solve(){
    int a,b,d;
    scanf("%lld%lld%lld",&a,&b,&d);
    if(min(lowbit(a),lowbit(b)) < lowbit(d)) puts("-1");
    else{
        int t = lowbit(d);
        int q = d;
        if(t)
            q = d / t;
		int a = 1ll<<(30-(int)log2(t));
		int b = q;
		int x,y;
		exGcd(a,b,x,y);
		int p = (x % q - 1 + q) % q;
        p <<= 30;
        for(int i=0;i<30;i++){
            if((1ll<<i) >= t) p += (1ll<<i);
        }
        printf("%lld\n",p);
    } 
}
signed main(){
    int _;
    for(cin>>_;_;_--) solve();
    return 0;
}

E. Yet Another Array Counting Problem

题意：

一个区间的leftmost是最左边的最大值的位置，现在给你一个a数组，问你有多少b数组满足所有区间的leftmost和a数组的相同

思路：

这个题想做的话得需要一个东西，就是笛卡尔树，把这个题套进笛卡尔树中去那就很简单了，直接树形dp就行，复杂度O(nm)，下面看代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 2e6+10,mod = 1e9+7;
int f[N],n,m;
inline int dp(int i,int j){
    return (i-1)*(m+1)+j;
}
struct node{
    int l,r;
}tr[N];
int a[N];
int stk[N];
int build(){
    int top = 0;
    for(int i=1;i<=n;i++){
        int k = top;
        while(k && a[stk[k]] < a[i]) k--;
        if(k) tr[stk[k]].r = i;
        if(k<top) tr[i].l = stk[k+1];
        top = k;
        stk[++top] = i;   
    }
    return stk[1];
}
void dfs(int u){
    if(tr[u].l) dfs(tr[u].l);
    if(tr[u].r) dfs(tr[u].r);
    if(!max(tr[u].l,tr[u].r)){
    	for(int i=0;i<=m;i++){
    		f[dp(u,i)] = i;
		}
		return;
	}
    for(int i=1;i<=m;i++){
    	if(tr[u].l && tr[u].r) 
			f[dp(u,i)] = (f[dp(tr[u].l,i-1)] * f[dp(tr[u].r,i)]) % mod;
        else if(tr[u].l)
        	f[dp(u,i)] = f[dp(tr[u].l,i-1)];
        else 
        	f[dp(u,i)] = f[dp(tr[u].r,i)];
		f[dp(u,i)] = (f[dp(u,i)] + ((i == 1)?0:f[dp(u,i-1)])) % mod;
    }
}
void solve(){
    scanf("%lld%lld",&n,&m);
    for(int i=1;i<=n*m;i++) f[i] = tr[i].l = tr[i].r = 0;
    for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
    int root = build();
    dfs(root);
    printf("%lld\n",f[dp(root,m)]);
}
signed main(){
    int _;
    for(cin>>_;_;_--) solve();
    return 0;
}