【思特奇杯·云上蓝桥·算法集训营】第三周
作者：互联网
1. 斐波那契数列
题目描述
斐波那契数，通常用 F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 1和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：
F(0) = 1，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1
给你 n ，请计算 F(n) 。
#include<stdio.h>
int F(int n)
{
if (n == 1 || n == 2)
{
return 1;
}
else
{
return F(n - 1) + F(n - 2);
}
}
int main()
{
int n,f;
scanf("%d", &n);
f = F(n);
printf("f=%d", f);
return 0;
} 2. 第 N 个泰波那契数
题目描述
泰波那契序列 Tn 定义如下：
T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2
给你整数 n，请返回第 n 个泰波那契数 Tn 的值。
示例 1：
输入：n = 4
输出：4
解释：
T_3 = 0 + 1 + 1 = 2
T_4 = 1 + 1 + 2 = 4
示例 2：
输入：n = 25
输出：1389537
#include<stdio.h>
int F(int n)
{
int a=0,b=1,c=1,d=0; //给前三项赋值
if (n == 0)
{
return 0;
}else if(n <= 2){
return 1;
}
while(n>2){
d=a+b+c;
a=b;
b=c;
c=d;
n--;
}
return d;
}
int main()
{
int n,f;
scanf("%d",&n);
f=F(n);
printf("%d",f);
return 0;
}3.爬楼梯
题目描述
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
示例 1：
输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶
示例 2：
输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶
#include<stdio.h>
int F(int n)
{
if (n == 1)
{
return 1;
}
if(n == 2){
return 2;
}
if(n > 2){
return F(n - 1) + F(n - 2);
}
}
int main()
{
int n,f;
scanf("%d", &n);
f = F(n);
printf("f=%d", f);
return 0;
} 4.使用最小花费爬楼梯
题目描述
给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。
你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。
请你计算并返回达到楼梯顶部的最低花费。
示例 1：
输入：cost = [10,15,20]
输出：15
解释：你将从下标为 1 的台阶开始。
支付 15 ，向上爬两个台阶，到达楼梯顶部。
总花费为 15 。
示例 2：
输入：cost = [1,100,1,1,1,100,1,1,100,1]
输出：6
解释：你将从下标为 0 的台阶开始。
支付 1 ，向上爬两个台阶，到达下标为 2 的台阶。
支付 1 ，向上爬两个台阶，到达下标为 4 的台阶。
支付 1 ，向上爬两个台阶，到达下标为 6 的台阶。
支付 1 ，向上爬一个台阶，到达下标为 7 的台阶。
支付 1 ，向上爬两个台阶，到达下标为 9 的台阶。
支付 1 ，向上爬一个台阶，到达楼梯顶部。
总花费为 6 。
int minCostClimbingStairs(vector<int>& cost) {
vector<int> M(cost.begin(),cost.begin()+2);
for(int i = 2;i<static_cast<int>(cost.size());i++)
{
M.push_back(cost[i] + min(M[i-1] , M[i-2]));
}
return min(M[cost.size()-1],M[cost.size()-2]);
}5.买卖股票的最佳时机
题目描述
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
示例 1：
输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
示例 2：
输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。
class Solution {
public:
int maxProfit(vector<int>& prices) {
if(prices.empty())
return 0;
int cnt=0;
for (int i=0;i<prices.size()-1;++i)
{
if(prices[i]<prices[i+1])
cnt += prices[i+1]-prices[i];
}
return cnt;
}
};6.最长公共子序列
题目描述
给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。
一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。
两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。
示例 1：
输入：text1 = “abcde”, text2 = “ace”
输出：3
解释：最长公共子序列是 “ace” ，它的长度为 3 。
示例 2：
输入：text1 = “abc”, text2 = “abc”
输出：3
解释：最长公共子序列是 “abc” ，它的长度为 3 。
示例 3：
输入：text1 = “abc”, text2 = “def”
输出：0
解释：两个字符串没有公共子序列，返回 0 。
#include <stdio.h>
void LSCLength(char a[],char b[],int c[11][10],int lsc[11][10],int la,int lb)
{
for(int i=0;i<=la;i++) lsc[0][i]=0;
for(int i=0;i<=lb;i++) lsc[i][0]=0;
for(int i=1;i<=la;i++)
{
for(int j=1;j<=lb;j++){
if(a[i-1]==b[j-1])
{
lsc[i][j]=lsc[i-1][j-1]+1;
c[i][j]=1;
}
else if(lsc[i-1][j]>=lsc[i][j-1])
{
lsc[i][j]=lsc[i-1][j];
c[i][j]=2;
}
else{
lsc[i][j]=lsc[i][j-1];
c[i][j]=3;
}
}
}
}
void LSC(int i,int j,char a[],int c[11][10])
{
if(i==0 || j==0) return;
if(c[i][j]==1)
{
LSC(i-1,j-1,a,c);
printf("%3c ",a[i-1]);
}
else if(c[i][j]==2)
{
LSC(i-1,j,a,c);
}
else
{
LSC(i,j-1,a,c);
}
}
int main(int argc, char** argv) {
char a[10]={'d','i','d','a','c','t','i','c','a','l'};
char b[9]={'a','d','v','a','n','t','a','g','e'};
int c[11][10]={0};
int lsc[11][10]={0};
LSCLength(a,b,c,lsc,10,9);
for(int i=0;i<=10;i++)
{
for(int j=0;j<=9;j++)
{
printf("%d ",lsc[i][j]);
}
printf("\n");
}
printf("长度：%d\n比较情况\n",lsc[10][9]);
for(int i = 0;i<11;i++){
for(int j = 0;j<10;j++){
printf("%3d",c[i][j]);
}
printf("\n");
}
LSC(10,9,a,c);
return 0;
} 7、杨辉三角
#include<iostream>
using nameapace std;
int N;
long long C(int n,int m){
long long t = 1;
for(int i =0;i<m;i++){
t= t*(n-i)/(i+1);
if(t>N)
return t;
}
return t;
}
bool find(int L,int R,int x){
long long ans = 0,M = 0;
while(R>=L){
int T = (R+L)>>1;
ans = C(T,x);
if(ans<=N)
M = T,L=T+1;
else
R = T - 1;
}
if(C(M,x)==N){
cout<<(1+M)*M/2 + x + 1;
return true;
}
return false;
}
int main(){
cin >> N;
if(N == 1)
cout<<1;
else
for(int i=17;i>0;i--)
if(find(i*2,N,i))
break;
reutrn 0;
}
8.节点选择
题目描述
有一棵 n 个节点的树，树上每个节点都有一个正整数权值。如果一个点被选择了，那么在树上和它相邻的点都不能被选择。求选出的点的权值和最大是多少？
样例输入
5
1 2 3 4 5
1 2
1 3
2 4
2 5
样例输出
12
#include<iostream>
using namespace std;
const int M = 100;
int max(int x,int y){
return x<y?y:x;
}
int a[M+5],p[M+5];
int son[M+5][M+5];
bool bo[M+5];
int find(int x,bool can){
if(!p[x])
return can?a[x]:0;
int ans = 0;
for(int i = 0;i<p[x];i++){
ans += find(son[x][i],true);
}
if(can){
int t = a[x];
for(int i = 0;i<p[x];i++)
t += find(son[x][i],false);
ans = max(ans,t);
}
return ans;
}
int main(){
cin>>n;
for(int i =1;i <= n; i++){
cin>>a[i];
}
for(int i =1;i < n; i++){
int t1,t2;
cin>>t1>>t2;
son[t1][p[t1]++]=t2;
}
cout<<find(1,true);
return 0;
}9.耐摔指数
题目描述
x 星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。
塔的各层高度都是一样的。他们的第 1 层不是地面，而是相当于我们的 2 楼。
他们的地面层为 0 层。如果手机从第 7 层扔下去没摔坏，但第 8 层摔坏了，则
手机耐摔指数 = 7。
特别地，如果手机从第 1 层扔下去就坏了，则耐摔指数 = 0。
如果到了塔的最高层第 n 层扔没摔坏，则耐摔指数 = n。
为了加快测试进度，从每个型号手机中，抽样 3 部参加测试。
问题来了：如果已知了测试塔的高度 n，并且采用最佳的策略，在最坏的运气下
需要测试多少次才能确定手机的耐摔指数呢？
#include<iostream>
using namespace std;
int dp[2][10001];
int main(){
int n;
cin>>n;
int i=0;
while(dp[1][i]<n){
i++;
dp[0][i]=dp[1][i-1]+i;
dp[1][i]=dp[1][i-1]+dp[0][i-1]+1;
}
cout<<i<<endl;
return 0;
}10.K 好数
题目描述
如果一个自然数 N 的 K 进制表示中任意的相邻的两位都不是相邻的数字，那么
我们就说这个数是 K 好数。求 L 位 K 进制数中 K 好数的数目。例如 K = 4，L = 2
的时候，所有 K 好数为 11、13、20、22、30、31、33 共 7 个。由于这个数目很
大，请你输出它对 1000000007 取模后的值。
输入格式
输入包含两个正整数，K 和 L。
输出格式
输出一个整数，表示答案对 1000000007 取模后的值。
样例输入
4 2
样例输出
7
#include<stdio.h>
int main(){
int k,l,i,j,m,sum;//因为int（32位）最大值为2147483647
//所以每次计算对1000000007取余就不会溢出
scanf("%d%d",&k,&l);
if(l==1){
printf("%d",k);//L=1时特殊讨论
}
else{
int dp[l+1][k];//0位不用以1位位开始所以是l+1，为了方便理解
for(i=0;i<k;i++){
dp[1][i]=1;//给1位数初始化为1
}
for(i=2;i<l+1;i++){//此处i代表i位
for(j=0;j<k;j++){//j代表以j开头的数
sum=0;//初始化sum
for(m=0;m<k;m++){//遍历i-1位所有情况
if(m-j!=1&&j-m!=1){//不相邻的进入
sum=(sum+dp[i-1][m])%1000000007;
}
}
dp[i][j]=sum;//把值赋给该位置
}
}
sum=0;//初始化sum
for(i=1;i<k;i++){//当位数超过1位时0不能做为开头所以舍去，k=1时直接进不了循环，所以输出0
sum=(sum+dp[l][i])%1000000007;//相加得到结果
}
printf("%d",sum);
}
return 0;
}标签：输出,集训营,return,示例,int,蓝桥,cost,台阶,云上 来源： https://blog.csdn.net/weixin_62647425/article/details/122676716