算法——递归与递推[蓝桥杯]

递归与递推

递归就是自己调用自己。

printf和scanf的速度比cin和cout要快

如果输入输出的规模小于10的5次方，速度没有太大区别，如果大于10的5次方，最好是用printf和scanf(相差大概一倍)

参数有两个位置，全局参数和形参。

斐波那契数列

#include//有cin和cout
#include//有memset
#include//有scanf和printf
using namespace std;

int f(int n)//每个递归都会实现一棵递归搜索树，然后树的子结点都是边界（n==1或n==2）
{
    if(n==1) return 0;
    if(n==2) return 1;
    else
    {
        return f(n-1)+f(n-2);
    }
}

int main()
{
    int n;
    cin>>n;//输入：5
    int i = 0 ;
    for(i = 1;i <= n-1 ;i++)
    {
         cout <<f(i)<<" ";
    }
    cout<<f(i);//输出：0 1 1 2 3
    return 0;
}

使用递推的方法：

递归是将一个问题分解成一系列同种子问题；递推正好相反，是通过解决子问题然后推算原问题。

int main()
{
	int n;
	cin >> n;
	int arr[20];
	arr[1] = 0;
	arr[2] = 1;
	for (int i = 3; i <= n; i++)
	{
		arr[i] = arr[i - 1] + arr[i - 2];
	}

	for (int i = 1; i <= n; i++)
	{
		cout << arr[i] << " ";
	}
	return  0;
}

这个可以进行优化，从空间的角度进行优化

原先使用的是保存的数组，经过优化以后可以只保存两个数。

int main()
{
	int n;
	cin >> n;
	int a = 0;
	int b = 1;
	for (int i = 1; i <= n; i++)
	{
		cout << a << " ";//每次只打印一个数，a。
		int fn = a + b;
		a = b;
		b = fn;
	}
	return  0;
}
//只需要存储a，b两个变量。

常用的2的次方表：

2的63次方 = 10的18次方

2的20次方 = 10的6次方

2的16次方 = 65536

2的15次方 = 32768

使用递归需要

1，创建递归搜索树

2，定义边界，因为最后的值都是要回归到边界上来的。

递归实现(指数型)枚举

首先复习数据范围，n是小于15的，符合n<=30的条件，所以可以使用n*n！的dfs（递归）

输出样例：

3
2
2 3
1
1 3
1 2
1 2 3

分析这个题：

如果n = 3，那么将会从3个中选取任意数量的个数来进行输出，如果要保证最终的输出不会有情况忽略，那么就需要保证顺序（从第一位开始分情况讨论，然后以此类推第二位，第三位）边界就是第三位填完了，这里如果到达边界可以不用返回，只需要输出就可以，所以在’return；‘之前输出一下即可。

因为需要判断以及控制这三位，所以需要将这三位调成可以控制的形式：数组。

代码实现

#include
#include
#include

using namespace std;


const int N = 16;//设置最大的数组长度，可以不用到这么大的范围，但是必须有。
int n;
int st[N];//数组状态（对应数的状态）：0表示还没有考虑，1表示选他，2表示不选他

void dfs(int u)
{
    //首先先确定边界情况
    if(u>n)//如果传进来的要控制的位u是大于n的，那么就是边界外了，进应该进行输出了。
    {
        for(int i = 0;i<=n;i++)//将n位上的标志是1的全部输出
        {
            if(st[i]==1)
            {
                printf("%d ",i);
            }
        }
        printf("\n");
        return ;
    }
    //然后就处理分支——处于递归搜索树的某个结点上，这个时候有两种情况要选择：选它或者不选它不选它
    st[u] = 2;//直接将它的状态改成：不选
    dfs(u+1);//然后处理它（不选）的情况（分支1）即可，调用递归
    st[u] = 0;//最后恢复现场
    
    st[u] = 1;//选
    dfs(u+1);//处理它（选）的情况（分支2），调用递归
    st[u] = 0;//最后恢复现场
}
int main()
{
    cin>>n;
    dfs(1);//下标从1开始
    return 0;
}

注意：如果在分情况讨论的时候对父结点进行赋值/改变，那么必须要进行恢复（不能因为分子情况而影响了自己）。

再写一遍：

