0x00 递归与递推(上）

递归：以“原问题”为起点尝试寻找把状态空间缩小到已知的“问题边界”的路线，再通过该路线反向回溯的遍历方式。

递推：以已知的“问题边界”为起点向“原问题”正向推导的扩展方式。

使用枚举算法暴力搜索整个状态空间，经常使用到递归算法。

例题 递归实现指数型枚举

题目描述

从 1~n 这 n 个整数中随机选取任意多个，输出所有可能的选择方案。

输入格式

输入一个整数n。

输出格式

每行输出一种方案。

同一行内的数必须升序排列，相邻两个数用恰好1个空格隔开。

对于没有选任何数的方案，输出空行。

本题有自定义校验器（SPJ），各行（不同方案）之间的顺序任意。

数据范围

1≤n≤15

输入样例：

3

输出样例：

3

2

2 3

1

1 3

1 2

1 2 3

解题思路：

使用二进制状态压缩，枚举所有的情况

解模板

C++:

#include<iostream>
 using namespace std;
 int n;
 
//u表示当前枚举到的数，state即用来记录状态的二进制数
 void dfs(int u, int state)
 {
   if(u == n){
     for(int i = 0;i < n;i++){
       if(state >> i & 1){   //判断第i位是否为1，如果为1即代表被选，输出
         cout << i + 1 << ' ';  //第i位表示的数为i+1
       }
     }
     cout << endl;
     return;
   }
   
   //u没有选，不用这个数，二进制状态第u位不变
   dfs(u + 1,state);  
   
   //选中u，使用u这个数，二进制状态的第u位变成1
   //左移优先级比位运算高
   dfs(u + 1,state | 1 << u);  
   
 }
 
int main()
{
  cin >> n;
  dfs(0,0);  //u为当前选的数，state是记录二进制状态的数
  return 0;
}

java：

import java.util.Scanner;


public class Main {


	public static void main(String[] args)   {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		dfs(0,0,n);
	}


	private static void dfs(int u, int state, int n) {
		if(u == n) {
			for(int i = 0;i < n;i++) {
				if((state>>i&1) != 0) {
					System.out.print((i+1)+" ");
				}
			}
			System.out.println();
			return;
		}
		
		dfs(u + 1,state,n);
		dfs(u + 1,state|1 << u,n);
	}
}

例题 递归实现组合型枚举

题目描述

从 1~n 这 n 个整数中随机选出 m 个，输出所有可能的选择方案。

输入格式

两个整数 n,m ,在同一行用空格隔开。

输出格式

按照从小到大的顺序输出所有方案，每行1个。

首先，同一行内的数升序排列，相邻两个数用一个空格隔开。

其次，对于两个不同的行，对应下标的数一一比较，字典序较小的排在前面（例如1 3 5 7排在1 3 6 8前面）。

数据范围

n>0,

0≤m≤n ,

n+(n−m)≤25

输入样例：

5 3

输出样例：

1 2 3 

1 2 4 

1 2 5 

1 3 4 

1 3 5 

1 4 5 

2 3 4 

2 3 5 

2 4 5 

3 4 5 

解题思路：

在上一题的基础上引入一个新的变量来表示当前取了几个数，增加一个边界条件。

解模板

#include<iostream>
using namespace std;
int n,m;
 
void dfs(int u, int sum,int state)
{
  if(sum + n - u < m){  //往后遍历无法选入m个数
    return;
  }
  if(sum == m){
    for(int i = 0;i < n;i++){
      if(state >> i & 1){   
        cout << i + 1 << ' ';  
      }
    }
    cout << endl;
    return;
  }


  dfs(u + 1,sum + 1,state | 1 << u);  //要求升序排序，则第一个先排
  dfs(u + 1,sum,state);  
   
}
 
int main()
{
  cin >> n >> m;
  dfs(0,0,0);
  return 0;
}

递归改为非递归

#include<iostream>
#include<stack>
 using namespace std;
 int n,m;
 
 struct State{
 	int pos;//表示程序运行到哪一部分了 即DFS里面的三种状态 
 	int u,sum,state;
 };
 
// void dfs(int u, int sum,int state)
// {
// 	//pos = 0 : 
//   if(sum + n - u < m){  
//     return;
//   }
//   if(sum == m){
//     for(int i = 0;i < n;i++){
//       if(state >> i & 1){   
//         cout << i + 1 << ' ';  
//       }
//     }
//     cout << endl;
//     return;
//   }
//
//   dfs(u + 1,sum + 1,state | 1 << u); 
//   //pos = 1 : 
//   
//   dfs(u + 1,sum,state);  
//   //pos = 2 : 
//   
// }
 
int main()
{
  cin >> n >> m;
  //dfs(0,0,0);
  
  stack<State> stk;
  stk.push({0,0,0,0});
  
  while(stk.size()){
  	auto t = stk.top();
  	stk.pop();
  	
  	if(t.pos == 0){
  		if(t.sum + n - t.u < m)continue;
  		if(t.sum == m){
  			for(int i = 0;i < n;i++){
       			if(t.state >> i & 1){   
         		cout << i + 1 << ' ';  
       			}	
     		}
     		cout << endl;
     		continue;
		}
		
		t.pos = 1;
		stk.push(t);
		stk.push({0,t.u + 1,t.sum + 1,t.state | 1<<t.u});
	}else if(t.pos == 1){
		t.pos = 2;
		stk.push(t);
		stk.push({0,t.u + 1,t.sum,t.state});
	}else continue;
  }
  return 0;
}