算法复习：回溯法

一、需要还原状态的递归回溯

leetcode 46. 全排列

打印一串数字的全排列，定义一颗树，树的每个节点map<int,int>used保存当前哪些点用了哪些点还没用，Tnode *next[100]保存接下来的每一个点的索引

就是一个建树的过程，当前数字栈达到了最大长度就保存一次结果，每一个节点都遍历它的used域，直到used所有的元素都用过了才达到叶子节点，那么返回

struct Tnode
{
    map<int,int>used;
    Tnode *next[100];
};
class Solution {
public:
    struct Tnode * root=new Tnode();
    vector<int >now;
    vector<vector<int>> result;
    void loop(struct Tnode *node,int num)
    {
        map<int,int>::iterator it;
        map<int,int> tmp=node->used;
        for(it=tmp.begin();it!=tmp.end();it++)
        {
            if(it->second==1)
                continue;
            now.push_back(it->first);
            if(now.size()==num)
                result.push_back(now);
            struct Tnode * new_node=new Tnode();
            new_node->used=tmp;
            new_node->used[it->first]=1;
            new_node->next[it->first]=new_node;
            loop(new_node,num);
            now.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        int num=nums.size();
        for(int i=0;i<num;i++)
        {
            root->used[nums[i]]=-1;
        }
        struct Tnode * node=new Tnode();
        node=root;
        loop(node,num);
        return result;

    }
};

leetcode 46

二、不需要还原状态的递归回溯

leetcode 面试题13. 机器人的运动范围

本质上还是一个深度优先遍历

class Solution {
public:
    int count=0;
    map<int,bool>lable;
    bool check(int m,int n,int k)
    {
        int sum=0;
        while(m)
        {
            sum+=m%10;
            m/=10;
        }
        while(n)
        {
            sum+=n%10;
            n/=10;
        }
        if(sum<=k)
            return true;
        return false;
    }
    void dfs(int x,int y,int m, int n, int k)//当前 x y ;最大m n ;限制为k
    {
        if(check(x,y,k)==false||x<0||x>=m||y<0||y>=n||lable[x*n+y]==true)
            return ;
        count++;
        lable[x*n+y]=true;
        dfs(x+1,y,m,n,k);
        dfs(x,y+1,m,n,k);
        dfs(x-1,y,m,n,k);
        dfs(x,y-1,m,n,k);
    }
    int movingCount(int m, int n, int k) {
        dfs(0,0,m,n,k);
        return count;
    }
};

回溯