leetcode1307——深度优先搜索

变量的含义：

chars用来保存从低位到高位每一位未确定的字符

equations用来记录每一层中每一个字母对应的加减个数标志

将result也push_back到words的动态数组中，最后直接减去result中的当前位用以判断余数是否为0

num_to_ch 用以保存从数字到单词的映射，ch_to_num用以保存从单词到数字的映射

zeroFlag记录不能为0的所有单词开头字母

思路为，确定每一层的所有字母后，进行该层的判断，判断成功后进行下一层判断，一直到第八层为止，成功后记录标志并返回，注意在回溯过程中进位标志要重置为原来的值。

class Solution {
public:
    bool check(vector>& equations,int layer_index,vector&ch_to_num,int& ins)
    {
        int ans=ins;
        int len_ch=equations[layer_index].size();
        for(int i=0;i>& chars,vector>& equations,int layer_index,int ch_id,int ins,vector& num_to_ch,vector& ch_to_num,vector& zeroFlag,bool& flag_result)
    {
             if(flag_result)return;
            if(ch_id==chars[layer_index].size())
            {
                if(!check(equations,layer_index,ch_to_num,ins))
                    return;

                if(layer_index==7)
                {
                    flag_result=true;
                    return;
                }
                 dfs(chars,equations,layer_index+1,0,ins,num_to_ch,ch_to_num,zeroFlag,flag_result);
                 return;
            }
            for(int i=0;i<10;i++)
            {
                if(i==0&&zeroFlag[chars[layer_index][ch_id]-'A']==true)
                    continue;
                if(num_to_ch[i]!='a')continue;
                int tempInc=ins;
                ch_to_num[chars[layer_index][ch_id]-'A']=i;
                num_to_ch[i]=chars[layer_index][ch_id];
                dfs(chars,equations,layer_index,ch_id+1,ins,num_to_ch,ch_to_num,zeroFlag,flag_result);
                ch_to_num[chars[layer_index][ch_id]-'A']=-1;
                num_to_ch[i]='a';
                ins=tempInc;
            }
    }
    bool isSolvable(vector& words, string result) {
        vectornum_to_ch(10,'a');  //记录从数字到单词的映射
        vectorch_to_num(26,-1);    //记录从单词到数字的映射
        vectorzeroFlag(26,false); //记录哪些字母不能被0填充
        vector>equation(8,vector(26,0));  //记录每一层字母对应数字前面的正负标志
        vector>chars(8,vector());
        words.push_back(result);
        for(int j=0;j=0;i--)
            {
                equation[layer++][word[i]-'A']+=(j==words.size()-1)?-1:1;
            }
        }
        setchar_undefined;
        for(int layer=0;layer<8;layer++)
        {
            for(size_t i=0;i<26;i++)
            {
                if(equation[layer][i]==0)continue;
                char c=i+'A';
                if(char_undefined.find(c)!=char_undefined.end())continue;
                chars[layer].push_back(c);
                char_undefined.insert(c);
            }
        }

        bool flag_result=false;
        dfs(chars,equation,0,0,0,num_to_ch,ch_to_num,zeroFlag,flag_result);
        return flag_result;
    }
};