手撕算法稳过技巧2：用日志更好的观察递归本文提出了一种更好的应对面试的手撕算法的调试技巧，即在递归的时候，习惯性的打上头

手撕算法稳过技巧2：用日志更好的观察递归

引言

在技术面试中，手撕算法是每个程序员都要面对的挑战。特别是递归算法，由于其执行过程的"黑盒化"特性，往往让面试者在白板编程时陷入困境。本文分享一种"嵌入式调试"的设计思路，通过将调试信息直接嵌入算法代码，让递归过程变得可观测，从而有效防止面试翻车。

题目背景：LeetCode 1079 活字印刷

题目描述

你有一套活字字模 tiles，其中每个字模上都刻有一个字母 tiles[i]。返回你可以印出的非空字母序列的数目。

注意：本题中，每个活字字模只能使用一次。

示例 1：

输入："AAB"
输出：8
解释：可能的序列为 "A", "B", "AA", "AB", "BA", "AAB", "ABA", "BAA"。

示例 2：

输入："AAABBC"
输出：188

示例 3：

输入："V"
输出：1

提示：

1 <= tiles.length <= 7
tiles 由大写英文字母组成

解题思路分析

这是一个典型的排列组合问题，需要生成所有可能的非空子序列。

核心挑战： 0. 排列组合

去重问题：相同字符的不同位置需要去重
回溯实现：需要正确实现状态的回溯恢复

算法思路：

使用回溯算法生成所有可能的排列
通过交换元素避免重复选择
使用哈希集合记录已使用的字符
每次递归都记录当前构建的字符串

问题背景：递归算法的观察困境

传统递归实现的问题

在面试环境中，我们面临以下约束：

无法使用IDE的调试功能
时间压力下的快速理解需求
白板编程的局限性
需要向面试官展示清晰的思维过程

传统的递归实现往往是这样的：


class Solution {
public:
    vector<string> ret;
    int numTilePossibilities(string tiles) {
        string level = "#";
        traverse(tiles, 0, level);
        // for(auto t: ret){
        //     cout << "tile is " << t << endl;
        // }
        return ret.size();
    }

    void traverse(string tiles, int p) {
        if(p == tiles.size()) return;
        
        char p_char = tiles[p];
        int p_forward = p;
        unordered_set<char> memo;
        memo.insert(p_char);
        
        while(p_forward < tiles.size()) {
            char p_forward_char = tiles[p_forward];
            if(p_forward > p && memo.find(p_forward_char) != memo.end()) {
                p_forward += 1;
            } else {
                swap(tiles[p], tiles[p_forward]);
                memo.insert(p_forward_char);
                ret.push_back(tiles.substr(0,p+1));
                traverse(tiles, p+1);
                swap(tiles[p], tiles[p_forward]);
                p_forward += 1;
            }
        }
    }
}

这种实现虽然逻辑正确，但在面试中容易出现以下问题：

状态变化难追踪：不知道当前处于哪个递归层级
错误定位困难：出现bug时难以快速定位问题
思维过程不清晰：面试官难以理解你的分析思路

解决方案：嵌入式调试设计

核心思想

"嵌入式调试"的核心思想是：

将调试信息直接嵌入算法逻辑中，通过注释代码提供虚拟的调试器功能。
在递归进入和结束的时候，打log标记。
进入递归的时候，带上一个表示层级的参数。
循环的时候，先打印参数，再执行具体的操作。

亮点分析和面试实战价值

通过log,多层次的信息记录

递归层级追踪：通过level参数构建递归树的可视化路径
状态变化记录：记录每次状态修改和恢复
决策过程标记：标记关键的条件判断和分支选择

深层价值思考

1. 认知负荷降低

这种设计将复杂的递归逻辑从"黑盒"变成"白盒"，显著降低了面试者的认知负荷。

2. 学习效果提升

通过注释代码，算法学习者可以更好地理解递归的执行机制，提升学习效果。

3. 工程实践价值

这种"可观测性设计"的思想在工程实践中同样有价值，特别是在复杂系统的调试和监控中。

总结

"嵌入式调试"的设计思路不仅解决了面试中手撕算法的翻车问题，更重要的是提供了一种让复杂逻辑变得可观测的方法论。它把"调试思维"前置到了"编码阶段"，让算法实现从"黑盒"变成"白盒"。

在技术面试中，这种设计让你能够：

快速理解递归执行过程
有效防止逻辑错误
向面试官展示清晰的思维过程
在高压环境下保持稳定的发挥

记住：最好的代码不仅是功能实现，更是知识传递的载体。通过这种设计，我们不仅解决了技术问题，更提升了面试的成功率。

附算法解决过程

using namespace std;
#include <algorithm>
#include <array>
#include <bitset>
#include <climits>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <queue>
#include <stack>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// @lcpr-template-end
// @lc code=start
class Solution {
public:
    vector<string> ret;
    int numTilePossibilities(string tiles) {
        string level = "#";
        traverse(tiles, 0, level);
        // for(auto t: ret){
        //     cout << "tile is " << t << endl;
        // }
        return ret.size();
    }

    void traverse(string tiles, int p, string level){
        if(p == tiles.size()){
            // cout << "p out" << endl;
            return;
        }
        // cout << "level is " << level << endl;
        // cout << "p is " << p << endl;
        char p_char = tiles[p];
        int p_forward = p;
        unordered_set<char> memo;
        memo.insert(p_char);
        while(p_forward < tiles.size()){
            char p_forward_char = tiles[p_forward];
            // cout << "p_forward is " << p_forward << endl;
            if(p_forward > p && memo.find(p_forward_char) != memo.end()){
                // cout << "replicated p " << p << endl;
                // cout << "replicated p_forward " << p_forward << endl;
                p_forward += 1;
            }else{
                // cout << "not replicated p " << p << endl;
                // cout << "not replicated p_forward " << p_forward << endl;
                swap(tiles[p], tiles[p_forward]);
                memo.insert(p_forward_char);
                // cout << "substr " << tiles.substr(0,p+1) << endl;
                // cout << "tiles is " << tiles << endl;
                ret.push_back(tiles.substr(0,p+1));
                traverse(tiles, p+1, level + "-" + to_string(p) + "#");
                swap(tiles[p], tiles[p_forward]);
                p_forward += 1;
            }
        }
        // cout << "level is " << level << "end" << endl;
    }
};