[Leetcode] 17, 127, 126

最新推荐文章于 2023-03-20 11:17:12 发布

鹿行见马

最新推荐文章于 2023-03-20 11:17:12 发布

阅读量229

点赞数

分类专栏： Leetcode刷题

本文链接：https://blog.csdn.net/coderqich/article/details/77618814

版权

Leetcode刷题专栏收录该内容

34 篇文章 0 订阅

订阅专栏

17. Letter Combinations of a Phone Number

Given a digit string, return all possible letter combinations that the number could represent.

A mapping of digit to letters (just like on the telephone buttons) is given below.

Input:Digit string "23"
Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

Note:
Although the above answer is in lexicographical order, your answer could be in any order you want.

Solution: 对于每一位遍历每种可能性。

Code(递归):

class Solution {
public:
    vector<string> letterCombinations(string digits) {
        vector<string> ans;
        if(digits.size()==0) return ans;
        string path;
        letterCombinations(0, digits, path, ans);
        return ans;
    }
private:
    vector<string> m{"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
    void letterCombinations(int index, string& digits, string& path, vector<string>& ans){
        if(index==digits.size()){
            ans.push_back(path);
            return;
        }
        int number = digits[index]-'0';
        for(int i=0; m[number][i]; i++){
            path.push_back(m[number][i]);
            letterCombinations(index+1, digits, path, ans);
            path.pop_back();
        }
    }
};

Code(迭代):

class Solution {
public:
    const vector<string> m{"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
    vector<string> letterCombinations(string digits) {
        vector<string> ans;
        if(digits.size()==0) return ans;
        
        ans.push_back("");
        for(int i=0; i<digits.size(); i++){
            
            int size = ans.size();
            for(int j=0; j<size; j++){
                
                string s = ans[0];
                ans.erase(ans.begin());
                
                int index = digits[i]-'0';
                for(int t=0; m[index][t]; t++){
                    s.push_back(m[index][t]);
                    ans.push_back(s);
                    s.pop_back();
                }
            }
            
        }
        return ans;
    }
};

127. Word Ladder

Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence frombeginWord to endWord, such that:

Only one letter can be changed at a time.
Each transformed word must exist in the word list. Note that beginWord is not a transformed word.

For example,

Given:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log","cog"]

As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

Note:

Return 0 if there is no such transformation sequence.
All words have the same length.
All words contain only lowercase alphabetic characters.
You may assume no duplicates in the word list.
You may assume beginWord and endWord are non-empty and are not the same.

UPDATE (2017/1/20):
The wordList parameter had been changed to a list of strings (instead of a set of strings). Please reload the code definition to get the latest changes.

Solution: 广度优先搜索，一层层的搜索相邻单词，使用位向量visited记录访问过的单词去重。

Code:

class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        if(beginWord==endWord) return 1;
        //广搜
        vector<bool> visited;//不要使用vector<bool> visited(false, wordList.size*())的方式初始化，不知为何会出bug
        for(int i=0; i<wordList.size(); i++) visited.push_back(false); //直接push_back
        queue<pair<int,int>> q;//(wordIndex,step)
        for(int t=0; t<wordList.size(); t++){
            int count = 0;
            for(int j=0; j<wordList[t].size(); j++){
                if(beginWord[j]!=wordList[t][j]){
                    count++;
                    if(count>2) break;
                }
                    
            }
            if(count==1){
                q.push(make_pair(t,2));
                visited[t] = true;
            }
        }
        while(!q.empty()){
            if(wordList[q.front().first]==endWord){
                return q.front().second;
            }
            for(int t=0; t<wordList.size(); t++){
                if(visited[t]) continue;
                int count = 0;
                for(int j=0; j<wordList[t].size(); j++){
                    if(wordList[q.front().first][j]!=wordList[t][j]){
                        count++;
                        if(count>2) break;
                    }
                }
                if(count==1){
                    q.push(make_pair(t,q.front().second+1));
                    visited[t] = true;
                }
            }
            q.pop();
        }
        return 0;
    }
};

126. Word Ladder II

Given two words (beginWord and endWord), and a dictionary's word list, find all shortest transformation sequence(s) from beginWordto endWord, such that:

Only one letter can be changed at a time
Each transformed word must exist in the word list. Note that beginWord is not a transformed word.