Leetcode17:电话号码的字母组合

题目介绍：
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例:

输入："23"
输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

方法1：深度优先搜索

解题思路：
　　这道题目需要穷举所有的组合，属于典型的bfs问题，且搜索路径过程中没有阻碍项，所以只需要把搜索树构建完成找出所有完整的路径返回即可。
　　在上面的示例中，树的深度是输入字符的长度，每一层树的宽度是对应输入字符在电话键盘上拥有的字符个数。根据下面bfs的就可以写程序了：

result=[];
def backtrack(路径，选择列表)
    if 满足结束条件：
       result.add(路径)
       return;
    for 选择 in 选择列表
       做选择
       backtrack(路径，选择列表)
       撤销选择

下面贴上自己写的bfs代码和官方的代码：

class Solution {
public:
    vector<string> letterCombinations(string digits) { 
    vector<string>str;  
    if(digits.empty()){
     return str;
    }
     unordered_map<char, string> phoneMap{
            {'2', "abc"},
            {'3', "def"},
            {'4', "ghi"},
            {'5', "jkl"},
            {'6', "mno"},
            {'7', "pqrs"},
            {'8', "tuv"},
            {'9', "wxyz"}
        }; 
    string contain;
    backtrack(str, contain, phoneMap,digits, 0);
    return str;
    }
    //定义回溯函数
   void backtrack(vector<string>& str, string contain,unordered_map<char, string> phoneMap,string digits, int index) {
           if(index==digits.length()){
           str.push_back(contain);
           return;
        }
        string record=phoneMap[digits[index]]; //这个里面记录的符号
        for(int i=0; i<record.length(); i++){
            contain.push_back(record[i]);
            backtrack(str,contain,phoneMap,digits,index+1);
            contain.pop_back();
    }
   }
};

class Solution {
public:
    vector<string> letterCombinations(string digits) {
        vector<string> combinations;
        if (digits.empty()) {
            return combinations;
        }
        unordered_map<char, string> phoneMap{
            {'2', "abc"},
            {'3', "def"},
            {'4', "ghi"},
            {'5', "jkl"},
            {'6', "mno"},
            {'7', "pqrs"},
            {'8', "tuv"},
            {'9', "wxyz"}
        };
        string combination;
        backtrack(combinations, phoneMap, digits, 0, combination);
        return combinations;
    }

    void backtrack(vector<string>& combinations, const unordered_map<char, string>& phoneMap, const string& digits, int index, string& combination) {
        if (index == digits.length()) {
            combinations.push_back(combination);
        } else {
            char digit = digits[index];
            const string& letters = phoneMap.at(digit);
            for (const char& letter: letters) {
                combination.push_back(letter);
                backtrack(combinations, phoneMap, digits, index + 1, combination);
                combination.pop_back();
            }
        }
    }
};

方法2：广度优先搜索

再补充下bfs搜索的一种算法，其实bfs的问题可以想象成在树上从左到右从上到下的走，然后每次走完一行，这行的元素叶清零了，或者说每次记录一个元素就删除一个元素，直到走到最后，在走的过程中不断更新路径~~~

#include <vector>
#include <string>
#include <queue>
#include <iostream>
#include <unordered_map>
using namespace std;
class Solution
{
    vector<string> result;
    string digits;
    unordered_map<char, string> store;

public:
    vector<string> letterCombinations(string digits)
    {
        if (digits.empty())
            return result;
        //储存字典
        store = unordered_map<char, string>{
            {'2', "abc"}, {'3', "def"}, {'4', "ghi"}, {'5', "jkl"}, {'6', "mno"}, {'7', "pqrs"}, {'8', "tuv"}, {'9', "wxyz"}};

        queue<string> workQueue;
        workQueue.push(""); //进入一个空结点，这样就符合了我们树的操作，但是我们不用提前先赋值第一层了。
        for (auto targetChar : digits)
        {
            string targetStr = store[targetChar];
            int queueSize = workQueue.size();
            //当前层，进行添加字符
            for (int i = 0; i < queueSize; ++i)
            {
                string tmpStr = workQueue.front(); //先记录队列或者某一层中每一个元素的前字符
                workQueue.pop(); //退出
                for (auto tmpChar : targetStr)  // 
                {
                    workQueue.push(tmpStr + tmpChar); //在前字符的基础上上累加字符
                }
            }
        }
        while (!workQueue.empty())
        {
            string tmpStr = workQueue.front();
            workQueue.pop();
            result.push_back(tmpStr);
        }
        return result;
    }
};

对字符问题的一些总结

因为之前没怎么写过过于针对string类型数据的处理，一开始有点茫然。从上面的代码可以看到string和vector类型都可以使用pop_back()，push_back()指令，它们的长度也可以用xx.size()来表示，string类型也可以用xx.length()表示长度(带string.h头文件。
　　虽然string类型的字符串是一个整体，但是也可以用下标来索引对应位置的元素，如digits[i]所示。在上面的代码中回溯函数传入参数很多，其实最好是在元素前面增加const 以免不小心修改了数组。
　　还有个就是contain是形参，但是在上面的代码中出现了contain.pop_back()，刚开始写bfs的时候经常不知道这个地方是否要撤回操作，担心撤回了那结果不是少了一个元素，无法搜索到完整结果了等。。
　　其实如果树的广度只有一个，是不需要做撤回操作了，但是撤回是为了检索同一深度其他元素参与的路径。而且这并不会影响最终结果。就是写b’fs的时候要明确我们的返回是什么，这道题返回的是完整路径，然后再回退，再找一条完整路径，回退。。。直到所有路径找完，完整的路径在之前已经记录和返回了，撤回操作是不会影响之前的结果的。 反正记住bfs是回退问题，树的同一层深度不同元素一旦开始循环遍历时，意味着至少已经找完了一条路在找下一条。
　　还有一个就是我的回溯函数形参中没有增加引用符号：&，这很大程度增加了内存占用，因为这题的传入参数比较多，基本都是不需要改变的，如果不用地址符，每次回溯调用函数都要开辟一个新的内存空间，但是用了引用地址符就可以共用一个内存空间啦~
　　最后发现就是对哈希表phoneMap传入时候前面加const后，在子函数中对哈希表值得索引不能通过简单得phoneMap[digit]了中对哈希表值但是都是而是要通过phoneMap.at(digit); 最后添加下char和 String的区别。
　　1、类型不同，char是字符类型， String是字符串类型。
2、String字符串是用""来包含串的， char是用’'来包含单字符的。 char用单引号，string 用双引号。 可以用.empty()判断string是否为空。

for (const char& letter: letters)