蓝桥杯算法学习纪实——递归实现排列型枚举

94. 递归实现排列型枚举 - AcWing题库

我的思路：多分支递归，即，递归搜索树。

关键点在于，如何判断每一层递归的分支数，即每层递归要嵌套调用自身多少次。相对于上题组合型的枚举，本题每层递归的分支数从 n 逐层递减至 0 （递归的底）；而递归最重要的就是“形式相同”，如果在递归函数中写死每层递归分支数，那将不再适用此题。

而上题就是固定的两个分支，代码如下：蓝桥杯算法学习纪实——递归实现指数型枚举-CSDN博客

void dfs(int u)//u表示第几个数字
{
    if(u > n)
    {
        for(int i = 1; i <= n; i ++)
        {
            if(state[i] == 1)
                cout<<i<<" ";
        }
    cout<<endl;//到达分支底后，回溯前输出该分支结果
    //每个分支递推的底
    return ;
    }
    //分支1
    state[u] = 2;//第u个数字做选择：不选
    dfs(u+1);//对状态为“不选”数字的下一个数做选择
    //分支2
    state[u] = 1;//第u个数字做另一个选择：选
    dfs(u+1);//对状态为“选”数字的下一个数做选择
    //套用上述步骤，从而产生多分枝结构
}

分形几何学，就是一门以不规则形态为研究对象的几何学。分形最大的特性是具有自相似性，不管是放大或者缩小研究对象，你都会看到局部和整体具有相似的结构。分形几何：寻找隐藏的维度 | 集智百科 - 知乎 (zhihu.com)

而在参考了《数据结构（C语言版）》6.7节“回溯法与树的遍历”中的四皇后问题、7.3节"图的遍历"中的DFS算法后，发现了递归搜索树的共性：

递归函数内部须多次调用自己，才能通过“分形”产生分支结构。

而不同的递归搜索树有不同的控制每层分支数的方式，如：函数内直接写死、利用循环控制每层分支数（四皇后问题、用DFS遍历图）。第二种便可以实现不同层数分支数的可控动态变化，而实现方式关键在于“判断条件”。

而这就解决了一开始的问题关键点：如何判断每一层递归的分支数。

代码如下：

#include<iostream>
using namespace std;
const int N = 10;
int path[N];//保存序列
int state[N];//数字是否被用过
int n;
void dfs(int u)
{
    if(u > n)//数字填完了，输出
    {
        for(int i = 1; i <= n; i++)//输出方案
            cout << path[i] << " ";
        cout << endl;
    }

    for(int i = 1; i <= n; i++)//空位上可以选择的数字为:1 ~ n
    {
        if(!state[i])//如果数字 i 没有被用过
        {
            path[u] = i;//放入空位
            state[i] = 1;//数字被用，修改状态
            dfs(u + 1);//填下一个位
            state[i] = 0;//回溯，取出 i
        }
    }
}

int main()
{

    cin >> n;
    dfs(1);
    return 0;
}

作者：Hasity
链接：https://www.acwing.com/solution/content/44647/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

以下是我的代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 10;//数据范围

int n;          //数据量
int node[N];    //装排列前的数字
int path[N];    //装排列后的数字，表示n个位置，也可理解为路径途径顺序
bool used[N];   //记录每个数字的安放状况，true:已安放；false:未安放；
int cnt;        //当前剩余数字个数
//全局变量自动初始化为0

