Facebook Phone Interview: Phone Number to Letter Combinations

Input: string of digits of arbitrary length

output: print all possible letter combinations for those digits to screen.

// This is a typical DFS algorithm.
// Suppose we dont know the phone screen layout. we need to set a dictionary first.
// 
map<char, vector<char> > dict; // we use a map structure to map digits to letters.
vector<string> ret;
void createDict() {
    dict.clear();
    dict['2'].push_back('a'); dict['2'].push_back('b'); dict['2'].push_back('c');
    dict['3'].push_back('d'); dict['3'].push_back('e'); dict['3'].push_back('f');
    dict['4'].push_back('g'); dict['4'].push_back('h'); dict['4'].push_back('i');
    dict['5'].push_back('j'); dict['5'].push_back('k'); dict['5'].push_back('l');
    dict['6'].push_back('m'); dict['6'].push_back('n'); dict['6'].push_back('o');
    dict['7'].push_back('p'); dict['7'].push_back('q'); dict['7'].push_back('r'); dict['7'].push_back('s');
    dict['8'].push_back('t'); dict['8'].push_back('u'); dict['8'].push_back('v');
    dict['9'].push_back('w'); dict['9'].push_back('x'); dict['9'].push_back('y'); dict['9'].push_back('z');
}

// dfs algorithm.
void dfs(int dep, int maxDep, string& s, string ans) {
    if(dep == maxDep) {
        ret.push_back(ans);
        return;
    }
    for(int i = 0; i < dict[s[dep]].size(); ++i) {
        dfs(dep + 1, maxDep, s, ans+ dict[s[dep]][i]);
    }
}

vector<string> letterCombinations(string digits) {
    ret.clear();
    createDict();
    dfs(0, digits.size(), digits, "");
    return ret;
}

This is very straightforward to do it recursively. However, iterative is more elegant. 

Think it in this way: 

Suppose we have one digit, the output is straightforward, if we have two digits: 23, the output should be add the second digits' mapping to each first digit's mapping.

We can use a vector to store first digit's mapping, and loop through the mapping to add the second digit's mapping.

The total time complexity is (m ^ n) : m is the mapping digits' size, n is the total length of digits.

// do it iteratively.
vector<string> letterCombinations(string digits) {
  if(digits.size() == 0) return {};
  vector<string> maps{"0", "1", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
  vector<string> res;
  res.push_back("");
  for(int i = 0; i < digits.size(); ++i) {
    vector<string> backUp;
    for(int j = 0; j < maps[digits[i] - '0'].size(); ++j) {
      for(int k = 0; k < res.size(); ++k) {
        backUp.push_back(res[k] + maps[digits[i] - '0'][j]);
      }
    }
    res = backUp;
  }
  return res;
}

int main(void) {
  vector<string> res = letterCombinations("123");
  for(int i = 0; i < res.size(); ++i) {
    cout << res[i] << endl;
  }
}