函数复习总结之题型总结

知识总结

题型总结

函数是用来实现具体的某种功能的，在编写程序时，与使用一个主函数相比，使用多个功能函数可以使整个程序

更加清晰明了，在查找错误时也可以省去不少时间

下面给出用函数体总结的一些简单题型

1.求两数最大公约数、最小公倍数

分析：给定两数m、n ，则有m*n=最小公倍数*最大公约数

          将函数体放在主函数前可以省去函数的声明步骤

#include<bits/stdc++.h>             //万能头文件
using namespace std;
int m,n;
void gcd(int s)
{
    for(int i=s;i>=1;--i)
    {
        if(m%i==0&&n%i==0)
        {
            cout<<i;break;          //(m*n)/i即为最小公倍数
        }
    }
}
int main()
{
    int a;
    cin>>m>>n;
    a=m>n?n:m;                //先判断m与n的大小关系
    gcd(a);
    return 0;
}

2. 验证哥德巴赫猜想

分析：此程序主要考察对于素数的判断，现在循环中判断i是否为素数，再判断n-i是否为素数，若都为素数则输出

#include<bits/stdc++.h>
using namespace std;
int prime(int m)
{
    int x=2;
    while(x<=floor(sqrt(m))&&m%x!=0)
         ++x;
    if(x>floor(sqrt(m))&&m!=1)
       return 1;
    else
       return 0;
}
int main()
{
    int n;
    cin>>n;
    for(int i=2;i<=n/2;++i)                   //使用n/2可以减少循环的次数，节省时间
        if(prime(i)&&prime(n-i))
           cout<<n<<" "<<"="<<" "<<i<<" "<<"+"<<" "<<n-i<<endl;
    return 0;
}

3. 数字反转

分析：用功能函数实现原数减少位数，新数增加位数的过程

#include<bits/stdc++.h>
using namespace std;
int fan(int m)
{
    int s=0;
    do
    {
        s=s*10+m%10;
        m/=10;
    }
    while(m!=0);
    return s;
}
int main()
{
    int n;
    cin>>n;
    cout<<fan(n);
    return 0;
}

接下来难点来了，递归函数闪亮登场

递归思想在于化大为小，化繁为简，最简单最小的问题不再调用自身递归

递归的关键在于找出递归定义和递归终止条件

递归定义：使问题向边界条件转化的规则，递归定义必须使问题越来越简单

递归终止条件：所描述问题的最简单情况，本身不再使用递归的定义

1. 分解因数

分析：本题需要通过寻找大规模与小规模问题之间的关系得出公式count（i，b/i），

还需找出递归边界i>b/i即可解决该问题

#include <bits/stdc++.h>   
using namespace std;  
int sum;  
void count(int a,int b)  
{  
    for(int i=a;i<b;i++)  
    {  
        if(b%i==0&&i<=b/i)  
        {  
            sum++;  
            count(i,b/i);  
        }  
        if(i>b/i) break;  
    }  
}  
int main()  
{  
    int n;  
    int a;  
  
    cin >> n;  
    while(n)  
    {  
        sum=1;  
        cin>>a;  
        count(2,a);  
        cout<<sum<<endl;  
        n--;  
    }  
    return 0;  
}  

2. 放苹果

分析：解决此题的方法为分类讨论+递归

你可以选择有一个盘子一个苹果都不放，然后盘子数减1或者（不可能两种方案都不选）

每个盘子都放一个苹果，即苹果减去盘子的数量，就一直这样递归下去，就得到了最终的答案。

注意：有0个苹果或1个盘子时，只有一种方案，所以（n==0||m==1）return 1，当n<0或m<1时

因为根本不存在这种情况，所以返回一个0

#include<bits/stdc++.h>
using namespace std;
int solve(int n,int m){//n代表苹果数，m代表盘子数
    if(n==0||m==1)return 1;
    if(n<0|m<1)return 0;//这里很重要，很容易被忘记，我已开始就忘了
    else return solve(n,m-1)+solve(n-m,m);
}
int main()
{
    int cases;
    cin>>cases;//输入测试数据的数目（问题的数量）
    while(cases--){
        int n,m;
        cin>>n>>m;
        cout<<solve(n,m)<<endl;//记得空行
    }
}

3. 算24

主要思路如下：

1.将四个数视为一个集合；

2.从集合中随机取两个数，通过加减乘除计算这两个数的结果，然后再将结果放回集合，这样集合就减少了一个元素；

3.重复2的步骤，直到集合中只剩下一个元素为止；

4.查看最后一个元素是否有是24来得出结果。

#include <bits/stdc++.h>  
using namespace std;  
  
double a[4];  
int c[4];  
int b[4];  
char cal_opt[4] = {'+', '-', '*', '/'};  
bool flag = false;  
bool selected[4];  
bool visited[4];  
  
double cal(double a, double b, char opt) {  
    if (opt == cal_opt[0])  
        return a + b;  
    else if (opt == cal_opt[1])  
        return a - b;  
    else if (opt == cal_opt[2])  
        return a * b;  
    else if (opt == cal_opt[3])  
        return a / b;  
    return 0.0;  
}  
  
void calculate(int count) {  
    double result;  
    if (count == 1) {  
        for (int i = 0; i < 4; ++i) {  
            if (!visited[i]) {  
                result = a[i];  
                break;  
            }  
        }  
        if (fabs(result - 24.0) < 0.000001) {  
            cout << "YES" << endl;  
            flag = true;  
        }  
        return;  
    }  
      
    double left, right;  
    for (int i = 0; i < 3; ++i) {  
        if (visited[i])  
            continue;  
        for (int k = i + 1; k < 4; ++ k) {  
            if (visited[k])  
                continue;  
            left = a[i];  
            right = a[k];  
            for (int j = 0; j < 4; ++j) {  
                if (a[k] == 0 && j == 3) // 除法不能除0  
                    continue;  
                result = cal(a[i], a[k], cal_opt[j]);  
                a[i] = result;  
                visited[k] = 1;  
                calculate(--count);  
                if (flag)  
                    goto here;  
                  
                a[i] = left;  
                a[k] = right;  
                visited[k] = 0;  
                ++count;  
            }  
        }  
    }  
here:  
    return;  
}  
  
int main() {  
    while (true) {  
        bool is_end = true;  
        for (int i = 0; i < 4; ++i) {  
            cin >> b[i];  
            if (b[i] != 0)  
                is_end = false;  
        }  
        if (is_end)  
            break;  
          
        // 生成一个全排列  
        memset(selected, 0, sizeof selected);  
        memset(visited, 0, sizeof visited);  
        flag = false;  
        for (int i = 0; i < 4; ++i) {  
            if (selected[i])  
                continue;  
            selected[i] = 1;  
            a[0] = b[i];  
            for (int j = 0; j < 4; ++j) {  
                if (selected[j])  
                    continue;  
                selected[j] = 1;  
                a[1] = b[j];  
                for (int k = 0; k < 4; ++k) {  
                    if (selected[k])  
                        continue;  
                    selected[k] = 1;  
                    a[2] = b[k];  
                    for (int l = 0; l < 4; ++l) {  
                        if (selected[l])  
                            continue;  
                        selected[l] = 1;  
                        a[3] = b[l];  
                        calculate(4);  
                        if (flag)  
                            goto here;  
                        selected[l] = 0;  
                    }  
                    selected[k] = 0;  
                }  
                selected[j] = 0;  
            }  
            selected[i] = 0;  
        }  
    here:  
        if (!flag)  
            cout << "NO" << endl;  
    }  
    return 0;  
}