void dfs(int u) //u表示位置编号;位置选数，数选位置：这里是位置选数
{
    if(u == n + 1)//每次递归前，都要检查：是否到了递归的底，即是否放完
    //if(cnt == 0)   //如果此时已放完，输出分支结果
    {
        //cnt ++;    //恢复
        for(int i = 1; i <= n; i ++)
            cout<<path[i]<<" ";
        cout<<endl;
        //该分支结束，回到上一层进入另一个分支
        //return;//可以不用这里return，后面加个else共用最后的return
    }
    else            //如果此时没有放完，将它们安放
        //u位置选数字，即此位置可放哪些剩余数字——分支数控制——每层自身调用次数
    for(int m = 1; m <= n; m ++)//按顺序把未安放数依次安放，遍历所有数字+判断
    {
        if(!used[m])            //如果第m个数字没放，就放在第u个位置
        {                       //u相当于双重循环中外循环变量，控制排列后位置，m相当于内循环变量，控制排列前位置
            path[u] = node[m];  //将第m个数字放入第u个位置；每个数字与其位序（下标）相同，所以也可直接借用“m”：node[m] == m
            used[m] = true;     //同时更新该数字为“已安放”
            //cnt --;
            //以此位置为起点，对下一个位置安放数字，继续上述操作及下面
            //相当于下一趟外循环
            dfs(u + 1);         
            //当所有数都已被安放后，即可输出该分支的结果，所以递归的底还可以是：“此时已没有数未被安放”
            //可在“放数字”时加上 cnt --;cnt 表示当前剩余数字个数，当cnt == 0时，输出分支结果，返回不再往下递推
            //u+1位置选完后，返回u位置（回溯），u位置换另一个数继续往下递推
            
            //此时还在该层，u位置，进行另一个分支；递归搜索树函数内部至少两个dfs(自身调用)
            //但是进行另一个分支前，需要恢复现场，给另一个分支以正确的信息
            //path[u] = 0;      //这个似乎也可以不用写
            used[m] = false;    //只需要将这个数改回false
            //cnt ++;
            //取出u位置上的数，并将此数标记为“未安放”，供下一个分支判断，取出来的数还可以继续放
            //该位置通过循环选另一个数，直至所有可选项被选完，for结束，该层函数结束，即该位置结束，返回上一层
            //所以递归结束的条件：不只有u == n + 1 或 cnt == 0，还有第二个，“此位置所有可选项已被选完”
            //故可将if中的return;移到函数尾部或去掉，将函数改为 “if-else 结构”
        }
    }
    //return;//if分支过来结束，或else分支过来结束
}

int main()
{
    cin>>n;
    //cnt = n;
    for(int i = 1; i <= n; i ++)
        node[i] = i;//放入要排列的数字
    dfs(1);
    return 0;
}

以下是缩减版：

#include <iostream>

using namespace std;

const int N = 10;//数据范围

int n;          //数据量
int node[N];    //装排列前的数字
int path[N];    //装排列后的数字，表示n个位置，也可理解为路径途径顺序
bool used[N];   //记录每个数字的安放状况，true:已安放；false:未安放；

void dfs(int u) //u表示位置编号;位置选数，数选位置：这里是位置选数
{
    if(u == n + 1)//如果此时已放完，输出分支结果
    {
        for(int i = 1; i <= n; i ++)
            cout<<path[i]<<" ";
        cout<<endl;
    }
    else          //如果此时没有放完，将它们安放
    for(int m = 1; m <= n; m ++)//从小到大把未安放数依次安放，遍历所有数字+判断
    {
        if(!used[m])            //如果第m个数字没放，就放在此u位置
        {
            path[u] = node[m];  //第m个数字放入u位置
            used[m] = true;     //同时标记该数字为“已安放”
            dfs(u + 1);         
            //path[u] = 0;      //也可不写
            used[m] = false;    //只需将标记改回false
        }
    }
//return;//上面两个分支结束自动结束函数
}

int main()
{
    cin>>n;
    for(int i = 1; i <= n; i ++)
        node[i] = i;//放入要排列的数字
    dfs(1);
    return 0;
}

问题1：u的作用是什么？

我的理解是：结点序号。此题可以转化为，n个结点有多少种途径顺序，这就是图的知识了；这也是一个全排列问题。

问题2：u相当于双重循环中外循环变量，控制排列后位置，m相当于内循环变量，控制排列前位置，能否用双重循环实现本题目？

以下是我的尝试，现在还并不能完成，牵扯到goto语句。发现递归算法最大的优点就是“能够回到上一层”，即“回溯”。

#include <iostream>
using namespace std;

const int N = 10;//数据范围

int n;          //数据量
int node[N];    //装排列前的数字
int path[N];    //装排列后的数字，表示n个位置，也可理解为路径途径顺序
bool used[N];   //记录每个数字的安放状况，true:已安放；false:未安放；
int cnt;        //当前剩余数字个数
//全局变量自动初始化为0

void Permutations(int node[])
{
	int u,before;
	for(u = 1; u <=n ; u ++){
		if(u>n){//放完就输出
			for(int i = 1; i <= n; i ++)
				cout<<path[i]<<" ";
			cout<<endl;
			u --;
			used[before] = false;
			goto 
		}
		else	//没放完继续放
			for(before = 1; before <= n; before ++){
			if(!used[before])				//没用过中的最小的的继续放
			{                       
				path[u] = node[before];		//排列前位置放入排列后位置
				used[before] = true;  		//标记此数字为已安放
				u ++;					//移动到下一个位置
			}
		}
	}
}

