牛客周赛Round41A~F题解

贴个题题

题目来源：牛客网

菜の题目评价

考了一些简单的思维题的样子，设计算法的部分不是很多，有个基础就很好，读题比较坑，不注意的话会走神然后读错题，还是训练读题的速度和读题质量&写板子的速度。

这是自己第一次AK，虽然只是一个周赛，但是在半个月前，还只是一个周赛只能做出两个题的小废物。不管最后学的怎么样吧，其实还是对自己的进步略微感到欣慰的。

A. 小红接雨水

木桶原理/chatgpt秒掉即可，最少是0，最大的接雨量abc组成的木桶

#include<iostream>
using namespace std;
int main(){
    int a, b, c;
    cin>>a>>b>>c;
    cout<<max(0, min(a-b, c-b));
    return 0;
}

B. 小红的排列构造

• 如果n是1那肯定就不行
• 如果k大于n那肯定也不行
• 除了上述两种情况剩下的肯定行
• 构造方式：把前k个留下，从k+1到n依次向右错一格，把原来的n位补到k+1
• 如果你看不懂这个构造方式，你就看C题的标题和内容

#include<iostream>
using namespace std;
const int N=110000;
int p[N];

int main(){
    int n, k;
    cin>>n>>k;
    for(int i=1; i<=n; ++i){
        cin>>p[i];
    }
    
    if(k>n  || k==1){
        cout<<-1<<endl;
        return 0;
    }
    
    for(int i=1; i<=n-k; ++i){
        cout<<p[i]<<' ';
    }
    for(int i=n-k+1; i<n; ++i){
        cout<<p[i+1]<<' ';
    }
    cout<<p[n-k+1];
    return 0;
}

C. 小红的循环移位

• 如果你学历是初中，你应该知道如果一个数是4的倍数的充分必要条件是这个数的末2位可以被4整除
• 如果这个数就1位那么你应该能很轻易的判断它
• 如果向左循环k次(k>1)， 那么循环后的数字的最后一位应该是$s_{k-1}$, 倒数第二位应该是$s_{k-2}$
• k=0和k=1特殊判定就可以

#include<iostream>
using namespace std;
int main(){
    string str;
    cin>>str;
    if(str.size()==1){
        if((str[0]-'0')%4==0){
            cout<<0<<endl;
            return 0;
        }
        else {
            cout<<-1<<endl;
            return 0;
        }
    }
    if(((str[str.size()-1]-'0')*10+str[0]-'0')%4==0){
        cout<<1<<endl;
        return 0;
    }
    if(((str[str.size()-2]-'0')*10+str[str.size()-1]-'0')%4==0){
        cout<<0<<endl;
        return 0;
    }
    for(int i=0; i<str.size()-1; ++i){
        int t=(str[i]-'0')*10+str[i+1]-'0';
        if(t%4==0){
            cout<<i+2<<endl;
            return 0;
        }
    }
    cout<<-1<<endl;
    return 0;
}

D.小红的好串

题目分析：

• 没错这个题我当成了只要是rrreeeeeeddddd的形式就行，于是前半个小时就在那里疯狂dp，我是弱智
• 好串的意思就是red的子序列数量最多，那么它一定有这样的条件：
  • 他一定是先r，再e，最后d的序列
    • 理由：如果存在a个r，b个e， c个d的序列string1，那么假设最大的串中存在er/dr/de子序列，那么对调此子序列后的string2会多出若干组red序列（严密证明我也不会）
  • red序列经过乘法原理计算，它的red子序列共有$a\times b\times c$种情况，且$a+b+c=r-l+1=length$
  • 对于和一定的三个数，他们乘积最大的情况是三个数最接近的时候
    • 三个数最接近的时候，就是每个数均为$length/3或length/3+1$二选一的时候
• 那么问题就会转化成”将这个串转化为每段定长的三段常字符串所需的修改次数“

复杂度：

• 暴拆是O（$n^2$）的复杂度，铁寄
• O($nlogn$)或O($n$)是比较友好的。
• 这个问题的关键在于一个地方的字符数量统计问题，且字符数量单增，那么分析到这里就变成了前缀和的板子。

步骤：

• 对red分别前缀和
• 对length除以三并取余
• 写一个函数，函数的作用是求解当需要$把l\sim r的串变成a个r，b个e，c个d的时候，l\sim r范围内需要改几次$
• 被3整除的情况/余1情况/余2情况分类讨论

