【ACwing 93】【模版】非递归实现组合型枚举——模拟递归

（题面来自ACwing）

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

输入格式

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

输出格式

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

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

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

数据范围

n>0 ,
0≤m≤n ,
n+(n−m)≤25

　　此题的正解是dfs枚举，在之前的博客中有所提及。现在考虑用循环模拟机器递归的方式来做。

　　计算机维护系统栈来实现递归，栈中每个元素记录三个状态：当前函数的参数、上一层递归的位置（旧栈顶），以及递归完成后，上一层递归函数应当执行的下一条语句。我们模拟的栈的上一层栈顶位置是显然的，不需要记录第二个参数。

　　递归的过程是：每次将栈顶的元素出栈，确认它对应的状态执行到了哪一步，从这一步继续向下执行，直到返回或者遇到下一个递归调用。举个例子：下面是此题正解的dfs函数，我们可以把它分为3段，如代码所示。

1. void dfs(int x) {  
2.     //--------#0  
3.     if (sel.size() > m || sel.size() + n - x + 1 < m)  
4.         return;  
5.     if (x == n + 1) {  
6.         rep(0, m - 1)  
7.             printf("%d ", sel[i]);  
8.         puts("");  
9.         return;  
10.     }  
11.     sel.push_back(x);  
12. 　 //--------#0
13.     dfs(x + 1);  
14.     //--------#1  
15.     sel.pop_back();  
16.     //--------#1
17.     dfs(x + 1);  
18.     //--------#2  
19.     return;  
20. }  

　　基于这段函数体，我们用循环来模拟递归调用的过程。定义状态state包含的两个元素为当前函数参数x、当前函数的执行位置；注意这里的状态和系统栈中有差异。系统栈中记录的是返回后函数的执行位置，这里为了更直观地演示当前函数的执行而做了修改。首先将第一个状态{1, 0}入栈（对应主函数中的递归调用入口）。接下来进入循环体，我们在栈不空时循环执行以下语句：

　　1、出栈，记录栈顶参数x和当前执行位置cur_addr。

　　2、如果cur_addr为0，说明该函数从头开始执行，我们执行第0段函数体。执行完毕后，我们先入栈{x, 1}（表示再退栈到该状态时应当执行第1段函数体了），仔把下一个函数的参数x+1、下一个函数的执行位置(0)入栈。之后continue进入下一层循环；

　　3、如果cur_addr为1，说明该执行第二段函数体；这时我们先后入栈{x, 2}（返回到该状态时执行第2段函数体）、{x+1, 0}（下一层递归），继续循环。

　　4、如果cur_addr为2，当前函数已执行完毕，不用再次入栈。继续循环即可。

完整main函数代码：

1. struct State {  
2.     int x, addr;  
3.     State(int a, int b):  
4.         x(a), addr(b) {}  
5. };  
6. int main() {  
7.     cin >> n >> m;   
8.     stack<State> sta;  
9.     sta.push(State(1, 0));//dfs(1);  
10.     while (sta.size()) {  
11.         int x = sta.top().x, cur_addr = sta.top().addr;   
12.         sta.pop();  
13.         switch (cur_addr) {  
14.             case 0:  
15.                 if (sel.size() > m || sel.size() + n - x + 1 < m)  
16.                     continue;  
17.                 if (x == n + 1) {  
18.                     rep(0, m - 1)  
19.                         printf("%d ", sel[i]);  
20.                     puts("");  
21.                     continue;  
22.                 }  
23.                 sel.push_back(x);  
24.                 sta.push(State(x, 1));  
25.                 sta.push(State(x+1, 0));   
26.                 continue;  
27.             case 1:  
28.                 sel.pop_back();  
29.                 sta.push(State(x+1, 0));  
30.         }  
31.     }   
32.     return 0;  
33. }  

　　算法进阶上给出的代码与系统栈的返回方式更加契合，这里一并给出。

1. #include <iostream>  
2. #include <cstring>  
3. #include <cstdio>  
4. #include <vector>  
5. using namespace std;  
6. vector<int> chosen;  
7. int top, address, sta[100010], n, m;  
8. inline void call(int x, int ret_addr) {  //模拟系统栈指令call()，记录每个状态的参数和返回语句位置
9.     int pre = top;  
10.     sta[++top] = x;  
11.     sta[++top] = ret_addr;  
12.     sta[++top] = pre;  
13. }  
14. inline int ret() {  //模拟指令return，退栈并返回应该执行的下一条语句
15.     int ret_addr = sta[top - 1];  
16.     top = sta[top];  
17.     return ret_addr;  
18. }  
19. int main() {  
20.     cin >> n >> m;  
21.     call(1, 0);  
22.     while (top) {  
23.         int x = sta[top - 2];  
24.         switch (address) {  
25.             case 0:  
26.                 if (chosen.size() > m || chosen.size() + (n - x + 1) < m) {  
27.                     address = ret();  
28.                     continue;  
29.                 }  
30.                 if (x == n + 1) {  
31.                     for (int i = 0; i < chosen.size(); ++i)  
32.                         printf("%d ", chosen[i]);  
33.                     puts("");  
34.                     address = ret();  
35.                     continue;  
36.                 }  
37.                 chosen.push_back(x);  
38.                 call(x+1, 1);  //入栈下一个状态
39.                 address = 0;  //下一个函数从头执行
40.                 continue;  
41.             case 1:  
42.                 chosen.pop_back();  
43.                 call(x+1, 2);  //入栈下一个状态
44.                 address = 0;  
45.                 continue;  
46.             case 2:  
47.                 address = ret();  //当前状态已执行完毕，返回
48.         }  
49.     }  
50.     return 0;     
51. }