#include
using namespace std;
#include
#include

int st[16];
int n = 0;//需要创建全局变量，因为n在外面的函数中需要用到

void dfs(int u)//必须是最后一个（第三位）确定了以后再打印
{
	if (u > n)
	{
		for (int i = 1; i <= n; i++)
		{
			if (st[i] == 1)
			{
				printf("%d ", i);
			}
		}
		printf("\n");
		return;//不要忘了一种情况（方式）打印完需要return回来。
	}
	st[u] = 2;
	dfs(u + 1);
	st[u] = 0;

	st[u] = 1;
	dfs(u + 1);
	st[u] = 0;
}

int main()
{
	cin >> n;
	dfs(1);
	return 0;
}

界限是需要考虑的，这里虽然是有界限的，而且在一开始构思代码的时候就应该想到界限是怎么触到的。

上面的方法是将方案直接输出，如果想把所有的方案都记录下来，然后再统一输出，那么就需要使用二维数组。（如果要先记录下来的话，那么肯定是等到所有的位上都有确切的值了以后，一齐放进数组中，这算一种方式，最多有2的n次方种方式。但是在设计数组的时候需要按照最多情况来设计。）

#include
using namespace std;
#include
#include

int n = 0;
int num = 1;//方式的序号
int st[16];
int arr[1 << 15][16];

void dfs(int u) 
{
	if (u > n)
	{
		for (int i = 1; i <= n; i++)//在边界处记录方案到二维数组中
		{ 
			if (st[i] == 1)
			{
				arr[num][i] = i;
			}
		}
		num++;
		return;
	}
	st[u] = 1;
	dfs(u + 1);
	st[u] = 0;

	st[u] = 2;
	dfs(u + 1);
	st[u] = 0;
}

int main()
{
	cin >> n;
	dfs(1);
	for (int i = 1; i <=num; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			if(arr[i][j]!=0)
			printf("%d ", arr[i][j]);
		}
		if(i!=num)
		printf("\n");
		//puts("");//输出一个字符串加回车，字符串为空的时候相当于回车。
	}

	return 0;
}

最后不知道怎么回事，多回车了一行，消除了这一行就正确了。（注意，如果我没有进行特殊判断的话，那么打印出来的方案都是三位的，即使没有，那么最终答案也是0，所以我使用了特殊判断，只要是0就不输出，也可以使用vector，但是我不会用）

上面的数组中的数如果不是1 的话就不需要打印了，所以直接判断是不是1即可，如果需要全排列的话，每个数都是需要涉及的，所以需要判断每个数，也就是说要将1-n分别判断一遍，即对数字进行判断，而不是对数组的值进行判断（需要一个used数组来判断这个数有没有被用过）。下面的arr数组中的值也不再是1，2，3这样的状态，而是10个不同的数的状态，0表示还没有数，1-9表示有数了。

递归实现(排列型)枚举

看到数据范围，n<=9,满足n<=30,所以可以考虑dfs递归。（n*n！）

这个题的意思就是输出n 的全排列。

字典序：

有两个序列a，b进行比较大小，如果a1 = b1，那么就继续向后进行比较，直到ai！=bi。如果到最后都相等，那么两个序列相同，如果ai存在而bi不存在，那么说明bi小于ai。（出题人比较懒，他没有将每种符合题意的情况都考虑到并加上，所以方案唯一）（只要按照正常规律去写，就不用在意这个字典序,因为正常来说都是先枚举1，然后依次向后。搜索递归树中，左边的分支肯定是比右边的分支大的）

一般全排列有两种枚举方式

第一种是依次枚举每个数放到哪一个位置。（先放1，再放2，依次放最后一个）

第二种是依次枚举每个位置放哪一个数。（第一个位置放3，第二个位置放2，以此类推）

每个数只能用一次，所以需要判断一下每个数值只用一次。（所以需要判断当前这个位置可以用的数有哪些）需要存一个新的状态，用来表示每个数是不是被用过。

按照第二种方法来实现代码

#include
using namespace std;
#include
#include


int st[10];//0表示还没有放数，1-n表示放了数了。
int n;
bool used[10];//用来判断数是否被用过,true表示用过了。

