递归讲解

递归——调用“自己”的函数

1. 调用“自己”是新开一个函数，而不是真的调用 “自己”.

2. 可以看作每一个函数都是“不同”的，即要么输入的参数不同，要么全局变量有变化.

3. 明白一个函数的作用并相信它能完成这个任务，千万不要跳进这个函数里面企图探究更多细节， 否则就会陷入无穷的细节无法自拔

int func(传入数值) {
  if (终止条件) return 最小子问题解;
  return func(缩小规模);
}

递归——递与归

递归与递推的区别：递推只有归，递归先有一步递.

考虑一道题：

$\mathrm{f[x] = f[x - 1] + x},x \geqslant 1$ .

$\mathrm{f[x] = 1}, x = 1$ .

递推：

void calc() {
    f[1] = 1; 
    for(int i = 2; i <= n ; ++ i) 
        f[i] = f[i - 1] + i;   
}

递归：

int f(int x) {
    if(x == 1) return x; 
    else return x + f(x - 1);   
} 

考虑二者不同：

递推由边界出发，逆向从终点走到起点.

递归由起点出发，走到终点，并从终点逆向退回起点.

递归 = 递（找终点）+ 归（从终点递推回起点）

源自详解递归思想_dreamispossible的博客-CSDN博客_递归思想

递归函数的书写

递归的定义可能会有点绕，但是递归函数的书写确是不难的.

为了便于理解，这里举几个简单递归函数.

设递归函数 $\mathrm{f(sta)}$ 表示运算规则为函数 $\mathrm{f}$ , 传入参数为 $\mathrm{sta}$ .

$\mathrm{f}$ 函数不涉及全局变量，传入的是数值参数（不改变传入的变量）时，这样的递归是易于理解的.

在书写函数 $\mathrm{f}$ 时，只需考虑这几个事情：

1. $\mathrm{f}$ 的功能

2. $\mathrm{f(x)}$ 可以由哪些 $\mathrm{f(y)}$ 转移得来.

3. 边界

正确性可以类比数学归纳法：

1. 边界条件正确.

2. $\mathrm{f(y)}$ 正确.

3. $\mathrm{f}$ 本身书写正确.（即转移状态正确）

由这三个条件可以归纳推得 $\mathrm{f(x)}$ 正确.

例题：

1. 斐波那契数列：

$\mathrm{f(x)=1, x \leqslant 2}$ .

$\mathrm{f(x)=f(x-1)+f(x-2)}$ .

思考步骤：

1. $\mathrm{f(x)}$ 干什么？

——计算斐波那契数列第 $\mathrm{x}$ 项的值.

2. 转移？

—— $\mathrm{f(x)=f(x-1)+f(x-2), x \geqslant 3}$ .

3. 边界条件？

—— $\mathrm{f(x)=1}, x \leqslant 2$ .

代码：

int f(int x) {
    if(x <= 2) {
        return 1;
    }
    else {
        return f(x - 1) + (x - 2); 
    }
}

2. 计算 $\mathrm{n!}$ .

1. $\mathrm{f}$ 要实现什么功能？

——计算 $\mathrm{n!}$ .

2. $\mathrm{f}$ 的转移是什么？

—— $\mathrm{f(n)=f(n-1) \times n}$ .

3. $\mathrm{f}$ 的边界是什么？

—— $\mathrm{f(1)=1}$ .

int f(int n) {
    if(n == 1) return 1; 
    else return n * f(n - 1);   
}

为什么要用递归？

上文也提到过递归 = 递 + 归，即如果知道函数的转移方向则和递推是等价的.

但是在很多情况，我们并不能很清楚的得知函数的递推方向.

在计算斐波那契函数和阶乘函数时，递推方向是下标由小到大.

但是在 $\mathrm{DAG}$ , 树上进行逆向递推时递推的顺序就是有讲究的（至少并不那么显然）

这个时候递归来做就显得更加无脑，更加方便.

例

1. 求解两个数字的最大公约数.

有公式：

$\mathrm{if}$ $\mathrm{y=0}$ $\mathrm{gcd(x, y) = x}$

$\mathrm{else}$ $\mathrm{gcd(x,y) = gcd(y, x \ mod y)}$ .

int gcd(int x, int y) {
    return y ? gcd(y, x % y) : x;  
}

2. 给定一棵有根树，求点 $\mathrm{i}$ 的子树大小 $\mathrm{size[i]}$ .

树： $\mathrm{n}$ 个点， $\mathrm{n-1}$ 条边的无向图（无环）

