蓝桥杯2020

字串分值

题目描述

对于一个字符串S，我们定义S 的分值 f(S) 为S中恰好出现一次的字符个数。例如f (”aba”) = 1，f (”abc”) = 3,
f (”aaa”) = 0。 现在给定一个字符串S[0…n-1]（长度为n），请你计算对于所有S的非空子串S[i…j](0 ≤ i ≤ j
< n)， f (S[i… j]) 的和是多少。

输入

输入一行包含一个由小写字母组成的字符串S。

输出

输出一个整数表示答案。

样例输入

ababc

样例输出

21
提示

样例说明：

子串f值：

a 1
ab 2
aba 1
abab 0
ababc 1
b 1
ba 2
bab 1
babc 2
a 1
ab 2
abc 3
b 1
bc 2
c 1

对于20% 的评测用例，1 ≤ n ≤ 10；
对于40% 的评测用例，1 ≤ n ≤ 100；
对于50% 的评测用例，1 ≤ n ≤1000；
对于60% 的评测用例，1 ≤ n ≤ 10000；
对于所有评测用例，1 ≤ n ≤ 100000。

时间超限

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int num[30];
int sum = 0;
void judge(string str){
	for(int i = 0; i < str.size(); i++){
		int t = str[i] - 97;
		num[t]++;
	}
	for(int i = 0; i < 26; i++){
		if(num[i] == 1){
			sum++;
	}
	}
}
int main(){
	string str;
	cin >> str;
	for(int i = 0; i < str.size(); i++){
		for(int j = i; j <str.size(); j++){
//			memset(num,0,sizeof(num));
			fill(num, num + 30, 0);
			judge(str.substr(i,j - i + 1));
//			cout << str.substr(i,j - i + 1) << endl;
		}
	}
	cout << sum;
     
} 

❤️❤️❤️
C++截取字符串
#include<string>函数库中
函数原型：

string substr(int pos = 0,int n ) const;

函数说明：

参数1：pos是必填参数

参数2：n是可参数，表示取多少个字符，不填表示截取到末尾

该函数功能为：返回从pos开始的n个字符组成的字符串，原字符串不被改变

#include <iostream>
#include <string>
using namespace std ;
void main()
{
    string str="Believe";
    cout << str.substr(2) <<endl ; //从字符串下标为2的地方开始截取，截取到末尾，输出lieve
    cout << s.substr(0,2) <<endl ; //从字符串下标为0的地方开始截取，截取长度为2，输出Be
    cout << s.substr(1,2) <<endl ; //输出el
}

memset
对每个字节赋值
比如int有4个字节，
memset(num,1,sizeof(num));
00000001000000010000000100000001
对于对int之类的数组，只能用memset对其初始化为0或-1。
而对于char型，可以赋任何字符。

fill()函数的用法
fill（）函数参数：fill(first,last,val);
first 为容器的首迭代器，last为容器的末迭代器，val为将要替换的值。fill赋任何值都可以

整除序列

题目描述
有一个序列，序列的第一个数是 ，后面的每个数是前一个数整除 2，请输出这个序列中值为正数的项。
输入
输入一行包含一个整数 。

输出
输出一行，包含多个整数，相邻的整数之间用一个空格分隔，表示答案。

样例输入
20
样例输出
20 10 5 2 1
提示
对于 80% 的数据，1 < n < 10的9次方 。
对于 100% 的数据，1 < n < 10的18 。

#include<bits/stdc++.h>
using namespace std;
#include<vector>
vector<long long> v;
int main(){
	long long n;
	cin >> n;
	while(n){
		v.push_back(n);
		n = n / 2;
	}
	for(auto a : v){
		cout << a << " ";
	}
}

注意取值范围
必须用long long ，刚开始用int，直接错

解码

题目描述