void dfs(int u)
{
	if (u > n)
	{
		for (int i = 1; i <= n; i++)//打印方案
		{
			printf("%d ", st[i]);
		}
		puts("");
		return;
	}
	//枚举每个分支，即当前的位置可以填那些数。
	for (int i = 1; i <= n; i++)//目标是一个位置，而讨论的是放那个数进去。
	{
		if (!used[i])//如果这个数没有用过
		{
			st[u] = i;
			used[i] = true;
			dfs(u + 1);
			//恢复现场
			st[u] = 0;
			used[i] = false;
		}
	}

}
int main()
{
	cin >> n;
	dfs(1);

	return 0;
}

分析这个全排列算法的时间复杂度：

这个算法会递归n层

第一层是n，（，就一个for循环，所有的数都可以选）

第二层是n*n，（有n个分支，每个分支中都有一个for循环）

第三层是n*（n-1） *n，（有n * (n-1)个分支，每个分支中都有一个for循环）

等到了叶子结点，就会有n！个分支，然后每个分支中有个for循环（输出的时候需要将n个位置上的数遍历一遍），所以，最后的时间复杂度就是n*n！

总共的时间复杂度是n*（1 + n + n * （n-1）+ n* （n-1）（n-2）…+n！）

经过放缩就是n*n！。

递归实现(组合型)枚举

组合型与排列型的区别：

排列型是注重的顺序的，比如132和123就是不同的两个方案。

组合型是不注重顺序的，比如132和123是相同的两个方案。

这里要求组合型枚举，那么就需要解决132，123，321等重复的问题，要求只能存在一个。

解决方法：人工规定一个枚举顺序，比如要求只有123这样按照从小到大这样的枚举顺序排列才是正确的，才会被打印。在递归的时候加一个限制，保证从小到大的顺序（局部属性，只需要保证新加的数是大于前一个数的）。

然后根据递归搜索树来写代码：

首先确定参数：

1，三个空位的状态时需要的，开一个长度为n的数组来记录。

2，当前在枚举中的哪个位置，传一个变量就可以了。（u）

3，后面位置的取值范围，要保证升序（需要传一个最小数start作为开始，也就是前一个数）

ps：发现这个组合型枚举的结果是可以用指数型枚举中的代码实现的，只需要挑出符合长度的数值。

代码实现：

#include
#include
using namespace std;

const int N = 30;
int n, m;
int way[N];//每个位置的状态，（数）。0表示空，如果用完了就需要把它恢复成空。

void dfs(int u,int start)//当前位置和开始位置
{
    //先想一下边界
	if (u > m)//u=1的时候一个数也没有选，u=2的时候就相当于选了1个数了。
	{
		for (int i = 1; i <=m; i++)
		{
			printf("%d ", way[i]);
		}
		puts("");
		return;
	}
	for (int i = start; i <= n; i++)
	{
		way[u] = i;
		dfs(u + 1, i + 1);
		way[u] = 0;
	}
}

int main()
{
	scanf("%d%d", &n, &m);
	dfs(1, 1);
	return 0;
}

补充：DFS的优化—剪枝

以上面的组合型代码为例子，假设当前正在选第u个数，那么就代表已经选了（u-1）个数，将从start开始到n结束的数按顺序放到数组dt[N]中，如果从start开始到n结束中间的数的数目过小，导致这个数加上u-1是小于m的（选不全），那么就可以直接return了。

即n-start+1+u-1 = n+u-start

如果把后面所有数都选上，都不够m个，当前分支一定无解。

#include
#include
using namespace std;

const int N = 30;//多给一点防止越界
int dt[N];
int n, m;

void dfs(int u,int start)
{
    if (n + u - start < m) return;//剪枝
	if (u > m)
	{
		for (int i = 1; i <=m; i++)
		{
			printf("%d ", dt[i]);
		}
		puts("");
		return;
	}
	for (int i = start; i <= n; i++)//开始选数放进去了，从start开始，到n结束。
	{
		dt[u] = i;
		dfs(u + 1, i + 1);//注意start代表最开始的位置，是不能改变的，改变的是代表开始位置的i。
		dt[u] = 0;
	}
}

int main()
{
	scanf("%d%d", &n, &m);
	dfs(1, 1);
	return 0;
}

优化完时间快了三倍。