递归-动态规划

简单递归

单向递归：递归的路径就是一个方向
递归的两个必要条件：1.存在限制2.每次递归调用之后越来越接近这个限制条件

例子1：实现求斐波那契数

#include<iostream>
using namespace std;
int fus(int a)
{
	if(a==1)
		return 1;
	else if (a==0)
		return 0;
	else 
		return fus(a-1)+fus(a-2);
}
int main()
{
	int n;
	cin>>n;
	cout<<fus(n)<<endl;
	return 0;
}

例子2：写一个递归函数DigitSum(n),输入一个非负整数，返回组成它的数字之和

#include<iostream>
using namespace std;
int DigitSum(int n)
{
	if(n==0)
		return 0;
	return n%10+DigitSum(n/10);
}
int main()
{
	int k;
	cin>>k;
	cout<<DigitSum(k)<<endl;
	return 0;
}

例子3：杨辉三角
两边的腰数字都为1，从第三行开始，除了第一个数和最后一个数外，其他位置的数都是上下顶上两数之和

#include <iostream>
using namespace std;
int fun(int m,int n){
	if(n==1||m==n)
	return 1;
	else return fun(m-1,n)+fun(m-1,n-1);
}

int main()
{
	int i,j,n;
	cin>>n;
	for(i=1;i<=n;i++){
		for(j=1;j<=i;j++)
			cout<<fun(i,j)<<" ";
		cout<<endl;
	}
	return 0;
}

例子4：汉诺塔

例子5：卡塔兰数（Catalan）
例子6：斯特林数（Stirling）
例子7：平面分割问题

递推

例子1：数字三角形（n<=100,n为行数）
编写一个程序计算从顶到底的某处的一条总和最大的路径

#include<iostream>
using namespace std;
int main()
{
	int n,i,j,a[101][101];
	cin>>n;
	for(i=1;i<=n;i++)
		for(j=1;j<=i;j++)
			cin>>a[i][j];
	for(i=n-1;i>=1;i++)
		for(j=1;j<=i;j++)
			{
				if(a[i+1][j]>=a[i+1][j+1])
					a[i][j]+=a[i+1][j];
				else
					a[i][j]+=a[i+1][j+1];
			}
	cout<<a[1][1]<<endl;
	return 0;	
}

（用倒推的方法）

全排列

从n个不同的元素中任取m个元素，按照一定的顺序排列起来，称作从n个不同元素中取出m个元素的一个排列，用A(n,m)表示。当n=m时称作全排列，排列数公式：n!

#include <iostream>
using namespace std;
int arr[5]={0,1,2,3,4};
void swap(int x,int y)
{
	int temp=arr[x];
	arr[x]=arr[y];
	arr[y]=temp;
}
int resove(int n)//递归函数
{
	if(n==5)
	{
		for(int i=0;i<5;i++)
		cout<<arr[i];
		cout<<endl;
		return 0;
	}
	for(int i=n;i<5;i++)//循环实现交换和之后的全排列，i是从n开始，swap(n,i)相当于固定当前位置，再进行下一位的排列
	{
		swap(n,i);
		resove(n+1);
		swap(n,i);
	}
} 
int main()
{
	resove(0);
}

或者：

#include<stdio.h>
void swap(int A[],int i ,int j)
{
	int temp=A[i];
	A[i]=A[j];
	A[j]=temp;
}
void printArray(int A[],int n)
{
	int i;
	for(i=0;i<n;i++)
	printf("%d ",A[i]);
	printf("\n");
}
void perm(int A[],int p,int q)
{
	if(p==q)
	{
		printArray(A,q+1);	
	}
	else
	{
		int i;
		for(i=p;i<=q;i++)
		{
			swap(A,p,i);
			perm(A,p+1,q);
			swap(A,p,i);
		}
	}
}
int main()
{
	int A[5]={1,2,3,4,5};
	perm(A,0,4);
	getchar();
}

背包问题

有n个物体，有各自的体积和价值，现给定容量的背包，如何让背包里装入的物品具有最大的价值总和？（这个问题我好像在《算法图解》里看过欸）

种类：
0/1背包问题
完全背包问题
多重背包问题
混合三种背包问题
二维费用背包问题
分组背包问题
有依赖的背包问题
求背包的方案总数

解题思路：动态规划（DP）

首先了解啥是动态规划

将要求的问题分解成若干相互联系的子问题，先求解子问题。
思考动态规划
1.最优子结构
2.子问题重叠：对于重复遇到已经解决过的子问题，只计算一次并把结果存储在表格中

0/1背包问题
有N件物品和一个容量是V的背包。
第i件物品的体积是vi，价值是wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包的容量，且价值最大。
子问题定义：F[i][j]表示前i件物品中选取若干件物品放入剩余空间为j的背包中所能得到的最大价值

解题思路：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn = 1e4;
int f[maxn];
int w[maxn],val[maxn];//w[]指物体体积val[]物体价值 
void solve(int n,int m){//n是物体个数，m是背包容量 
	memset(f,0,sizeof f);//数组的初始化，所有元素初始化为0
	for(int i = 1;i <= n;i++){
		for(int v = m;v > 0;v--){
			if(v >= w[i])
				f[v] = max(f[v],f[v-w[i]]+val[i]);
		}
	}
	printf("%d\n",f[m]);
}
int main(){
	int n,m;//n是物体个数，m是背包容量 
	while(scanf("%d%d",&n,&m) != EOF){
		for(int i = 1;i <= n;i++) scanf("%d%d",w+i,val+i);
		solve(n,m);
	}
	return 0;
}

memset(void *s,int ch,size_t n)将s中当前位置后面的n个字节用ch替换并返回s。通常用于对较大的机构体或数组进行清零操作。

#include<iostream>
using namespace std;
int dp[35][205];
int w[35],c[35];
int main()
{
	int m,n;
	cin>>m>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>w[i]>>c[i];
	}
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
		{
			if(j<w[i])
				dp[i][j]=dp[i-1][j];
			else
				dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+c[i]);
		}
//输出dp看变化
for(int i=0;i<=n;i++)
{
	for(int j=0;j<=m;j++)
	{
		cout<<dp[i][j]<<" ";
	}
	cout<<endl;
 } 
 cout<<dp[n][m];
 return 0;
}

后无效性原则：当前状态只与上一个有关

最长子序列系列问题

求解序列中最长子序列
子序列：将给定序列中零个或多个元素去掉之后的结果。
子串：给定串中任意个连续的字符组成的子序列。

最长公共子序列（LCS）

有一篇文章总结的很好：
原文链接：
戳这里