对于有根树，我们可以将每个点的儿子（直接与 $\mathrm{x}$ 相邻的点且并不是 $\mathrm{x}$ 的父亲）存储起来.

子树的概念：

(图片源自 OI - wiki)

递推做法：

对于一个点 $\mathrm{x}$ , 若 $\mathrm{x}$ 能使 $\mathrm{y}$ 的子树大小 +1，则 $\mathrm{y}$ 必为 $\mathrm{x}$ 的祖先.

裸做的话要暴力跳祖先一个一个贡献.

递归做法：

考虑定义递归函数 $\mathrm{f(x)}$ 表示 $\mathrm{x}$ 点的子树大小.

显然有 $\mathrm{f(x)=1 + \sum_{v \in son[x]} f(v)}$ .

int dfs(int x) {
    int cur = 1; 
    for(int i = 0; i < G[x].size() ; ++ i) {
        cur += dfs(G[x][i]); 
    }
    return cur; 
}

3. 全排列问题

给定 $\mathrm{n}$ , 输出 $\mathrm{n}$ 的所有排列.

按照递归三部曲，定义函数 $\mathrm{dfs(now, a)}$ :

输出”给定 $[1, now]$ 中的数字情况下“的排列，即 $1$ ~ $\mathrm{now-1}$ 中的数字都确定好的情况下输出剩下的排列.

那么，我们枚举 $\mathrm{now}$ 位置上该填什么：即 $\mathrm{now-1}$ 及之前没有加入过的数字就是要加入的.

void dfs(int cur, vector<int>g) {
    if(cur == n + 1) {
        for(int i = 0; i < n ; ++ i) {
            printf("    %d", g[i]);  
        }
        printf("\n"); 
        return ; 
    }
    for(int i = 1; i <= n ; ++ i) {
        int flag = 0; 
        for(int j = 0; j < g.size() ; ++ j) {
            if(g[j] == i) { flag = 1; break; } 
        }
        if(!flag) {
            g.pb(i);   
            dfs(cur + 1, g);   
            g.pop_back();   
        }
    }
}

但是，我们每次都要在函数里有一个 $\mathrm{a}$ , 在空间上就显得很不方便，不妨用全局变量来代替.

那么，在这个时候我们就要改变一下函数的定义方式：

即令 $dfs(now)$ 表示：

当前已添加完 $\mathrm{now-1}$ 及之前的数字，且填入数字数组为 $\mathrm{a}$ ，状态为 $\mathrm{vis}$ .

且：执行完本函数之后 $\mathrm{a}$ 与 $\mathrm{vis}$ 的状态不改变.

如果后面觉得懵的话反复朗读这两句话.

那么函数调用就好写了：

#include <bits/stdc++.h>
#define ll long long 
#define pb push_back 
using namespace std;  
int n , a[20], vis[20]; 
void dfs(int now) {
    if(now > n) {
        for(int i = 1; i <= n ; ++ i) {
            printf("    %d", a[i]); 
        }
        printf("\n"); 
        return ; 
    }
    for(int i = 1; i <= n ; ++ i) {
        if(!vis[i]) {
            vis[i] = 1;
            a[now] = i;     
            dfs(now + 1); 
            vis[i] = 0; 
            a[now] = 0; 
        }
    }   
}
int main() {
    scanf("%d", &n); 
    dfs(1);  
    return 0; 
}

既然我们已经学会了递归，就利用递归做题吧！

1. Painting Fence

来源：codeforces round 256 (Div 2)

有 $\mathrm{n}$ 块连着的木板，每个木板高度为 $\mathrm{h[i]}$ ，我们需要把 $\mathrm{n}$ 个木板涂上颜色.

每次涂色可以有两种选择：

1. 竖着涂完一块木板（若之前这个木板有涂过，则可以继续涂完）

2. 横着刷一个高度单位的连续的木板（中间不能空着，不能间断）

问：最少需要刷多少次，使得所有木板都涂上颜色？

数据范围： $n \leqslant 5000, a_{i} \leqslant 10^9$ .

