1、跳台阶

 有一楼梯共m级，刚开始时你在第一级，若每次只能跨上一级或二级，要走上第m级，共有多少走法？

注：规定从一级到一级有0种走法。

#include<iostream>
#include<vector>
using namespace std;

int main(){
    int k;
    cin >> k;
    int n;
    while(k--)>0) {
    
    cin >> n;
    if(n==1) {
        cout << 0 << endl;
          continue;
    }
    vector<int> steps(n,1);
    
    for(int i=2;i<n;i++) {
        steps[i] = steps[i-1] + steps[i-2];
    }
    
    cout << steps[n-1] << endl;
    
    }
}


#include<iostream>
using namespace std;
 
int main()
{
    int n;
    cin>>n;

    int a[41]={0};
    a[1]=1;
    a[2]=1;
    for(int i=3;i<=40;i++)
        a[i]=a[i-1]+a[i-2];
    while(n--)
    {
        int num;
        cin>>num;
        cout<<a[num]<<endl;
    }
}

2、击鼓传花

聪明的小赛提出一个有趣的问题：有多少种不同的方法可以使得从小赛手里开始传的花，传了m次以后，又回到小赛手里。对于传递的方法当且仅当这两种方法中，接到花的同学按接球顺序组成的序列是不同的，才视作两种传花的方法不同。比如有3个同学1号、2号、3号，并假设小赛为1号，花传了3次回到小赛手里的方式有1->2->3->1和1->3->2->1，共2种。

输入：输入共一行，有两个用空格隔开的整数n，m（3<=n<=30，1<=m<=30）

输出：输出共一行，有一个整数，表示符合题意的方法数

#include<iostream>
#include<vector>
using namespace std;
int main()
{
    int n, m;
    cin >> n >> m;

    vector<vector<int> > A(2, vector<int>(n));
    A[0][0] = 1;
    for (int i = 1; i < n; i++)
        A[0][i] = 0;
    
    int p = 1;
    for (int i = 1; i <= m; i++,p=1-p)
    {
        for (int j = 0; j < n; j++)
        {
            A[p][j] = A[1 - p][(j - 1 + n) % n] + A[1 - p][(j + 1) % n];//DP的递推方程
        }
    }
    cout << A[1-p][0] << endl;
    return 0;
}

3、股神

经过严密的计算，小赛买了一支股票，他知道从他买股票的那天开始，股票会有以下变化：第一天不变，以后涨一天，跌一天，涨两天，跌一天，涨三天，跌一天…依此类推。

为方便计算，假设每次涨和跌皆为1，股票初始单价也为1，请计算买股票的第n天每股股票值多少钱？

                                            
#include <iostream>
using namespace std;

int GetValue(int n)
{
    int i = 0;// i统计遇到了多少次下跌
    int j = 2;// 每次下跌之后上涨的天数，包含已经下跌的那天
    int k = n;
    while (k > j) {
        i += 2;
        k -= j;
        ++j;
    }
    return n - i;
}

int main()
{
    int n;
    while (cin >> n) {
        cout << GetValue(n) << endl;
    }
    return 0;
}

4、约德尔测试

说起约德尔人的未来，黑默丁格曾经提出了一个约德尔测试，将约德尔人的历史的每个阶段都用一个字符表达出来。(包括可写字符,不包括空格。)。然后将这个字符串转化为一个01串。转化规则是如果这个字符如果是字母或者数字，这个字符变为1,其它变为0。然后将这个01串和黑默丁格观测星空得到的01串做比较，得到一个相似率。相似率越高,则约德尔的未来越光明。

请问:相似率为多少？

输入：每组输入数据为两行，第一行为有关约德尔人历史的字符串，第二行是黑默丁格观测星空得到的字符串。(两个字符串的长度相等,字符串长度不小于1且不超过1000。)

输出：输出一行，在这一行输出相似率。用百分数表示。(相似率为相同字符的个数/总个数,精确到百分号小数点后两位。printf(“%%”);输出一个%。)

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<string>
using namespace std;
string a,b;
bool isAlph(char &c) {
  return ((c>='a'&&c<='z')||(c>='A'&&c<='Z'));
}
bool isNum(char &c) {
  return (c>='0'&&c<='9');
}
bool isOne(char &c) {
  return (isAlph(c)||isNum(c));
}
int main () {
  cin>>a>>b;
  int l = a.length();
  int cnt = 0;
  for(int i=0;i<l;++i) {
    if(isOne(a[i])^(b[i]=='1'))
      continue;
    ++cnt;
  }
  double ans = cnt*100.0/l;
  printf("%.2lf%%\n", ans);
}

5、路灯

V先生有一天工作到很晚，回家的时候要穿过一条长l的笔直的街道，这条街道上有n个路灯。假设这条街起点为0，终点为l，第i个路灯坐标为ai。路灯发光能力以正数d来衡量，其中d表示路灯能够照亮的街道上的点与路灯的最远距离，所有路灯发光能力相同。为了让V先生看清回家的路，路灯必须照亮整条街道，又为了节省电力希望找到最小的d是多少？

输入：两行数据，第一行是两个整数：路灯数目n (1≤n≤1000)，街道长度l (1 ≤l≤109)。第二行有n个整数ai (0 ≤ ai≤ l)，表示路灯坐标，多个路灯可以在同一个点，也可以安放在终点位置。

输出：能够照亮整个街道的最小d，保留两位小数。

                                            
#include <iostream>
#include <string>
#include <iomanip>
#include <algorithm>
#include <functional>
using namespace std;

//主程序
int main() {
    cout << setiosflags(ios::fixed) << setprecision(2);
    int n;
    int l;
    int a[1000];

    while (cin >> n >> l) {
        for (int i = 0; i < n; i++) {
            cin >> a[i];
        }

        sort(a, a + n, greater<int>());
        
        double d = 0;

        for (int i = 0; i < n - 1; i++) {
            d = max(d, (a[i] - a[i + 1]) / 2.0);
        }

        d = max(d, (l - a[0]) / 1.0);
        d = max(d, a[n - 1] / 1.0);

        cout << d << endl;
    }

    return 0;
}

6、翻转数组

给定一个长度为n的整数数组a，元素均不相同，问数组是否存在这样一个片段，只将该片段翻转就可以使整个数组升序排列。其中数组片段[l,r]表示序列a[l], a[l+1], …, a[r]。原始数组为

a[1], a[2], …, a[l-2], a[l-1], a[l], a[l+1], …, a[r-1], a[r], a[r+1], a[r+2], …, a[n-1], a[n]，

将片段[l,r]反序后的数组是

a[1], a[2], …, a[l-2], a[l-1], a[r], a[r-1], …, a[l+1], a[l], a[r+1], a[r+2], …, a[n-1], a[n]。

#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
    int n;
    scanf("%d", &n);
    int arr[n];
    int sortArr[n]; 
        for(int i = 0; i < n; i++){
            scanf("%d", &arr[i]);
            sortArr[i]=arr[i];
        }
        sort(sortArr, sortArr + n);
        int start = 0, end = n - 1;
        while(start < n && arr[start] == sortArr[start])start++;
        while(end >= 0 && arr[end] == sortArr[end])end--;
        bool ok = true;
        while(start < end){
            if(sortArr[start] != arr[end]){
                
                ok = false;
                break;
            }
            start++, end--;
        }
        if(ok)
            printf("yes\n");
        else 
            printf("no\n");
    return 0;
}