#include<iostream>
using namespace std;
const int N=1e5+100;
int sum[N][3];
int d[N];
int op(int l, int r, int a, int b, int c){
    int t=0;
    t+=(a-(sum[l+a-1][1]-sum[l-1][1]));
    t+=(b-(sum[l+a+b-1][2]-sum[l+a-1][2]));
    t+=(c-(sum[l+a+b+c-1][3]-sum[l+a+b-1][3]));
    return t;
}
int main(){
    int n, q;
    cin>>n>>q;
    string str;
    cin>>str;
    for(int i=0; i<str.size(); ++i){
        if(str[i]=='r')d[i+1]=1;
        if(str[i]=='e')d[i+1]=2;
        if(str[i]=='d')d[i+1]=3;
    }
    for(int i=1; i<=n; ++i){ 
        for(int j=1; j<=3; ++j)sum[i][j]=sum[i-1][j];
        if(d[i]==1)sum[i][1]=sum[i-1][1]+1;
        if(d[i]==2)sum[i][2]=sum[i-1][2]+1;
        if(d[i]==3)sum[i][3]=sum[i-1][3]+1;
    }
    
    for(int i=1; i<=q; ++i){
        int l, r;
        cin>>l>>r;
        if(r-l+1<3){
            cout<<0<<endl;
            continue;
        }
        int s=r-l+1;
        int ans=0x3f3f3f3f;
        if(s%3==0)ans=op(l, r, s/3, s/3, s/3);
        if(s%3==1){
            ans=op(l, r, s/3+1, s/3, s/3);
            ans=min(ans, op(l, r, s/3, s/3+1, s/3));
            ans=min(ans, op(l, r, s/3, s/3, s/3+1));
        }
        if(s%3==2){
            ans=op(l, r, s/3+1, s/3+1, s/3);
            ans=min(ans, op(l, r, s/3, s/3+1, s/3+1));
            ans=min(ans, op(l, r, s/3+1, s/3, s/3+1));
        }
        cout<<ans<<endl;
    }
    return 0;
}

E&F. 小红的树上赋值

• 非常容易不知道这个题要干什么
  • 红节点的子树和为0，说明红节点及其下面的所有元素和加一起，包括白节点，加一起是0
• 如果红节点里没有红节点，那么红节点的子树和为0的情况就是一个贪心的思想
• 如果红节点A里有红节点B，那么红节点的子树和为0的情况就是一个不必考虑B子树的贪心的思想(doge)（因为B子树和为0所以直接被剪掉就可以）
• 那么题目的本质就是在问，给定某些点集和，让这些点集和的权值和分别为0的情况。
• 也可以说是，给定一个图，划分了一些区域，问这些区域和为0，且所有数字绝对值总和最大的情况

进步分析

• 搜出所有被划分的区域
• 如果这个区域没有被划分出来，那么它一定和根节点有关，并且他们应该赋值为l和r绝对值最大的哪一个。
• 如果这片区域被划分出来，那么它为0且绝对值最大的方案可以这样计算：
  • 先把这片区域的所有节点填上l和r绝对值最大的数， 并记录填完后这片区域的区域和
  • 分类讨论
    • 如果填的是l，就用r开始不断的后悔
    • 如果填的是r，用l开始不断的后悔
  • 后悔：
    • 指定一个待更改节点
    • 把节点从区域和中删除
    • 询问是填l/r还是填l和r中间的某数(一个非常奇怪的算式)
    • 把刚才询问的结果塞进结论数组
    • 再指定一个节点重复上述

#include<iostream>
#include<cstring>
#include<stack>
#include<cmath>
using namespace std;
const int N=1e5+100;
int e[2*N], ne[2*N], h[2*N], idx=0;
void add(int a, int b){
	e[idx]=b;
	ne[idx]=h[a];
	h[a]=idx++;
}

bool st1[N];
int n, l, r;
int c[N];
char color[N];

int res[N];
int aridx=0;
stack<int> ar[N];
long long max(long long a, long long b){
	return a>b?a:b;
}
long long min(long long a, long long b){
	return a<b?a:b;
}
void dfs_ar(int x, bool st){
	if(!st && c[x])return;
	if(st1[x])return;
	
	st1[x]=true;
	ar[aridx].push(x);
	for(int i=h[x]; i!=-1; i=ne[i]){
		int t=e[i];
		dfs_ar(t, 0);
	}
}
void dfs(int x){
	if(c[x])return;
	if(st1[x])return;
	st1[x]=true;
	for(int i=h[x]; i!=-1; i=ne[i]){
		int t=e[i];
		dfs(t);
	}
}
int main(){
//	freopen("test.txt", "r", stdin);
	cin>>n>>l>>r;
	cin>>color+1;
	for(int i=1; i<=n; ++i)
		if(color[i]=='R')c[i]=true;
		else c[i]=false;
	
	memset(h, -1, sizeof h);
	for(int i=1; i<n; ++i){
		int a, b;
		cin>>a>>b;
		add(a, b);
		add(b, a);
	}			
	
	memset(st1, 0, sizeof st1);
	aridx=0;
	for(int i=1; i<=n; ++i){
		if(c[i]){
			aridx++;
			dfs_ar(i, 1);
		}
		if(!c[i] && !st1[i])dfs(i);
	}
	
	for(int i=1; i<=n; ++i){
		if(abs(l)>r)res[i]=l;
		else res[i]=r;
	}
	
	for(int i=1; i<=aridx; ++i){
		long long t=res[ar[i].top()]*ar[i].size();
		if(t<0){
			while(!ar[i].empty()){
				int x=ar[i].top();
				ar[i].pop();
				long long t1=t-res[x];
				res[x]=min(r, -t1);
				t1+=res[x];
				t=t1;
			}
		}
		if(t>0){
			while(!ar[i].empty()){
				int x=ar[i].top();
				ar[i].pop();
				long long t1=t-res[x];
				res[x]=max(l, 0-t1);
				t=t1+res[x];
			}
		}
	}
	
	for(int i=1; i<=n; ++i)cout<<res[i]<<' ';
	cout<<endl;
	return 0;
}