#include <stdio.h>  
#define N  5009 
#define setIO(s) freopen(s".in","r",stdin)
int min(int x, int y) { return x < y ? x : y; }
int a[N], n;  
int solve(int l, int r, int cur) {
    if(l == r) {
        return 1;   
    }
    int mi = a[l];    
    for(int i = l; i <= r; ++ i) {
        mi = min(mi, a[i]);  
    }  
    int an = mi - cur, i, j;    
    for(i = l; i <= r; ) {
        if(a[i] == mi)  {
            ++ i; 
            continue;  
        }
        else {
            for(j = i; j + 1 <= r && a[j + 1] > mi; ++ j);   
            an += solve(i, j, mi);     
            i = j + 1;   
        }
    }
    return min(an, r - l + 1);   
}
int main() {
    //  setIO("input"); 
    scanf("%d",&n); 
    for(int i = 1; i <= n ; ++ i) {
        scanf("%d", &a[i]);   
    }                   
    printf("%d", solve(1, n, 0)); 
    return 0; 
}

解：直接做肯定不太好做，因为问题十分复杂，不妨考虑递归。

按照递归三部曲：

1. $\mathrm{solve(l, r, cur)}$ :当前 $\mathrm{[l,r]}$ 区间已经涂上 $\mathrm{cur}$ 高度的, 还需要最少多少次可以将这个区间的墙涂完.

2. 转移：若已经涂过的高度小于这段区间的最小值，则肯定可以横着给这个区间都涂上，缩小问题规模.

3. 边界： $\mathrm{l=r}$ 时直接返回 1.

#include <stdio.h>  
#define N  5009 
#define setIO(s) freopen(s".in","r",stdin)
int min(int x, int y) { return x < y ? x : y; }
int a[N], n;  
int solve(int l, int r, int cur) {
    if(l == r) {
        return 1;   
    }
    int mi = a[l];    
    for(int i = l; i <= r; ++ i) {
        mi = min(mi, a[i]);  
    }  
    int an = mi - cur, i, j;    
    for(i = l; i <= r; ) {
        if(a[i] == mi)  {
            ++ i; 
            continue;  
        }
        else {
            for(j = i; j + 1 <= r && a[j + 1] > mi; ++ j);   
            an += solve(i, j, mi);     
            i = j + 1;   
        }
    }
    return min(an, r - l + 1);   
}
int main() {
    //  setIO("input"); 
    scanf("%d",&n); 
    for(int i = 1; i <= n ; ++ i) {
        scanf("%d", &a[i]);   
    }                   
    printf("%d", solve(1, n, 0)); 
    return 0; 
}

2. Chloe and the sequence　

来源：codeforces 743B

给定两个数 $n$ , $k$ （ $n \leqslant 50$ ， $k \leqslant 2^n-1$ )
再生成一个长度为 $2^n-1$ 的数列；
这个数列是这样的：
首先在正中间填上 $n$ .
接着在 $n$ 的两边的正中间填上 $n-1$ .
再在两个 $n-1$ 的两边填上 $n-2$ ………………
当 $n=4$ 时，这个数列是这样的：
$1,2,1,3,1,2,1,4,1,2,1,3,1,2,1$
问：第 $k$ 位数字是什么？

定义递归函数 $\mathrm{f(n, k)}$ 表示中间数字为 $\mathrm{n}$ 时第 $\mathrm{k}$ 位是多少.

1. $\mathrm{k}$ 就是中间位置，则输出

2. $\mathrm{k}$ 是中间位置左面，则递归左面.

3. $\mathrm{k}$ 是中间位置右面，则递归右面.

#include <bits/stdc++.h> 
#define ll long long 
using namespace std; 
int solve(int n, ll k) {
    ll len = (1ll << n) - 1;   
    if(k == len / 2 + 1) return n;  
    if(k < len / 2 + 1) return solve(n - 1, k); 
    if(k > len / 2 + 1)  return solve(n - 1, k - (len / 2 + 1)); 
}
int main() {
    int n ; 
    ll K; 
    scanf("%d%lld", &n, &K); 
    printf("%d\n", solve(n, K)); 
    return 0; 
}

3. How many integers can you find ?

来源：HDU1796

给定 $\mathrm{n}$ , 一个大小为 $10$ 的正整数集合 $\mathrm{M}$ .

问 $\mathrm{[1,n]}$ 中有多少个数字 $\mathrm{x}$ 满足 $\mathrm{M}$ 中存在 $\mathrm{x}$ 的因数.