小明有一串很长的英文字母，可能包含大写和小写。在这串字母中，有很多连续的是重复的。小明想了一个办法将这串字母表达得更短：将连续的几个相同字母写成字母 + 出现次数的形式。
例如，连续的 5 个 a ，即 aaaaa ，小明可以简写成 a5 （也可能简写成 a4a 、 aa3a 等）。 对于这个例子：HHHellllloo，小明可以简写成 H3el5o2 。为了方便表达，小明不会将连续的超过 9 个相同的字符写成简写的形式。
现在给出简写后的字符串，请帮助小明还原成原来的串。

输入

输入一行包含一个字符串。

输出

输出一个字符串，表示还原后的串。

样例输入

H3el5o2

样例输出

HHHellllloo

提示

对于所有评测用例，字符串由大小写英文字母和数字组成，长度不超过 100 。 请注意原来的串长度可能超过 100 。

思路：判断字符串的每一位，如果是字母直接打印输出，如果是数字，就将字符先转成数字，然后循环输出k - 1;

#include<bits/stdc++.h>
using namespace std;
char c[1000];
int main(){
	string str;
	cin >> str;
	int t = 0;
	for(int i = 0; i < str.size(); i++){
		if(str[i] > '0' && str[i] <= '9'){
			int j = str[i] - '0';
			for(int k = 0; k < j - 1; k++){
				c[t++] = str[i - 1];
			}
		}
		else{
		  		c[t++] = str[i];
		}
	}
	for(int i = 0; i < t; i++){
		cout << c[i];
	} 
}

相关：
字符串常用函数：
❤️❤️❤️
核心思想：
整数转化为字符：加 ‘0’ ，然后逆序。
字符转化整数：减 ‘0’
注：整数加 ‘0’后会隐性的转化为char类型；字符减 ‘0’隐性转化为int类型

走方格

一道题简单理解dfs和动态规划
题目描述

在平面上有一些二维的点阵。

这些点的编号就像二维数组的编号一样，从上到下依次为第 1 至第 行，从左到右依次为第 1 至第 列，每一个点可以用行号和列号来表示。

现在有个人站在第 1 行第 1 列，要走到第 行第 列。

只能向右或者向下走。

注意，如果行号和列数都是偶数，不能走入这一格中。

问有多少种方案。

输入

输入一行包含两个整数n,m。

输出

输出一个整数，表示答案。

样例输入

3 4

样例输出
2

提示

1 <= n,m <= 30

解题（一）DFS

注意本题只有两个方向，开方向数组的时候2个就够。开4个的话时间超限。
直接套用DFS模板就行

#include<bits/stdc++.h>
using namespace std;
int a[31][31];
int book[31][31];
int dx[4] = {0,1};
int dy[4] = {1,0};
int num,n,m;
void dfs(int x,int y){
	int tx,ty ,k;
	if(x == n && y == m){
		num ++;
		return ;
	}
	for(int k = 0; k < 2; k++){
		tx = x + dx[k];
		ty = y + dy[k];
		if(tx < 1 || tx > n || ty < 1 || ty > m){
			continue;
		}
		if(book[tx][ty] == 0 && a[tx][ty] ==0){
			book[tx][ty] = 1;// 标记为已访问
			dfs(tx,ty);
			book[tx][ty] = 0; // 回溯
		}
	}
	
}
int main(){
	
	cin >> n >> m;
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= m; j++){
			if(i % 2 == 0 && j % 2 == 0){
				a[i][j] = 1;
			}
		}
	}
	book[1][1] = 1;
	dfs(1,1);
	cout << num;
	
}

方法（二） 动态规划
每个当前状态由可能前面的两种状态推出来，因此状态方程如下：

#include<bits/stdc++.h>
using namespace std;
int dp[31][31];
int main(){
	int n,m;
	cin >> n >> m;
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= m; j++){
			if(i == 1 && j == 1){
				dp[1][1] = 1;
				continue;
			}
			if(i % 2 == 0 && j % 2 == 0)  continue;
			dp[i][j] = dp[i - 1][j] + dp[i][j - 1];	
		}
	}
	cout << dp[n][m];
}