算法精析-1：回溯

1. 定义

回溯：回溯就是试错，是枚举。按照规定线路一条一条去遍历，一旦命中就返回。

2. 范式

回溯必须是递归，而且一般是多分枝递归（往下一步走时有多条路径）

【关键数据结构】：需要一个路径记录表（一维或二维数组）
【关键逻辑结构】：递归

if 命中目标
    return true
else
    1）记录当前路径或下一步的路径到路径表
    2）递归调用到下一步（往往是多分支），返回是否命中
    3）if 未命中
            把第1步中记录的路径删掉
       else 
            return true
return false

【解析要点】：
结果路径：一维数组或二维数组
结束条件：结果路径被填满或者其他约束
分支路径：下一步共多少分支
回溯条件：如何判断失败，不需要继续往下走

3. 举例

1）骑士巡游

结果路径：二维数组

结束条件：走过的步数等于棋盘方格数

分支路径：马走日

回溯条件：a) 踩到已走过的点  b) 无路可走了还没到结束条件

2）老鼠走迷宫

3）括号生成

结果路径：一维数组，存放生成的括号序列

结束条件：结果路径被填满

分支路径：a)添加左括号  b)添加右括号

回溯条件：a)右括号个数多余左括号 b)

 

4 代码示例

79. 单词搜索

https://leetcode-cn.com/problems/word-search/

/**
 * @param {character[][]} board
 * @param {string} word
 * @return {boolean}
 */
var exist = function (board, word) {
    let entries = _getEntries(board, word[0]);
    let res = [];

    // 该题目的特点在于“多源”，从各个可能的起点开始遍历
    for (let i = 0; i < entries.length; i++) {
        const pos = entries[i];
        let path = _copy(board);
        path[pos[0]][pos[1]] = 1;
        res.push(_backTrace({
            board,
            target: word.split(''),
            index: 1
        }, path, pos));
    }

    for (let k = 0; k < res.length; k++) {
        if (res[k] === true) {
            return true;
        }
    }

    return false;
};

function _copy(src) {
    let res = [];

    // 注意点：二维数组的深拷贝
    src.forEach(element => {
        res.push([...element]);
    });
    return res;
}

function _getEntries(board, start) {
    let res = [];
    for (let i = 0; i < board.length; i++) {
        for (let j = 0; j < board[i].length; j++) {
            const element = board[i][j];
            if (element === start) {
                res.push([i, j]);
            }
        }
    }
    return res;
}

/**
 * 经典回溯算法
 * @param traceData: {
 *  board: [][],
 *  target: [], 目标字符串
 *  index: number  结果路径（的指标）
 * }
 * @param board 
 * @param current: [x, y]
 */
function _backTrace(traceData, path, current) {
    // 结束条件
    if (traceData.board[current[0]][current[1]] === traceData.target.slice(-1)[0] &&
        traceData.index === traceData.target.length) {
        return true;
    } else {
        // 分支路径
        let next = _getNext(traceData, current);
        for (let i = 0; i < next.length; i++) {
            const pos = next[i];
            if (path[pos[0]][pos[1]] !== 1) {
                if (traceData.board[pos[0]][pos[1]] === traceData.target[traceData.index]) {
                    path[pos[0]][pos[1]] = 1;
                    traceData.index++;
                    const status = _backTrace(traceData, path, pos);
                    if (status === true) {
                        return true;
                    } else {
                        // 回溯条件
                        path[pos[0]][pos[1]] = 0;
                        traceData.index--;
                    }
                }
            }
        }
    }

    return false;
}

function _getNext(traceData, current) {
    const dx = [-1, 0, 1, 0];
    const dy = [0, -1, 0, 1];
    let res = [];

    for (let i = 0; i < dx.length; i++) {
        let tmp = [current[0] + dx[i], current[1] + dy[i]];
        if (tmp[0] >= 0 && tmp[0] < traceData.board.length &&
            tmp[1] >= 0 && tmp[1] < traceData.board[0].length) {
            res.push(tmp);
        }
    }

    return res;
}