目录
1 子串简写
题目描述
程序猿圈子里正在流行一种很新的简写方法：对于一个字符串，只保留首尾字符，将首尾字符之间的所有字符用这部分的长度代替。例如 internation-alization 简写成 i18n，Kubernetes （注意连字符不是字符串的一部分）简写成 K8s, Lanqiao 简写成 L5o 等。
在本题中，我们规定长度大于等于 K 的字符串都可以采用这种简写方法（长度小于 K 的字符串不配使用这种简写）。
给定一个字符串 S 和两个字符 c1 和 c2，请你计算 S 有多少个以 c1 开头c2 结尾的子串可以采用这种简写？
输入格式
第一行包含一个整数 K。
第二行包含一个字符串 S 和两个字符 c1 和 c2。
输出格式
一个整数代表答案。
样例输入
4 abababdb a b
样例输出
6
提示
符合条件的子串如下所示，中括号内是该子串：
[abab]abdb
[ababab]db
[abababdb]
ab[abab]db
ab[ababdb]
abab[abdb]
对于 20% 的数据，2 ≤ K ≤ |S | ≤ 10000。
对于 100% 的数据，2 ≤ K ≤ |S | ≤ 5 × 105。S 只包含小写字母。c1 和 c2 都是小写字母。
|S | 代表字符串 S 的长度。
代码实现
#include <iostream>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <string>
#include <algorithm>
using namespace std;
typedef long long ll;
const int N = 5e5 + 10;
int a[N];
int n,m;
int mem[N];
int st[N];
string s;
int dfs(int x)
{
}
/*
4
abababdb a b
输出:6
*/
int main()
{
scanf("%d",&n);
char c1,c2;
cin>>s>>c1>>c2;
ll sum = 0, ans = 0;
// 以c2开始，看前面的c1的数量，计算c1时前缀和
for(int i = 0, j = n - 1; i < s.length(); i ++, j++)
{
if(s[i] == c1) sum ++;
if(s[j] == c2) ans += sum;
}
cout<<ans;
/* 最初的暴力思想
for(int i = 0; i < s.length() - n + 1; i ++)
{
if(s[i] == c1)
for(int j = i + n - 1; j < s.length(); j ++)
{
if(s[j] == c2) sum++;
}
}
cout<<sum;
*/
return 0;
}
2 接龙数列
题目描述
对于一个长度为 K 的整数数列：A1, A2, . . . , AK，我们称之为接龙数列当且仅当 Ai 的首位数字恰好等于 Ai−1 的末位数字 (2 ≤ i ≤ K)。
例如 12, 23, 35, 56, 61, 11 是接龙数列；12, 23, 34, 56 不是接龙数列，因为 56的首位数字不等于 34 的末位数字。所有长度为 1 的整数数列都是接龙数列。
现在给定一个长度为 N 的数列 A1, A2, . . . , AN，请你计算最少从中删除多少个数，可以使剩下的序列是接龙序列？
输入格式
第一行包含一个整数 N。
第二行包含 N 个整数 A1, A2, . . . , AN。
输出格式
一个整数代表答案。
样例输入
5 11 121 22 12 2023
样例输出
1
提示
删除 22，剩余 11, 121, 12, 2023 是接龙数列。
对于 20% 的数据，1 ≤ N ≤ 20。
对于 50% 的数据，1 ≤ N ≤ 10000。
对于 100% 的数据，1 ≤ N ≤ 105，1 ≤ Ai ≤ 109。所有 Ai 保证不包含前导 0。
思路分析
代码中动态规划状态转移方程如下，首先提取每个数字的首位 x 和末位 y
dp[y]的意思是以y为结尾的接龙数列的长度。
以题目中的例子举例：11 121 22 12 2023
第一个11被选择，dp[1] = 1，接下来121，x = 1, y = 1，显然，121是可以添加进来的
此时dp[1] = max(dp[1], dp[1] + 1) = 2.
接下来轮到22，x = 2, y = 2, dp[2] 原来没有，所以要选择，dp[2] = max(dp[2], d[2] + 1) = 1
接着是12，x = 1, y = 2, 可以接到11 121 的后面，所以以2为结尾的最长长度为3
dp[2] = max(dp[2], d[1] + 1) = 3
接着是2023, x = 2, y = 3, 有两个选择，要么接到22后面，要么接到11 121 12 后面，观察知道接到第二个后面的长度更长，此时 dp[3] = max(dp[3], dp[2] + 1) = 4
int x = s[j - 1], y = s[0];//x是最位，y是最低位
dp[y] = max(dp[y], dp[x] + 1);
代码实现
#include <iostream>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const int N = 100005;
int a[N];
int n,m;
int mem[N];
int st[N];
int dp[10];
/*
5
11 121 22 12 2023
输出：1
*/
int main()
{
scanf("%d",&n);
for(int i = 1; i <= n; i ++)
{
scanf("%d",&a[i]);
int s[15],j = 0;
while(a[i])
{
s[j++] = a[i] % 10;
a[i] /= 10;
}
int x = s[j - 1], y = s[0];//x是最位，y是最低位
dp[y] = max(dp[y], dp[x] + 1);
}
int ans = 0;
for(int i = 0; i < 10; i ++) ans = max(ans, dp[i]);
cout<<n - ans;
return 0;
}
3 带分数
题目描述
100 可以表示为带分数的形式：100 = 3 + 69258 / 714。
还可以表示为：100 = 82 + 3546 / 197。
注意特征：带分数中，数字1~9分别出现且只出现一次（不包含0）。
类似这样的带分数，100 有 11 种表示法。
输入格式
从标准输入读入一个正整数N (N< 1000*1000)
输出格式
程序输出该数字用数码1~9不重复不遗漏地组成带分数表示的全部种数。
注意：不要求输出每个表示，只统计有多少表示法！
样例输入
100
样例输出
11
思路分析
1.枚举1-9的全排列
2.将全排类分割成a b c
3.判断该枚举的数组成的a b c，是否可以使等式成立
成立的话，res++;
代码实现
#include <iostream>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
#define N 100
int a[N];
int n,m;
int mem[N];
int st[N];
int res;
int calculate(int l, int r) // 计算几个数字的和
{
int res = 0;
for(int i = l; i <= r; i++)
{
res = res * 10 + a[i];
}
return res;
}
void dfs(int x)
{
if(x > 8)
{
for(int i = 0; i < 9 - 2; i ++)
{
for(int j = i + 1; j < 9 - 1; j++)
{
int a = calculate(0, i);
int b = calculate(i + 1, j);
int c = calculate(j + 1, 8);
//if( n == a + b / c)
if( n * c == (a * c + b))
res++;
}
}
return ;
}
for(int i = 1; i <= 9; i ++)
{
if(!st[i])
{
a[x] = i;
st[i] = true;
dfs(x + 1);
st[i] = false;
}
}
}
/*思路
1.枚举1-9的全排列
2.将全排类分割成a b c
3.判断该枚举的数组成的a b c，是否可以使等式成立
成立的话，res++;
*/
int main()
{
scanf("%d",&n);
dfs(0);
printf("%d",res);
return 0;
}
4 等差数列
题目描述
数学老师给小明出了一道等差数列求和的题目。但是粗心的小明忘记了一 部分的数列，只记得其中 N 个整数。
现在给出这 N 个整数，小明想知道包含这 N 个整数的最短的等差数列有 几项?
输入格式
输入的第一行包含一个整数 N。 第二行包含N个整数A1,A2,···,AN。(注意A1 ∼AN并不一定是按等差数
列中的顺序给出)
(对于所有评测用例，2≤ N ≤100000，0≤ Ai ≤10的9次方。)
输出格式
输出一个整数表示答案
样例输入
5 2 6 4 10 20
样例输出
10
思路分析
本题主要分析公差的情况，有三种情况：0，1，其他
代码实现
#include <iostream>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
#define N 100005
int a[N];
int n,m;
int mem[N];
int st[N];
int dfs(int x)
{
}
/*
5
2 6 4 10 20
输出: 10
*/
int main()
{
scanf("%d",&n);
for(int i = 0; i < n; i ++) scanf("%d",&a[i]);
sort(a,a + n);
int d = 10000000;
for(int i = 0; i < n - 1; i ++)
{
d = min(d, a[i + 1] - a[i]);
}
if(d == 0) // 序列一样
{
cout<<n;
return 0;
}
if(d == 1) // 公差为 1
{
cout<<a[n - 1] - a[0] + 1;
return 0;
}
int res = 0;
res = (a[n - 1] - a[0]) / d + 1; // 公差为其他
cout<<res;
return 0;
}
5 砝码称重（dfs过50%，dp）
题目描述
你有一架天平和 N 个砝码，这 N 个砝码重量依次是 W1, W2, · · · , WN。
请你计算一共可以称出多少种不同的重量？
注意砝码可以放在天平两边。
输入格式
输入的第一行包含一个整数 N。
第二行包含 N 个整数：W1, W2, W3, · · · , WN。
输出格式
输出一个整数代表答案。
样例输入
3 1 4 6
样例输出
10
思路分析：
蓝桥杯—砝码称重—Java_怎么计算出第3个砝码的重量是多少-CSDN博客蓝桥杯 砝码称重 C语言_砝码能表示的重量总数c语言-CSDN博客蓝桥杯—砝码称重—Java_怎么计算出第3个砝码的重量是多少-CSDN博客
代码实现
dfs
#include <iostream>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
#define N 100005
int a[N];
int n,m;
int mem[N];
int st[N];
int cnt[N];
void dfs(int i,int j)
{
if(i>n)
{
if(j!=0)
cnt[j] = 1;
return;
}
dfs(i+1,j);
dfs(i+1,j+a[i+1]);
dfs(i+1,abs(j-a[i+1]));
}
/*
3
1 4 6
输出:10
*/
int main()
{
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
sort(a + 1, a + n + 1);
dfs(0,0);
int res = 0;
for (int i = 1; i <= N; i++)
{
if(cnt[i] == 1)
res++;
}
cout<<res;
}dp
#include <iostream>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
/*
3
1 4 6
输出:10
*/
int main(void){
int n;
scanf("%d", &n);
int i, j;
int W[n];
int dp[n][100010]; //对于dp[i][j]，i表示前i+1个砝码，j表示可以称出的重量，
//dp[i][j]值为1即为前i+1个砝码可以称出质量j
int total = 0; //算出总质量来约束j
for(i = 0 ; i < n ; i++){
scanf("%d", &W[i]);
total += W[i];
}
dp[0][W[0]] = 1; //第一个肯定称重
for(i = 1 ; i < n ; i++)
{
for(j = 1 ; j < total ; j++)
{
if(dp[i-1][j] == 1) //如果前i-1个砝码称重为j, 那么前i个砝码可以称重的如下三种情况
{
dp[i][j] = dp[i-1][j];
dp[i][j+W[i]] = 1;
dp[i][abs(j-W[i])] = 1;
}
if(j == W[i])
{
dp[i][j] = 1;
}
}
}
int num = 0;
for(j = 1 ; j <= total ; j++)//进行计数，每个可以称出的质量只需计一次
{
if(dp[n-1][j] == 1)
{
num++;
}
}
printf("%d", num);
return 0;
}6 飞机降落
题目描述
N 架飞机准备降落到某个只有一条跑道的机场。其中第 i 架飞机在 Ti 时刻到达机场上空，到达时它的剩余油料还可以继续盘旋 Di 个单位时间，即它最早
可以于 Ti 时刻开始降落，最晚可以于 Ti + Di 时刻开始降落。降落过程需要 Li个单位时间。
一架飞机降落完毕时，另一架飞机可以立即在同一时刻开始降落，但是不能在前一架飞机完成降落前开始降落。
请你判断 N 架飞机是否可以全部安全降落。
输入格式
输入包含多组数据。
第一行包含一个整数 T，代表测试数据的组数。
对于每组数据，第一行包含一个整数 N。
以下 N 行，每行包含三个整数：Ti，Di 和 Li。
输出格式
对于每组数据，输出 YES 或者 NO，代表是否可以全部安全降落。
样例输入
2 3 0 100 10 10 10 10 0 2 20 3 0 10 20 10 10 20 20 10 20
样例输出
YES NO
代码实现
#include <iostream>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const int N = 11;
int T[N],D[N],L[N];
bool used[N],have_answer;
int a[N];
int m,n;
int mem[N];
int st[N];
void dfs(int x,int time)
{
if(have_answer) return ;
if(x == n)
{
have_answer = 1;
return ;
}
for(int i = 1; i <= n; i++)
{
if(!used[i] && time <= T[i] + D[i])
{
used[i] = 1;
dfs(x + 1, max(T[i],time) + L[i]); //体现最早降落时间,max那个地方,可以等等
if(have_answer) return ;
used[i] = 0;
}
}
}
void solve()
{
have_answer = 0;
cin>>n;
for(int i = 1; i <= n; i ++)
{
cin>>T[i]>>D[i]>>L[i];
used[i] = 0;
}
dfs(0,0);
if(have_answer) cout<<"YES\n";
else cout<<"NO\n";
}
/*
2
3
0 100 10
10 10 10
0 2 20
3
0 10 20
10 10 20
20 10 20
输出：
YES
NO
*/
int main()
{
int T;
scanf("%d",&T);
while(T--) solve();
return 0;
}
7 双向排序
题目描述
给定序列 (a1, a2, · · · , an) = (1, 2, · · · , n)，即 ai = i。
小蓝将对这个序列进行 m 次操作，每次可能是将 a1, a2, · · · , aqi 降序排列，或者将 aqi , aqi+1, · · · , an 升序排列。
请求出操作完成后的序列。
输入格式
输入的第一行包含两个整数 n, m，分别表示序列的长度和操作次数。
接下来 m 行描述对序列的操作，其中第 i 行包含两个整数 pi, qi 表示操作类型和参数。当 pi = 0 时，表示将 a1, a2, · · · , aqi 降序排列；当 pi = 1 时，表示将 aqi , aqi+1, · · · , an 升序排列。
输出格式
输出一行，包含 n 个整数，相邻的整数之间使用一个空格分隔，表示操作完成后的序列。
样例输入
3 3 0 3 1 2 0 2
样例输出
3 1 2
思路分析
直接sort，不能过全部样例，只能过60%
代码实现
#include <iostream>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
#define N 100005
int a[N];
int n,m;
int mem[N];
int st[N];
int dfs(int x)
{
}
bool cmp(int a,int b) // 降序
{
return a > b;
}
/*
3 3
0 3
1 2
0 2
输出:3 1 2
*/
int main()
{
cin>>n>>m;
int p,q;
for(int i = 0; i < n; i ++) a[i] = i + 1;
for(int i = 0; i < m; i ++)
{
cin>>p>>q;
if(p == 0) // 降序
{
sort(a + 0, a + q, cmp);
}
else
{
sort(a + q - 1, a + n);
}
}
for(int i = 0; i < n; i ++) cout<<a[i]<<" ";
return 0;
}
8 四平方和
题目描述
四平方和定理，又称为拉格朗日定理：
每个正整数都可以表示为至多4个正整数的平方和。
如果把0包括进去，就正好可以表示为4个数的平方和。
比如：
5 = 0^2 + 0^2 + 1^2 + 2^2
7 = 1^2 + 1^2 + 1^2 + 2^2
（^符号表示乘方的意思）
对于一个给定的正整数，可能存在多种平方和的表示法。
要求你对4个数排序：
0 <= a <= b <= c <= d
并对所有的可能表示法按 a,b,c,d 为联合主键升序排列，最后输出第一个表示法
输入格式
程序输入为一个正整数N (N<5000000)
输出格式
要求输出4个非负整数，按从小到大排序，中间用空格分开
样例输入
5
样例输出
0 0 1 2
代码实现
#include <iostream>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
#define N 100
int a[N];
int n,m;
int mem[N];
int st[N];
int main()
{
scanf("%d",&n);
for(int i = 0 ; i * i <= n; i ++)
{
for(int j = i ; i * i + j * j <= n; j ++)
{
for(int k = j ; i * i + j * j + k * k <= n; k ++)
{
for(int l = j ; i * i + j * j + k * k + l * l <= n; l ++)
{
if(i * i + j * j + k * k + l * l == n)// 或者不用枚举l，直接计算l，如下面注释
{
/*
int d sqrt(n a*a b*b c*c);
if(n =a*a b*b+c*c +d*d)
printf("%d %d %d %d\n",a,b,c,d);
return 0;
*/
cout<<i<<" "<<j<<" "<<k<<" "<<l;
return 0;
}
}
}
}
}
return 0;
}
9 冶炼金属
题目描述
小蓝有一个神奇的炉子用于将普通金属 O 冶炼成为一种特殊金属 X。这个炉子有一个称作转换率的属性 V，V 是一个正整数，这意味着消耗 V 个普通金
属 O 恰好可以冶炼出一个特殊金属 X，当普通金属 O 的数目不足 V 时，无法继续冶炼。
现在给出了 N 条冶炼记录，每条记录中包含两个整数 A 和 B，这表示本次投入了 A 个普通金属 O，最终冶炼出了 B 个特殊金属 X。每条记录都是独立
的，这意味着上一次没消耗完的普通金属 O 不会累加到下一次的冶炼当中。
根据这 N 条冶炼记录，请你推测出转换率 V 的最小值和最大值分别可能是多少，题目保证评测数据不存在无解的情况。
输入格式
第一行一个整数 N，表示冶炼记录的数目。
接下来输入 N 行，每行两个整数 A、B，含义如题目所述。
输出格式
输出两个整数，分别表示 V 可能的最小值和最大值，中间用空格分开。
样例输入
3 75 3 53 2 59 2
样例输出
20 25
提示
当 V = 20 时，有：⌊75/20⌋ = 3，⌊ 53/20 ⌋ = 2，⌊ 59/20 ⌋ = 2，可以看到符合所有冶炼记录。
当 V = 25 时，有：⌊75/25⌋ = 3，⌊ 53/25 ⌋ = 2，⌊ 59/25 ⌋ = 2，可以看到符合所有冶炼记录。
且再也找不到比 20 更小或者比 25 更大的符合条件的 V 值了。
对于 30% 的评测用例，1 ≤ N ≤ 102。
对于 60% 的评测用例，1 ≤ N ≤ 103。
对于 100% 的评测用例，1 ≤ N ≤ 104，1 ≤ B ≤ A ≤ 109。
思路分析】
二分答案
代码实现
#include <iostream>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
#define N 10005
int a[N],b[N];
int n,m;
int mem[N];
int st[N];
bool check_min(int V)
{
for(int i = 1; i <= n;i ++)
if(a[i] / V > b[i]) return false;
return true;
}
bool check_max(int V)
{
for(int i = 1; i <= n;i ++)
if(a[i] / V < b[i]) return false;
return true;
}
/*
3
75 3
53 2
59 2
输出:20 25
*/
int main()
{
ios::sync_with_stdio(0); cin.tie(0);
cin>>n;
for(int i = 1; i <= n; i ++) cin>>a[i]>>b[i];
int L = 1,R = 1000000000, V_min;
while(L <= R)
{
int mid = L+R>>1;
if(check_min(mid)) //查找小的,所以让右边往左边缩
{
V_min = mid;
R = mid - 1;
}
else L = mid + 1;
}
L = 1,R = 1000000000;
int V_max;
while(L <= R)
{
int mid = L+R>>1;
if(check_max(mid))
{
V_max = mid;
L = mid + 1;
}
else R = mid - 1;
}
cout<<V_min<<" "<<V_max;
return 0;
}
547
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
