【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段，如代码所示。

void dfs(int x) {
    //--------#0
    if (sel.size() > m || sel.size() + n - x + 1 < m)
        return;
    if (x == n + 1) {
        rep(0, m - 1)
            printf("%d ", sel[i]);
        puts("");
        return;
    }
    sel.push_back(x);
　 //--------#0
    dfs(x + 1);
    //--------#1
    sel.pop_back();
    //--------#1
    dfs(x + 1);
    //--------#2
    return;
}

　　基于这段函数体，我们用循环来模拟递归调用的过程。定义状态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函数代码：

struct State {
    int x, addr;
    State(int a, int b):
        x(a), addr(b) {}
};
int main() {
    cin >> n >> m;
    stack<State> sta;
    sta.push(State(1, 0));//dfs(1);
    while (sta.size()) {
        int x = sta.top().x, cur_addr = sta.top().addr;
        sta.pop();
        switch (cur_addr) {
            case 0:
                if (sel.size() > m || sel.size() + n - x + 1 < m)
                    continue;
                if (x == n + 1) {
                    rep(0, m - 1)
                        printf("%d ", sel[i]);
                    puts("");
                    continue;
                }
                sel.push_back(x);
                sta.push(State(x, 1));
                sta.push(State(x+1, 0));
                continue;
            case 1:
                sel.pop_back();
                sta.push(State(x+1, 0));
        }
    }
    return 0;
}

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

#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
using namespace std;
vector<int> chosen;
int top, address, sta[100010], n, m;
inline void call(int x, int ret_addr) {  //模拟系统栈指令call()，记录每个状态的参数和返回语句位置
    int pre = top;
    sta[++top] = x;
    sta[++top] = ret_addr;
    sta[++top] = pre;
}
inline int ret() {  //模拟指令return，退栈并返回应该执行的下一条语句
    int ret_addr = sta[top - 1];
    top = sta[top];
    return ret_addr;
}
int main() {
    cin >> n >> m;
    call(1, 0);
    while (top) {
        int x = sta[top - 2];
        switch (address) {
            case 0:
                if (chosen.size() > m || chosen.size() + (n - x + 1) < m) {
                    address = ret();
                    continue;
                }
                if (x == n + 1) {
                    for (int i = 0; i < chosen.size(); ++i)
                        printf("%d ", chosen[i]);
                    puts("");
                    address = ret();
                    continue;
                }
                chosen.push_back(x);
                call(x+1, 1);  //入栈下一个状态
                address = 0;  //下一个函数从头执行
                continue;
            case 1:
                chosen.pop_back();
                call(x+1, 2);  //入栈下一个状态
                address = 0;
                continue;
            case 2:
                address = ret();  //当前状态已执行完毕，返回
        }
    }
    return 0;
}