递推与递归—＞（递推）

递推与递归

---

数楼梯

题目描述

楼梯有 NN 阶，上楼可以一步上一阶，也可以一步上二阶。

编一个程序，计算共有多少种不同的走法。

输入格式

一个数字，楼梯数。

输出格式

输出走的方式总数。

输入样例

4

输出样例

5

思路

服了，换专题了都，思路还是还纠缠着 dfs 不放，结果好了，TLE。

怎么回事呢?不考虑时间复杂度和高精度的话，这题实际上可以用dfs的，反正不是走一步就是走两步，dfs子集模板嘛。见代码一（超时未通过）。

换思路吧，找规律发现a[i] = a[i-1] + a[i-2],看来是动态规划了，再看一下范围，5000，又要加个高精（大数相加，专题一讲过），详见代码二。

代码一

#include<iostream>
using namespace std;
int n,x,num;
void dfs(int x){
    if(x==n){
        num++;
        return;
    }
    if(x<n){
        x++;//走一步
        dfs(x);
        x++;//走两步
        dfs(x);
    }
}

int main()
{
    cin >> n;
    dfs(0);
    cout<<num;
    return 0;
}

代码二

#include<iostream>
using namespace std;
int n,a[5050][1000],up;
int main()
{
    cin >> n;
    a[1][1] = 1;
    a[1][0] = 1;
    a[2][1] = 2;
    a[2][0] = 1;
    for(int i=3;i<=n;i++){
        //大数相加
        //a[i][0]代表a[i]的值的长度
        for(int j=1;j<=a[i-1][0];j++){
            int t = a[i-1][j]+a[i-2][j]+up;
            a[i][j] = t%10;
            up = t/10;
        }
        //判断进位
        if (up) a[i][a[i-1][0] + 1] = 1;
        a[i][0] = up ? a[i-1][0] + 1 : a[i-1][0];
    } 
    for(int i=a[n][0];i>0;i--){
        cout<<a[n][i];
    }
    return 0;
}

[NOIP2002 普及组] 过河卒

题目描述

棋盘上 A 点有一个过河卒，需要走到目标 B 点。卒行走的规则：可以向下、或者向右。同时在棋盘上 C 点有一个对方的马，该马所在的点和所有跳跃一步可达的点称为对方马的控制点。因此称之为“马拦过河卒”。

棋盘用坐标表示，A 点 (0,0)、B 点 (n,m)，同样马的位置坐标是需要给出的。

现在要求你计算出卒从 A 点能够到达 B 点的路径的条数，假设马的位置是固定不动的，并不是卒走一步马走一步。

输入格式

一行四个正整数，分别表示 B 点坐标和马的坐标。

输出格式

一个整数，表示所有的路径条数。

输入样例

6 6 3 3

输出样例

6

思路

用二维数组代表棋盘，卒每一步只能向下或向右，因此当前坐标的路径数实际上就是当前坐标上边和左边两个坐标的路径数相加，

即a[x][y] = a[x-1][y] + a[x][y-1]

但是马的坐标，以及马可以走到的坐标，卒不能走，那么这几个坐标的路径数就为0；

代码

#include<iostream>
using namespace std;
// x1,y1代表目标坐标
// x2,y2代表马的坐标
//默认所有坐标路径数都为0
long a[25][25],x1,y1,x2,y2;
int main(){   
    //输入目标坐标以及马的坐标
    cin >> x1 >> y1 >> x2 >> y2;
    //开始坐标的路径数设为1
    a[0][0] = 1;
    //遍历所有坐标
    for(int x = 0; x <= x1; x++){
        for(int y = 0; y <= y1; y++){
            //如果是开始坐标，直接进入下一个坐标
            if(x == y && x == 0) continue;
            //如果是马的坐标也直接进入下一个坐标，因为初始化为0，所以马的坐标路径数依旧为0
            if(x == x2 &&y == y2) continue;
            //如果是马走的到坐标也直接进入下一个坐标，马走日
            if((x == x2 + 2 || x == x2 - 2) && (y == y2 + 1 || y == y2 - 1)) continue;
            if((y == y2 + 2 || y == y2 - 2) && (x == x2 + 1 || x == x2 - 1)) continue;
            //如果当前坐标的上边或左边没有坐标，只需要加上单边坐标的路径数
            if(y - 1 < 0) a[x][y] = a[x-1][y];
            else if(x - 1 < 0) a[x][y] = a[x][y-1];
            //否则左边和上边的坐标的路径书都要加上
            else a[x][y] = a[x][y-1] + a[x-1][y];
        }
    }
    //输出目标坐标的路径数
    cout<<a[x1][y1];
    return 0;
}

[NOIP2003 普及组] 栈

题目描述

宁宁考虑的是这样一个问题：一个操作数序列，1,2,…,n（图示为 1 到 3 的情况），栈 A 的深度大于 n。

现在可以进行两种操作，

1. 将一个数，从操作数序列的头端移到栈的头端（对应数据结构栈的 push 操作）
2. 将一个数，从栈的头端移到输出序列的尾端（对应数据结构栈的 pop 操作）

使用这两种操作，由一个操作数序列就可以得到一系列的输出序列，下图所示为由 1 2 3 生成序列 2 3 1 的过程。

（原始状态如上图所示）

你的程序将对给定的 n，计算并输出由操作数序列 1,2,…,n 经过操作可能得到的输出序列的总数。

输入格式

输入文件只含一个整数 n（1≤n≤18）。

输出格式

输出文件只有一行，即可能输出序列的总数目。

输入样例

3

输出样例

5

思路

用i代表等待出栈的个数，用j表示等待入栈的个数，用a[i][j]表示有多少种情况。

则当j==0时，即等待入栈的个数为0，没有数可以入栈了，那么只有一种情况，出栈，所以，当j==0时，无论i有多少，即无论栈内有多少数，也只有一种情况，就是出栈。所以a[i][0] = 1

当i==0时，即栈内一个数也没有，此时只能进行入栈操作，即a[0][j] = a[1][j-1]，栈内数加1，栈外数减1。

当i>0&&j!=0时，即栈内有数，栈外也有数时，既可以进栈，也可以出栈，即a[i][j] = a[i][j-1] + a[i-1][j]，即当前的情况为进栈的情况和出栈的情况相加。代码已详细注解。

代码

#include<iostream>
using namespace std;
int n,a[20][20];
int main(){   
    cin >> n;
    //i表示栈内
    //j表示未进栈
    //当栈外没有数，即无法压入栈的时候，只有出栈一种情况
    //无论栈内有多少数，都只能出栈
    for(int i = 0; i < 20; i++){
        a[i][0] = 1;
    }
    //从栈外个数为1开始
    for(int j = 1; j <= 20; j++){
        //从栈内个数为0开始
        for(int i = 0; i <= 20; i++){
            //如果栈内没有数的时候，只能进栈
            if(i==0) a[i][j] = a[i+1][j-1];
            //否则既可以进栈也可以出栈
            else if(i>0) a[i][j] = a[i-1][j] + a[i+1][j-1];
        }
    }
    //输出栈内为0，栈外为n的情况，即有n个数的所有情况
    cout<<a[0][n];
    return 0;
}