#include <cstdio>
#define ll long long 
using namespace std;
ll a[20], n,ans;
int m, cnt;
ll gcd(ll a,ll b){
    return b==0 ? a : gcd(b,a % b);
}
void dfs(int cur,ll lcm,int id){
    if(cur > cnt) return;
    lcm = a[cur] / gcd(a[cur], lcm) * lcm;
    if(id) ans += (n - 1) / lcm;
    else ans -= (n - 1) / lcm;
    for(int i = cur + 1; i <= cnt ; ++ i)
        dfs(i, lcm, !id);
}
int main(){
    while(scanf("%lld%d",&n,&m) != EOF)
    {
        ans = cnt = 0;
        for(int i = 1; i <= m ; ++ i){
            ll k;
            scanf("%lld",&k);
            if(k) a[ ++cnt] = k;
        }
        for(int i = 1; i <= cnt ; ++ i)
            dfs(i, a[i], 1);
        printf("%lld\n",ans);
    }
    return 0;
}

根据容斥原理，答案 $=$ 被一个数整除 - 被 2 个数整除 + 被 3 个数整除......

即我们要找到 $\mathrm{M}$ 的所有子集，然后判断这个子集应该加上还是减去.

这个用递归可以方便地进行求解.

4. 平面最近点对

给定平面上 $n$ 个点，问距离最近的点对的距离是多少？

用分治法可以做到在 $O(n \log n)$ 的时间复杂度内求解.

先把所有点按照 $x$ 坐标排序， $x$ 坐标相同则按照 $y$ 来排序.

每次取中间点 $\mathrm{mid}$ , 递归求解 $\mathrm{[l,mid]}$ 与 $\mathrm{[mid+1,r]}$ .

考虑如何合并：即一个点在左侧，一个点在右侧.

求解完左侧后自动按照纵坐标排序，右侧同理.

那么这里就有一个结论：对于左侧一个点，所需要枚举到的右侧点的个数不大于 $8$ .

记忆化搜索

讲完这么多递归，不讲记忆化搜索就可惜了，这里介绍一下：

考虑最开始讲得计算斐波那契数列的递归函数：

int f(int x) {
    return x <= 2 ? 1: f(x - 1) + f(x - 2);       
}

仔细分析一下这个函数，假如说现在要求 $f(5)$ .

$f(5)=f(4)+f(3)$

$f(4)=f(3)+f(2)$

$f(3)=f(2)+f(1)$

在短短的调用关系中，不难发现 $f(3)$ 就要计算两次.

在递推中，每一个 $f(i)$ 只会计算一次，所以时间复杂度是线性的.

而在这个简陋的递归中，每一个 $f(i)$ 会被重复计算，这个计算量就不是线性了.

所以这里引入记忆化搜索的概念，即计算过的值就被保留在数组中，下次调用就直接拿来用.

#include <bits/stdc++.h> 
using namespace std;
int f[40];   
int dfs(int x) {
    if(f[x]) return f[x]; 
    if(x <= 2) return f[x] = 1; 
    else return f[x] = dfs(x - 1) + dfs(x - 2); 
} 

posted @ 2021-11-29 03:56 guangheli 阅读(440) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

公告

昵称： guangheli
园龄： 3年7个月
粉丝： 2
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

guangheli

递归讲解

递归——调用“自己”的函数

递归——递与归

递归函数的书写

例题：

1. 斐波那契数列：

2. 计算 $\mathrm{n!}$ .

为什么要用递归？

例

1. 求解两个数字的最大公约数.

2. 给定一棵有根树，求点 $\mathrm{i}$ 的子树大小 $\mathrm{size[i]}$ .

3. 全排列问题

既然我们已经学会了递归，就利用递归做题吧！

1. Painting Fence

2. Chloe and the sequence

3. How many integers can you find ?

4. 平面最近点对

记忆化搜索

公告

搜索

常用链接

我的标签

随笔档案

阅读排行榜

推荐排行榜

guangheli

递归讲解

递归——调用“自己”的函数

递归——递与归

递归函数的书写

例题：

1. 斐波那契数列：

2. 计算 n!n!\mathrm{n!}.

为什么要用递归？

例

1. 求解两个数字的最大公约数.

2. 给定一棵有根树，求点 ii\mathrm{i} 的子树大小 size[i]size[i]\mathrm{size[i]}.

3. 全排列问题

既然我们已经学会了递归，就利用递归做题吧！

1. Painting Fence

2. Chloe and the sequence

3. How many integers can you find ?

4. 平面最近点对

记忆化搜索

公告

搜索

常用链接

我的标签

随笔档案

阅读排行榜

推荐排行榜

2. 计算 $\mathrm{n!}$ .

2. 给定一棵有根树，求点 $\mathrm{i}$ 的子树大小 $\mathrm{size[i]}$ .

2. Chloe and the sequence　