1、
小易有一些彩色的砖块。每种颜色由一个大写字母表示。各个颜色砖块看起来都完全一样。现在有一个给定的字符串s,s中每个字符代表小易的某个砖块的颜色。小易想把他所有的砖块排成一行。如果最多存在一对不同颜色的相邻砖块,那么这行砖块就很漂亮的。请你帮助小易计算有多少种方式将他所有砖块排成漂亮的一行。(如果两种方式所对应的砖块颜色序列是相同的,那么认为这两种方式是一样的。)
例如: s = "ABAB",那么小易有六种排列的结果:
"AABB","ABAB","ABBA","BAAB","BABA","BBAA"
其中只有"AABB"和"BBAA"满足最多只有一对不同颜色的相邻砖块。
输入描述:
输入包括一个字符串s,字符串s的长度length(1 ≤ length ≤ 50),s中的每一个字符都为一个大写字母(A到Z)。
输出描述:
输出一个整数,表示小易可以有多少种方式。
输入例子1:
ABAB
输出例子1:
2
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main()
{
string s;
int counter=0;
cin>>s;
sort(s.begin(),s.end());
for(int i=0;i<s.length()-1;i++)
{
if(s.at(i)!=s.at(i+1))
counter++;
}
if(counter+1>=3)
cout<<0;
else cout<<(counter+1)%3;
return 0;
}
2、
如果一个数列S满足对于所有的合法的i,都有S[i + 1] = S[i] + d, 这里的d也可以是负数和零,我们就称数列S为等差数列。
小易现在有一个长度为n的数列x,小易想把x变为一个等差数列。小易允许在数列上做交换任意两个位置的数值的操作,并且交换操作允许交换多次。但是有些数列通过交换还是不能变成等差数列,小易需要判别一个数列是否能通过交换操作变成等差数列
输入描述:
输入包括两行,第一行包含整数n(2 ≤ n ≤ 50),即数列的长度。 第二行n个元素x[i](0 ≤ x[i] ≤ 1000),即数列中的每个整数。
输出描述:
如果可以变成等差数列输出"Possible",否则输出"Impossible"。
输入例子1:
3 3 1 2
输出例子1:
Possible
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
int n,temp;
vector<int> v;
cin>>n;
for(int i=0;i<n;i++)
{
cin>>temp;
v.push_back(temp);
}
sort(v.begin(),v.end());
int c=v[1]-v[0];
int i;
for(i=1;i<v.size()-1;i++)
{
if(v[i+1]-v[i]!=c)
break;
}
if(i==v.size()-1)
cout<<"Possible";
else cout<<"Impossible";
return 0;
}
如果一个01串任意两个相邻位置的字符都是不一样的,我们就叫这个01串为交错01串。例如: "1","10101","0101010"都是交错01串。
小易现在有一个01串s,小易想找出一个最长的连续子串,并且这个子串是一个交错01串。小易需要你帮帮忙求出最长的这样的子串的长度是多少。
输入描述:
输入包括字符串s,s的长度length(1 ≤ length ≤ 50),字符串中只包含'0'和'1'
输出描述:
输出一个整数,表示最长的满足要求的子串长度。
输入例子1:
111101111
输出例子1:
3
#include <iostream>
#include <string.h>
using namespace std;
int main()
{
char s[30];
int count=0,result=0;
cin>>s;
for(int i=0;i<strlen(s)-1;i++)
{
if(s[i]!=s[i+1])
count++;
else
{
result=max(result,count);
count=0;
}
}
cout<<max(result+1,count+1);
return 0;
}
小易有一个长度为n的整数序列,a_1,...,a_n。然后考虑在一个空序列b上进行n次以下操作:
1、将a_i放入b序列的末尾
2、逆置b序列
小易需要你计算输出操作n次之后的b序列。
1、将a_i放入b序列的末尾
2、逆置b序列
小易需要你计算输出操作n次之后的b序列。
输入描述:
输入包括两行,第一行包括一个整数n(2 ≤ n ≤ 2*10^5),即序列的长度。 第二行包括n个整数a_i(1 ≤ a_i ≤ 10^9),即序列a中的每个整数,以空格分割。
输出描述:
在一行中输出操作n次之后的b序列,以空格分割,行末无空格。
输入例子1:
4 1 2 3 4
输出例子1:
4 2 1 3
#include <iostream>
using namespace std;
int main()
{
int n,i,j=0;
int a[200000],b[200000];
cin>>n;
for(i=0;i<n;i++)
cin>>a[i];
for(i=n-1;i>=0;i=i-2)
{
b[j]=a[i];
j++;
}
for(i=n%j;i<n;i=i+2)
{
b[j]=a[i];
j++;
}
cout<<b[0];
for(i=1;i<n;i++)
cout<<" "<<b[i];
return 0;
}
5、
小易为了向他的父母表现他已经长大独立了,他决定搬出去自己居住一段时间。一个人生活增加了许多花费: 小易每天必须吃一个水果并且需要每天支付x元的房屋租金。当前小易手中已经有f个水果和d元钱,小易也能去商店购买一些水果,商店每个水果售卖p元。小易为了表现他独立生活的能力,希望能独立生活的时间越长越好,小易希望你来帮他计算一下他最多能独立生活多少天。
输入描述:
输入包括一行,四个整数x, f, d, p(1 ≤ x,f,d,p ≤ 2 * 10^9),以空格分割
输出描述:
输出一个整数, 表示小易最多能独立生活多少天。
输入例子1:
3 5 100 10
输出例子1:
11
#include <iostream>
using namespace std;
int main()
{
int x,f,d,p,day1;
cin>>x>>f>>d>>p;
if(d>=x*f)
day1=(d-x*f)/(p+x)+f;
else
day1=d/x;
cout<<day1;
return 0;
}
6、
小易将n个棋子摆放在一张无限大的棋盘上。第i个棋子放在第x[i]行y[i]列。同一个格子允许放置多个棋子。每一次操作小易可以把一个棋子拿起并将其移动到原格子的上、下、左、右的任意一个格子中。小易想知道要让棋盘上出现有一个格子中至少有i(1 ≤ i ≤ n)个棋子所需要的最少操作次数.
输入描述:
输入包括三行,第一行一个整数n(1 ≤ n ≤ 50),表示棋子的个数 第二行为n个棋子的横坐标x[i](1 ≤ x[i] ≤ 10^9) 第三行为n个棋子的纵坐标y[i](1 ≤ y[i] ≤ 10^9)
输出描述:
输出n个整数,第i个表示棋盘上有一个格子至少有i个棋子所需要的操作数,以空格分割。行末无空格 如样例所示: 对于1个棋子: 不需要操作 对于2个棋子: 将前两个棋子放在(1, 1)中 对于3个棋子: 将前三个棋子放在(2, 1)中 对于4个棋子: 将所有棋子都放在(3, 1)中
输入例子1:
4 1 2 4 9 1 1 1 1
输出例子1:
0 1 3 10
#include <bits/stdc++.h>
using namespace std;
// 计算曼哈顿距离
int manhattan_dist(int x1, int y1, int x2, int y2) {
return abs(x2 - x1) + abs(y2 - y1);
}
/*
求，让某一个格子(x0,y0)上有k个棋子所需要的最少操作次数
1. 求出所有棋子到某一点的曼哈顿距离，得到一个n维vector
2. 将vector从小到大排序
3. 对vector中第0个元素到第k - 1个元素求和，即前k个元素
*/
int get_dist_sum(int x0, int y0, const vector<int> &X, const vector<int> &Y, int k) {
int n = X.size();
// 1. 计算所有棋子到点(x0, y0)的曼哈顿距离，得到n维向量dists
vector<int> dists(n);
for (int i = 0; i < n; ++i)
dists[i] = manhattan_dist(x0, y0, X[i], Y[i]);
// 2. 将dists从小到大排序
sort(dists.begin(), dists.end());
// 3. 对vector中第0个元素到第k - 1个元素求和
int dist_sum = 0;
for (int i = 0; i < k; ++i)
dist_sum += dists[i];
return dist_sum;
}
/*
求，让棋盘上出现有一个格子上有k个棋子所需要的最少次数
这个函数是这道题的关键。由于计算曼哈顿距离时可以通过对x和y分别计算再求和来得到，
所以使dist_sum最小的格子的x坐标一定是X中的一个，y坐标一定是Y中的一个。
1. 遍历每一个备选格子(X[i], Y[j])，并分别计算dist_sum
2. 求得它们的最小值
*/
int min_move(int k, const vector<int> &X, const vector<int> &Y) {
int min_dist_sum = INT_MAX, n = X.size();
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
int dist_sum = get_dist_sum(X[i], Y[j], X, Y, k);
min_dist_sum = min(min_dist_sum, dist_sum);
}
}
return min_dist_sum;
}
vector<int> min_moves(int n, const vector<int> &X, const vector<int> &Y) {
vector<int> res(n, 0);
for (int k = 2; k <= n; ++k)
res[k - 1] = min_move(k, X, Y);
return res;
}
int main() {
int n = 0;
cin >> n;
vector<int> X(n), Y(n);
for (int i = 0; i < n; ++i) cin >> X[i];
for (int i = 0; i < n; ++i) cin >> Y[i];
vector<int> res = min_moves(n, X, Y);
for (int i = 0; i < n - 1; ++i) cout << res[i] << ' ';
cout << res.back() << endl;
return 0;
}
7、
小易老师是非常严厉的,它会要求所有学生在进入教室前都排成一列,并且他要求学生按照身高不递减的顺序排列。有一次,n个学生在列队的时候,小易老师正好去卫生间了。学生们终于有机会反击了,于是学生们决定来一次疯狂的队列,他们定义一个队列的疯狂值为每对相邻排列学生身高差的绝对值总和。由于按照身高顺序排列的队列的疯狂值是最小的,他们当然决定按照疯狂值最大的顺序来进行列队。现在给出n个学生的身高,请计算出这些学生列队的最大可能的疯狂值。小易老师回来一定会气得半死。
输入描述:
输入包括两行,第一行一个整数n(1 ≤ n ≤ 50),表示学生的人数 第二行为n个整数h[i](1 ≤ h[i] ≤ 1000),表示每个学生的身高
输出描述:
输出一个整数,表示n个学生列队可以获得的最大的疯狂值。 如样例所示: 当队列排列顺序是: 25-10-40-5-25, 身高差绝对值的总和为15+30+35+20=100。 这是最大的疯狂值了。
输入例子1:
5 5 10 25 40 25
输出例子1:
100先排序，在两两取数，从中间向两边插数，交替插大小数，如果是长度是奇数，需要判断一下最后一个数插在左边还是右边。
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
int n,count=0,temp1,temp2,sum=0;
vector<int> v;
int a[50];
cin>>n;
for(int i=0;i<n;i++)
{
int temp;
cin>>temp;
v.push_back(temp);
}
sort(v.begin(),v.end());
int i1=n-1;
int i2=0;
int ave=n/2;
int ave2=ave+1;
while(i1!=i2&&i1>i2){
if(count%2==0){
temp1=v[i1];
temp2=v[i2];
}
else
{
temp1=v[i2];
temp2=v[i1];
}
a[ave]=temp1;
a[ave2]=temp2;
count++;
i1--;
i2++;
ave--;
ave2++;
}
/*
if(n%2==1)
a[ave]=v[n/2];
*/
if(n%2==1)
{
if(abs(a[ave+1]-v[n/2])>abs(a[ave2-1]-v[n/2]))
{
a[ave]=v[n/2];
ave--;
}
else
{
a[ave2]=v[n/2];
ave2++;
}
}
for(int i=ave+1;i<ave2-1;i++)
{
sum=sum+abs(a[i]-a[i+1]);
}
cout<<sum;
return 0;
}
小易非常喜欢拥有以下性质的数列:
1、数列的长度为n
2、数列中的每个数都在1到k之间(包括1和k)
3、对于位置相邻的两个数A和B(A在B前),都满足(A <= B)或(A mod B != 0)(满足其一即可)
例如,当n = 4, k = 7
那么{1,7,7,2},它的长度是4,所有数字也在1到7范围内,并且满足第三条性质,所以小易是喜欢这个数列的
但是小易不喜欢{4,4,4,2}这个数列。小易给出n和k,希望你能帮他求出有多少个是他会喜欢的数列。
输入描述:
输入包括两个整数n和k(1 ≤ n ≤ 10, 1 ≤ k ≤ 10^5)
输出描述:
输出一个整数,即满足要求的数列个数,因为答案可能很大,输出对1,000,000,007取模的结果。
输入例子1:
2 2
输出例子1:
3利用 动态规划，dp[j][i]表示长度为i，最后一个数字是j的数列的个数，则有dp[j][i]+=dp[j][i-1]，这样没有考虑到题目的条件，即B不能是A的约数，我们可以再来计算1-k这些数中是j的约数的和，然后满足条件的就是总和减去不满足的。最后输出长度为n的，取值在1-k的所有满足条件和就是结果。
#include <iostream>
const int mod = 1e9 + 7;
const int maxn = 1e5 + 5;
int dp[maxn][15];
int n,k;
using namespace std;
int main()
{
cin>>n>>k;
dp[1][0]=1; //dp[ij][i]表示数列最后一个数字是j，长度为i的合格数
for(int i=1;i<=n;i++)
{
int sum=0;
for(int j=1;j<=k;j++)
{
sum += dp[j][i - 1];
sum %= mod;
}
//上边求得是总和
//长度为i-1的基础上，加上数字j
for(int j = 1; j <= k; j++) {
int sum2 = 0;
for(int z = j + j; z <= k; z += j) { // 去掉j的约数的那部分
sum2 += dp[z][i - 1];
sum2 %= mod;
}
//上边求得是无效 的
dp[j][i] = (sum - sum2 + mod) % mod;
//总和-无效
}
}
//长度为n，数字为1-k的所有合格数列求和
int ans = 0;
for(int j = 1; j <= k; j++) {
ans += dp[j][n];
ans %= mod;
}
cout << ans << endl;
return 0;
}
扫一扫
879
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
