牛客周赛 Round 1题解

A.游游画U

打印题找规律，直接用朴素方法

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 1e7 + 10;
int a[N];
int dp[N];
int ans[N];


signed main(){
	int n;
	cin>>n;
	string s,k;
	for(int i=0;i<n;i++)
	{
		s+='*';
		k+='.';
	}
	for(int i=0;i<n*3;i++){
		cout<<s<<k<<k<<s<<endl;
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=i;j++)
		{
			cout<<".";
		 } 
		 cout<<s;
		 for(int j=1;j<=(n-i)*2;j++)
		 {
		 	cout<<'.';
		 }
		 cout<<s;
		for(int j=1;j<=i;j++)
		{
			cout<<".";
		 } 
		 cout<<endl; 
	}
	return 0;
} 

B.游游的数组染色

取一个数组中的相同的数却不同颜色的组合，求有多少种

注意：本题只有代码三和代码四是正确题解！！！

一、朴素思路：
1、遍历数组，直接创建一个蓝色数组和一个红色数组，将每个数字用颜色分开存储，然后所有所有数字蓝红相乘和就是所得结果，但是每个数字过大，如果用来做下标，数组会越界，因为在int中数组的大小最多开1e7左右，所以如代码一所示，和图一所示，会产生数组越界，形成所谓的段错误（错误在代码中表明）。
2、所以这时我们可以想到，数组报了，就用map这个函数来维护本题的答案。map<int,int>不会像数组那样存在存太多的数而爆掉，所以只用将数组换成map函数即可解决数组越界的问题。代码如代码二，但此时看图二，没有段问题，但又有了一个新的问题超时了，很明显，因为我们时间复杂度最后因为求和时，是循环到1e9的所以时间度肯定超了（位置看代码）。
3、所以我们可以选择新开一个map用来维护下标，因为n<2e5，所以把之前下标没用到的数用了，就不会超时，如代码三，和图三。
！！所以此时也可以想到如果将数组中的下标也给维护了，是不是也不会超时了呢，就自己试试把！！
二、做题时，我看见段错误没有去优化，而是想到了另一个方法：
一方法是将所有的球进行遍历，先将颜色分类。二可以直接将球先分类，我想的是直接排序，这样为相同数字的球就在一起了，但是这样也会打乱顺序，所以我就用的结构体将球的号数和球的序号打包在一个数组中，这样就可以解决，如代码四。

代码一：

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 1e7 + 10;
int a[N];
int dp[N];
int R[N]={0};
int B[N]={0};
string s;
int n,ma=0;
signed main(){
     
    cin>>n;
    for(int i=0;i<n;i++) cin>>a[i],ma=max(ma,a[i]);
 
    cin>>s;
    for(int i=0;i<s.size();i++)
    {
        if(s[i]=='R') R[a[i]]++;//错误原因：a[i]>1e7时数组越界
        else B[a[i]]++;			//错误原因：a[i]>1e7时数组越界
    }
    int ans=0;
    for(int i=1;i<=ma;i++) ans+=(R[i]*B[i]);
    cout<<ans;
    return 0;
}

图一：

代码二：

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 1e7 + 10;
int a[N];
int dp[N];
map<int,int> R;
map<int,int> B;
string s;
int n,ma=0;
signed main(){
	
	cin>>n;
	for(int i=0;i<n;i++) cin>>a[i],R[a[i]]=0,B[a[i]]=0,ma=max(ma,a[i]);

	cin>>s;
	for(int i=0;i<s.size();i++)
	{
		if(s[i]=='R'){
			R[a[i]]++;
		}
		else{
			B[a[i]]++; 
		}
	}
	int ans=0;
	for(int i=1;i<=ma;i++) ans+=(R[i]*B[i]);//错误原因
	cout<<ans;
	return 0;
} 

图二：

代码三

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 1e7 + 10;
int a[N];
int dp[N];
map<int,int> R;
map<int,int> B;
map<int,int> c;//维护下标
string s;
int n,ma=0;
signed main(){
	
	cin>>n;
	int k=0;
	for(int i=0;i<n;i++) cin>>a[i],c[a[i]] = k,R[k]=0,B[k]=0,k++,ma=max(ma,a[i]);

	cin>>s;
	for(int i=0;i<s.size();i++)
	{
		if(s[i]=='R'){
			R[c[a[i]]]++;
		}
		else{
			B[c[a[i]]]++; 
		}
	}
	int ans=0;
	for(int i=0;i<k;i++) ans+=(R[i]*B[i]);
	cout<<ans;
	return 0;
} 

图三：

代码四：

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 2e5 + 10;

string s;
int n;
struct zz{
	int x,y;
}a[N];
bool cmp(zz a,zz b){
	return a.x<b.x;
}
int kk=0;
int an1,an2;
int ans=0;
signed main(){
	
	cin>>n;
	for(int i=0;i<n;i++){
		 int x;
		 cin>>x;
		 a[i].x=x;
		 a[i].y=i;
	}
	sort(a,a+n,cmp);
	cin>>s;
	for(int i=0;i<n;i++)
	{
		if(a[i].x!=kk){
			kk=a[i].x;
			ans+=an1*an2;
			an1=0,an2=0;
		}
		if(s[a[i].y]=='R') an1++;
		else if(s[a[i].y]=='B')an2++;
		if(i==n-1){
			ans+=an1*an2;
		}
	}
	cout<<ans;
	return 0;
} 

C.游游的交换字符

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 2e5 + 10;
int check(string s,char x){
	int ans=0;
	for(int i=0,j=0;i<s.size();i++)
	{
		if(s[i]==x){
			ans+=abs(i-j);
			j+=2;
		} 
	}
	return ans;
}
signed main(){
	string s;
	cin>>s;
	int a=0,b=0;
	for(int i=0;i<s.size();i++){
		if(s[i]=='0') a++;
		else b++; 
	} 
	if(a==b) cout<<min(check(s,'0'),check(s,'1'));
	else if(a>b) cout<<check(s,'0');
	else cout<<check(s,'1');
	return 0;
}

将1和0分叉排列，所以就只有两种情况，就是1开头和0开头，开头的数必定排列在0，2，4…偶数上，所以直接进行入队就行，然后算相减的和就是答案

D.游游的9的倍数

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 2e5 + 10;
const int Mod = 1e9+7;
int a[N];
int dp[N][9];
signed main(){
	string s;
	cin>>s;
	int n = s.size(); 
	for(int i=0,j=1;i<n;i++,j++)
	{
		a[j]=s[i]-'0';
		dp[j][a[j]%9]++;
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=0;j<9;j++)
		{
			dp[i][j]=dp[i][j]+dp[i-1][j]+dp[i-1][(j+9-a[i])%9]%Mod;
			dp[i][j]%=Mod;
		}
	}
	cout<<dp[n][0]<<endl;
	return 0;
}

本题为DP问题：
状态表示dp [ i ][ j ]表示前i个数中对9取为为j的个数。
所以状态转移方程式为：
dp[i][j] = dp[i][j]¹ + dp[i-1][j]² + dp[i-1][(j+9-a[i])%9]³
1.是经过初始化的个数，表示每个一位数对九取余都是自己，一个数
2.表述i-1个数之前的对j取余的个数
3.表示i-1个数之前对j+9-a[i]取余的个数，因为取了模，可以理解为，开始还没有取a[i]这个数，然后取了之后肯定取模就是j所以应该加进来。