【思特奇杯·云上蓝桥-算法集训营】第三周

问题1 斐波那契数

斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1
给定 n ，请计算 F(n) 。

简单的递归算法

#include <iostream>
using namespace std;
long long f(int );
int main()
{
    int n;
    cin>>n;
	long long a;
    a=f(n);
    cout<<a;
}

long long f(int n)
{
    if(n==0)
    return 0;
    if(n==1)
    return 1;
	return f(n-1)+f(n-2);
}

问题2 第N个泰波那契数

泰波那契序列 Tn 定义如下：

T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2

给你整数 n，请返回第 n 个泰波那契数 Tn 的值。

同上一题，递归解决

#include <iostream>
using namespace std;
long long f(int );
int main()
{
    int n;
    cin>>n;
	long long a;
    a=f(n);
    cout<<a;
}

long long f(int n)
{
    if(n==0)
    return 0;
    if(n==1)
    return 1;
    if(n==2)
    return 1;
	return f(n-1)+f(n-2)+f(n-3);
}

问题3 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶
示例 2：

输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

 递归问题

#include <iostream>
using namespace std;
int num=0;
void f(int);

int main()
{
	int step;
	cin>>step;
	f(step);
	cout<<num;
    return 0;
}

void f(int step)
{
	if(step<0)
	return;
	if(step==0)
	num++;
	f(step-1);
	f(step-2);
}

问题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 。

只要在当前位置的前两个中选择一个最小值+当前位置的值，就是每个阶梯所花费的最小值

算法代码如下

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int n=cost.size();
        vector<int> dp(n,0);

        dp[0]=cost[0];
        dp[1]=cost[1];

        for(int i=2;i<n;i++)
                dp[i]=min(dp[i-1],dp[i-2])+cost[i];
        return min(dp[n-1],dp[n-2]);
    }
};

 问题5 买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

动态规划问题

代码如下

#include <iostream>
#include <stdlib.h>
using namespace std;
int max(int a, int b)
{
    if (a > b)
        return a;
    else
        return b;
}
int main()
{
    int array[6] = {3,2,5,4,3,6};
    int s1 = INT8_MIN, s2 = 0, s3 = INT8_MIN, s4 = 0;
    for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++)
    {
        s4 = max(s4,s3+array[i]);
        s3 = max(s3, s2 - array[i]);
        s2 = max(s2, s1 + array[i]);
        s1 = max(s1, -array[i]);
    }
    cout<<s4;
    return 0;
}

 问题6 最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。
两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

动态规划

#include<iostream>
#include<cstring>
using namespace std;
//两个原串 
char s1[1000], s2[1000];
//存放s1的左边i个字符形成的子串，与s2左边j个字符形成的子串的最长公共子序列的长度 
int maxLen[1000][1000];
int main() {
	while(cin >> s1 >> s2) {
		int len1 = strlen(s1);
		int len2 = strlen(s2);
		//先处理MaxLen(n, 0)和MaxLen(0, n)的情况  
		for(int i = 0; i <= len1; i++)
			maxLen[i][0] = 0;
		for(int j = 0; j <= len2; j++)
			maxLen[0][j] = 0;
			
		//遍历两个原串	
		for(int i = 1; i <= len1; i++) {
			for(int j = 1; j <= len2; j++) {
				if(s1[i-1] == s2[j-1])//此处的s1、s2的下表从0开始 s1[i-1]代表s1的第i个字符 
					maxLen[i][j] = maxLen[i-1][j-1] + 1;//此处的i-1、j-1与上面意义不同 
				else 
					maxLen[i][j] = max(maxLen[i-1][j], maxLen[i][j-1]);
			}
		}
		cout << maxLen[len1][len2] << endl;
	}
	return 0;
} 

问题7 杨辉三角形

 

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
LL n;
LL C(int x,int k){
  LL ans=1;
  for(int i=x,j=1;j<=k;i--,j++){
    ans=ans*i/j;
    if(ans>n)return ans;
  }
  return ans;
}
bool check(int x){
  LL l=2*x,r=max(n,l);
  while(l<r){
    int mid=l+r>>1;
    if(C(mid,x)>=n)r=mid;
    else l=mid+1;
  }
  if(C(r,x)!=n)return false;
  cout<<(LL)(r+1)*r/2+x+1<<endl;
  return true;
}
int main(){
  cin>>n;
  for(int t=17;;t--){
    if(check(t))break;
  }
  return 0;
}

问题8 节点选择

 

#include<bits/stdc++.h>

using namespace std;

vector<vector<int> > v;//存放树形结构 

int dp[100005][2] = {0};

void dfs(int a, int pre){
	for(int i = 0; i < v[a].size(); i++){
		int t = v[a][i];
		if(t != pre){//只要不是相邻节点就符合题意 
			dfs(t, a);
			dp[a][0] += max(dp[t][0], dp[t][1]);//不选择该节点，保存下一节点的最大值 
			dp[a][1] += dp[t][0];//选择该节点，下一节点只能不选择 
		}
	}
}
int main(){
	int n, a, b;
	cin >> n;
	v.resize(n + 1);//给定数据大小 
	for(int i = 1; i <= n; i ++)
		cin >> dp[i][1];//输入节点的权重 
	for(int i = 0; i < n-1; i ++){
		cin >> a >> b;//输入节点之间的关系 
		v[a].push_back(b);
		v[b].push_back(a);
	}
	dfs(1, 0);
	cout << max(dp[1][0], dp[1][1]) << endl;
	return 0;
} 

问题9 

#include<bits/stdc++.h>
using namespace std;

#define _for(i, a, b) for (int i = (a); i < (b); ++i)
#define _rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define For(i, a, b) for (int i = (a); i >= (b); --i)
#define debug(a) cout << #a << " = " << a << endl;
#define mod(x) (x) % MOD
#define ENDL "\n"
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int N = 10000 + 10;
int f[N][4];

int main()
{
#ifdef LOCAL
    freopen("data.in", "r", stdin);
#endif
    ios::sync_with_stdio(false); // 取消cin与stdin 的同步
    cout.tie(0), cin.tie(0);

    int m = 3, n;
    cin >> n;
    
    _rep(i, 1, n) f[i][1] = i;
    _rep(i, 1, n) _rep(j, 2, m) {
        f[i][j] = 0x3f3f3f3f;
        _rep(k, 1, i)
            f[i][j] = min(f[i][j], max(f[k - 1][j - 1], f[i - k][j]) + 1);
    }

    cout << f[n][m] << endl;
    return 0;
}

 问题10 k好数

 

#include<iostream>
using namespace std;
long long int K, L, C;

void fun1(int a,int b) {
	for (int i = 0; i < K; i++) {
		if (i != b + 1 && i != b - 1) {
			if (a != 2) {
				fun1(a - 1, i);
			}
			else {
				C++;
				C=C%1000000007;
			}
		}
	}
}

int main() {
	cin >> K >> L;
	C = 0;
	for (int i = 1; i < K; i++) {
		fun1(L, i);
	}
	cout << C<<endl;
	return 0;
}