17.11.17 递归作业

 习题(15-1) 前缀表达式 (1010）

描述

前缀表达式是一种把运算符前置的算术表达式，例如普通的表达式2 + 3的前缀表示法为+ 2 3。前缀表达式的优点是运算符之间不必有优先级关系，也不必用括号改变运算次序，例如(2 + 3) * 4的前缀表示法为* + 2 3 4。本题求解前缀表达式的值，其中运算符包括+ - * /四个。

关于输入

输入为一行，其中运算符和运算数之间都用空格分隔，运算数是浮点数。

关于输出

输出为一行，表达式的值。  可直接用printf("%f ", v)输出表达式的值v。

例子输入

* + 11.0 12.0 + 24.0 35.0

例子输出

1357.000000
 

提示

可使用atof(str)把字符串转换为一个double类型的浮点数。atof定义在stdlib.h中。  此题可使用函数递归调用的方法求解。

 

#include <iostream>
#include<cstring>
using namespace std;
char str[100][20];        //定义一个字符数组，以空格为界，每行存放一个符号或数
int strcount = 0;        //定义符号和数的总数目
double res;       //定义结果
void input()        //此函数用作输入表达式，存入数组
{
    int  i = 1, j = 0;
    char ch;
    while (cin.get(ch))
    {
        if (ch == ' ')
        {
            i++;
            j = 0;
        }
        else if (ch == '
')
            break;
        else
        {
            str[i][j] = ch;
            j++;
        }
    }
    strcount = i;
}
int calc(int num)          //此函数用以递归计算
{
    double sum,a1,a2;
    if (num == 0)
    {
        res = atof(str[1]);
        return 0;
    }
    if (str[num][0] == '+')
    {
        a1 = atof(str[num + 1]); a2 = atof(str[num + 2]);
        sum = a1 + a2;
        sprintf(str[num], "%.10f", sum);
        for (int i = 3; i <= strcount - num; i++)
            strcpy(str[num + i - 2], str[num + i]);
    }
    else if (str[num][0]=='*')
    {
        a1 = atof(str[num + 1]); a2 = atof(str[num + 2]);
        sum = a1 * a2;
        sprintf(str[num], "%.10f", sum);
        for (int i = 3; i <= strcount - num; i++)
            strcpy(str[num + i - 2], str[num + i]);
    }
    else if (str[num][0] == '/')
    {
        a1 = atof(str[num + 1]); a2 = atof(str[num + 2]);
        sum = a1/ a2;
        sprintf(str[num], "%.10f", sum);
        for (int i = 3; i <= strcount - num; i++)
            strcpy(str[num + i - 2], str[num + i]);
    }
    else if (str[num][0] == '-')
    {
        a1 = atof(str[num + 1]); a2 = atof(str[num + 2]);
        sum = a1 - a2;
        sprintf(str[num], "%.10f", sum);
        for (int i = 3; i <= strcount - num; i++)
            strcpy(str[num + i - 2], str[num + i]);
    }
    calc(num - 1);
}
int main()
{
    input();
    calc(strcount);
    printf("%f
", res);
}

 猴子分苹果

描述

有1堆苹果共 m 个，由 n 只猴子按个数平均分配。每次到达苹果堆放地的猴子只有1只，而且每个猴子都会平均分 1 次苹果。第1个到达的猴子将苹果平均分成 n 等份，但发现多 k ( k < n )个，于是，将多余的k个扔掉，然后拿走其中的1等份。第 2 个猴子同样将剩余的苹果又分成 n 等份，也发现多 k 个，并同样将多余的 k 个扔掉，然后拿走其中1等份。之后的每个猴子都这样（将剩余的苹果又分成 n 等份，也发现多 k 个，并将多余的 k 个扔掉，然后拿走其中1等份）。假设最后的猴子分配后至少可以拿走1个苹果，请根据输入的 n 和 k值，计算最小的 m

关于输入

输入猴子数目n 和扔掉的个数 k，其中 k 小于 n，n 和 k 之间以空格间隔。

关于输出

输出最小苹果数目

例子输入

2 1

例子输出

7

 

#include <iostream>
using namespace std;
int n, k,i=1;           //定义初始值
int monk(int p, int k)       //此函数用以递归求值
{
    int num;
        if (p == 1)      //当猴子只剩一只的时候，最小值为n*i+k
            return n*i + k;
        else
        {
            num = monk(p - 1, k) / (n - 1)*n + k;
            if (monk(p - 1, k) % (n - 1) == 0)  //当这种i取值符合时，正常输出
                return num;
            else        //不符合时，换一个i，继续尝试
            {
                i++;
                return monk(p, k);
            }
        }
}
int main()
{
    cin >> n>>k;
    cout << monk(n, k);
return 0;
}

 二叉树

描述

 由正整数1, 2, 3, ...组成了一棵无限大的二叉树。从某一个结点到根结点（编号是1的结点）都有一条唯一的路径，比如从10到根结点的路径是(10, 5, 2, 1)，从4到根结点的路径是(4, 2, 1)，从根结点1到根结点的路径上只包含一个结点1，因此路径就是(1)。对于两个结点x和y，假设他们到根结点的路径分别是(x₁, x₂, ... ,1)和(y₁, y₂, ... ,1)（这里显然有x = x₁，y = y₁），那么必然存在两个正整数i和j，使得从x_i 和 y_j开始，有x_i = y_j , x_{i + 1} = y_{j + 1}, x_{i + 2} = y_{j + 2},... 现在的问题就是，给定x和y，要求x_i（也就是y_j）。

关于输入

输入只有一行，包括两个正整数x和y，这两个正整数都不大于1000。

关于输出

输出只有一个正整数x_i。

例子输入

10 4

例子输出

2

#include <iostream>
#include<cmath>
using namespace std;
int search(int row,int x)        //此函数用以找出x到1路径的下一步将是哪个数，并直接赋给x
{
    double mul=row;
    return pow(2, mul - 1) + (x - pow(2,mul)) / 2;
}
int check(int x, int y)         //此函数用于判断此时x和y是否相等
{
    int sizex, sizey;
    for (int i = 1;; i++)    //下面两个循环分别求出x，y处于第几行
    {
        double mul = i;
        if (x <= pow(2, mul)-1)
        {
            sizex = i - 1;
            break;
        }
    }
    for (int i = 1;; i++)
    {
        double mul = i;
        if (y <= pow(2,mul)-1)
        {
            sizey = i - 1;
            break;
        }
    }
    if (y > x)    //如果y比x大，对y进行search，然后递归
    {
        y = search(sizey, y);
        check(x, y);
    }
    else if (y == x)
        return x;
    else if(x>y)
    {
        x = search(sizex, x);
        check(x, y);
    }
}
int main()
{
    int x, y;
    cin >> x >> y;
    cout << check(x, y) << endl;
    return 0;
}

红与黑

描述

有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。你站在其中一块黑色的瓷砖上，只能向相邻的四块瓷砖中的黑色瓷砖移动。请写一个程序，计算你总共能够到达多少块黑色的瓷砖。

关于输入

包括多个数据集合。每个数据集合的第一行是两个整数W和H，分别表示x方向和y方向瓷砖的数量。W和H都不超过20。在接下来的H行中，每行包括W个字符。每个字符表示一块瓷砖的颜色，规则如下  ‘.’：黑色的瓷砖  ‘#’：红色的瓷砖  ‘@’：黑色的瓷砖，并且你站在这块瓷砖上。该字符在每个数据集合中仅出现一次  当在一行中读入的是两个零时，表示输入结束。

关于输出

对每个数据集合，分别输出一行，显示你从初始位置出发能到达的瓷砖数(记数时包括初始位置的瓷砖)。

例子输入

6 9
 ....#.
 .....#
 ......
 ......
 ......
 ......
 ......
 #@...#
 .#..#.
 11 9
 .#.........
 .#.#######.
 .#.#.....#.
 .#.#.###.#.
 .#.#..@#.#.
 .#.#####.#.
 .#.......#.
 .#########.
 ...........
 11 6
 ..#..#..#..
 ..#..#..#..
 ..#..#..###
 ..#..#..#@.
 ..#..#..#..
 ..#..#..#..
 7 7
 ..#.#..
 ..#.#..
 ###.###
 ...@...
 ###.###
 ..#.#..
 ..#.#..
 0 0

例子输出

45
 59
 6
 13

#include <iostream>
#include<cmath>
using namespace std;
int col,row,bcount=0;         //定义行列数，计数
char ch[21][21];         //定义石砖分布
void hh(int x, int y)           //此函数用于弄清有几块可以走到的石砖
{
    if (x<1 || x>row || y<1 || y>col || ch[x][y] != '.')
        return;
    else
    {
        ch[x][y] = '#';     //一块黑砖走到以后就把他变成红的防止重复走
        bcount++;
        hh(x+1,y); hh(x-1,y);
        hh(x, y + 1); hh(x, y - 1);
    }
}
int main()
{
    int startcol, startrow;         
    while (1)
    {
        cin >>col >> row;            //进行输入
        if (col == 0)
            return 0;
        for (int i = 1; i <= row; i++)
            for (int j = 1; j <= col; j++)
            {
                cin >> ch[i][j];
                if (ch[i][j] == '@')          //遇到@时把他变成.，记下方位
                {
                    startcol = j; startrow = i;
                    ch[i][j] = '.';
                }
            }
    hh(startrow, startcol);
    cout << bcount << endl;
    bcount = 0;
    }
    
    return 0;
}

放苹果问题

描述

把M个同样的苹果放在N个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法（用K表示）？注意：5，1，1和1，5，1是同一种分发。

关于输入

第一行是测试数据的数目t（0<= t <= 20）,其后的t行均包含两个整数M和N，以空格分开。  1<= M <= 25;  1<= N <= 10;

关于输出

对输入的每组数据M和N，用一行输出相应的K

例子输入

1
 7 3

例子输出

8

提示

采用递归思想解题。

#include <iostream>
#include<cmath>
using namespace std;
int app(int m, int n)          //此函数用以递归求出方案数
{
    if (m == 0 || n == 1)     //最终情况是m=0或者n=1时候的，此时有一种方案符合
        return 1;
    else
    {
        if (m >= n)        //当盘子不比苹果多，有放满和不放满两种情况
            return app(m, n - 1) + app(m - n, n);
        else                //当盘子比苹果多，必须有n-m个盘子是空的，相当于m个苹果放在m个盘子
            return app(m, m);
    }
}
int main()
{
    int co;
    cin >> co;
    for (int i = 1; i <= co; i++)
    {
        int m, n;
        cin >> m >> n;
        cout << app(m, n) << endl;
    }
    return 0;
}

1090 分解因数

描述

给出一个正整数a，要求分解成若干个正整数的乘积，即a = a1 * a2 * a3 * ... * an，并且1 < a1 <= a2 <= a3 <= ... <= an，问这样的分解的种数有多少。注意到a = a也是一种分解。

关于输入

第1行是测试数据的组数n，后面跟着n行输入。每组测试数据占1行，包括一个正整数a (1 < a < 32768)

关于输出

n行，每行输出对应一个输入。输出应是一个正整数，指明满足要求的分解的种数

例子输入

2
 2
 20

例子输出

1
 4

#include <iostream>
#include<cmath>
using namespace std;
int sum = 1;           //定义一个全局变量，是输出结果
void res(int m,int a)           //此函数用于算出，当最小的因数大于等于a时，m的分法有几种
{
    for (int i =a; i <= sqrt(m); i++)    //循环出不同情况，并且因为因数从小到大，i有最大界限
    {
        if (m%i == 0)   //当i是因数的时候，多一种分法，并递归余数
        {
            sum++;
            res(m / i,i);
        }
    }
}
int main()
{
    int n,a;
    cin >> n;
    for(int i=1;i<=n;i++)
    {
        cin >> a;
        res(a,2);        //初始时，最小因数大于等于2
        cout << sum << endl;
        sum = 1;
    }
}