int main()
{
	cin>>n;
	//cnt = n;
	for(int i = 1; i <= n; i ++)
		node[i] = i;//放入要排列的数字
	Permutations(node);
	return 0;
}

回溯法：递归的特性就是能够回溯。

发现3：递归的结束条件有两个，整个递归函数是一个二分支结构：要么if后return，要么调用自己；参考数据结构教材可以发现统一的结构都是——if-else结构，最后共用的return可写可不写。

所以，多分枝递归的共性：有两个出口。

        一个是递推到底后结束函数（if分支）、一个是每层递归（即每个结点）的分支都完成后结束函数；而每个结点的每个分支要完成，最终都需要递推到底才能完成，即还是要通过if结束。所以这个if的结束条件对于一个递归函数来说，就是它的结束条件，非常关键，否则递归函数将永远递推下去永不回归直至内存被用完，即递归的底，很重要。
        但是，本题却有点特殊，if如果不写，直接写一个循环调用递归，递归函数也能结束。
因为每次循环判断所有数是否已被使用，发现所有数都被使用就会结束循环，从而结束递归，返回上一层。
        但是如果要输出结果，且不重复输出数据，就要在循环中加入输出条件和输出操作且提前break循环。代码如下，已通过acwing平台oj测试。

while版：

#include <iostream>
using namespace std;
const int N = 10;//数据范围

int n;          //数据量
int node[N];    //装排列前的数字
int path[N];    //装排列后的数字，表示n个位置，也可理解为路径途径顺序
bool used[N];   //记录每个数字的安放状况，true:已安放；false:未安放；

void dfs(int u) //u表示位置编号;位置选数，数选位置：这里是位置选数
{
    int m = 1; 
    while(m <= n)
    {
        if(u == n + 1){         //放完则输出并结束循环
            for(int i = 1; i <= n; i ++)
                cout<<path[i]<<" ";
            cout<<endl;
            break;//如果不加此条，将会重复输出n次
                  //至于为什么回溯后u一直==n+1，导致重复输出，这个还不清楚
        }
        if(!used[m])            //如果第m个数字没放，就放在此u位置
        {
            path[u] = node[m];  //第m个数字放入u位置
            used[m] = true;     //同时标记该数字为“已安放”
            dfs(u + 1);         
            //path[u] = 0;      //也可不写
            used[m] = false;    //只需将标记改回false
        }
        m ++;                   //从小到大把未安放数依次安放，遍历所有数字+判断
    }
}
int main()
{
    cin>>n;
    for(int i = 1; i <= n; i ++)
        node[i] = i;//放入要排列的数字
    dfs(1);
    return 0;
}

for版：

#include <iostream>
using namespace std;
const int N = 10;//数据范围

int n;          //数据量
int node[N];    //装排列前的数字
int path[N];    //装排列后的数字，表示n个位置，也可理解为路径途径顺序
bool used[N];   //记录每个数字的安放状况，true:已安放；false:未安放；

void dfs(int u) //u表示位置编号;位置选数，数选位置：这里是位置选数
{

    for(int m = 1; m <= n; m ++)//从小到大把未安放过的数依次安放，遍历所有数字+判断
    {
        //u放完则输出并结束循环
        if(u == n + 1){         
            for(int i = 1; i <= n; i ++)
                cout<<path[i]<<" ";
            cout<<endl;
            break;
        }
        //u没放完则继续放下一个u位置
        if(!used[m])            //第m个数字没放，就放在此u位置
        {
            path[u] = node[m];  //第m个数字放入u位置
            used[m] = true;     //标记该数字为“已安放”
            dfs(u + 1);         
            //path[u] = 0;      //也可不写
            used[m] = false;    //将该数字改回false
        }
    }
}
int main()
{
    cin>>n;
    for(int i = 1; i <= n; i ++)
        node[i] = i;//放入要排列的数字
    dfs(1);
    return 0;
}

总结：
        递归最大的好处就是可以回溯；
        多分枝搜索树利用回溯法遍历，正是利用了递归的“回溯特性”，使得各分支都能得到不重不漏的遍历；
        而递归有几个关键点：1、顺序；2、底；3、相同的操作。

未完待续……