重构, bugfix

Author: soulmachine

C++/LeetCodet题解(C++版).pdf

@@ -43,37 +43,50 @@ \subsubsection{代码}
 //LeetCode, Word Ladder
 class Solution {
 public:
-    int ladderLength(string start, string end, unordered_set<string> &dict) {
+    typedef string state_t;
+    int ladderLength(string start, string end,
+            const unordered_set<string> &dict) {
         if (start.size() != end.size()) return 0;
-        if (start.empty() || end.empty()) return 1; return 0;
-        int level = 1;  // 层次
-        queue<string> queToPush, queToPop;
-
-        queToPop.push(start);
-        while (dict.size() > 0 && !queToPop.empty()) {
-            while (!queToPop.empty()) {
-                string str(queToPop.front());
-                queToPop.pop();
-                for (int i = 0; i < str.size(); i++) {
-                    for (char j = 'a'; j <= 'z'; j++) {
-                        if (j == str[i]) continue;
-
-                        const char temp = str[i];
-                        str[i] = j;
-                        if (str == end) return level + 1; //找到了
-
-                        if (dict.count(str) > 0) {
-                            queToPush.push(str);
-                            dict.erase(str); // 删除该单词，防止死循环
+        if (start.empty() || end.empty()) return 0;
+
+        queue<string> next, current; // 当前层，下一层
+        unordered_set<string> visited; // 判重
+        unordered_map<string, string > father;
+        int level = 0;  // 层次
+        bool found = false;
+
+        current.push(start);
+        while (!current.empty() && !found) {
+            ++level;
+            while (!current.empty() && !found) {
+                const string str(current.front()); current.pop();
+
+                for (size_t i = 0; i < str.size(); ++i) {
+                    string new_word(str);
+                    for (char c = 'a'; c <= 'z'; c++) {
+                        if (c == new_word[i]) continue;
+
+                        swap(c, new_word[i]);
+                        if (new_word == end) {
+                            found = true; //找到了
+                            father[new_word] = str;
+                            break;
                         }
-                        str[i] = temp; // 恢复该单词
+
+                        if (dict.count(new_word) > 0
+                                && !visited.count(new_word)) {
+                            next.push(new_word);
+                            visited.insert(new_word);
+                            father[new_word] = str;
+                        }
+                        swap(c, new_word[i]); // 恢复该单词
                     }
                 }
             }
-            swap(queToPush, queToPop); //!!! 交换两个队列
-            level++;
+            swap(next, current); //!!! 交换两个队列
         }
-        return 0; // 所有单词已经用光，还是找不到通向目标单词的路径
+        if (found) return level+1;
+        else return 0;
     }
 };
 \end{Code}
@@ -119,90 +132,80 @@ \subsubsection{描述}
 
 
 \subsubsection{分析}
-跟 Word Ladder比，这题是求路径本身，不是路径长度，也是BFS，略微麻烦点
+跟 Word Ladder比，这题是求路径本身，不是路径长度，也是BFS，略微麻烦点。
+
+这题跟普通的广搜有很大的不同，就是要输出所有路径，因此在记录前驱和判重地方与普通广搜略有不同。
 
 
 \subsubsection{代码}
 
 \begin{Code}
 //LeetCode, Word Ladder II
-//跟 Word Ladder比，这题是求路径本身，不是路径长度，也是BFS，略微麻烦点
 class Solution {
 public:
-    std::vector<std::vector<std::string> > findLadders(std::string start,
-            std::string end, std::unordered_set<std::string> &dict) {
-        result_.clear();
-        std::unordered_map<std::string, std::vector<std::string>> prevMap;
-
-        for (auto iter = dict.begin(); iter != dict.end(); ++iter) {
-            prevMap[*iter] = std::vector<std::string>();
-        }
-
-        std::vector<std::unordered_set<std::string>> candidates(2);
-
-        int current = 0;
-        int previous = 1;
-
-        candidates[current].insert(start);
-
-        while (true) {
-            current = !current;
-            previous = !previous;
-
-            // 从dict中删除previous中的单词，避免自己指向自己
-            for (auto iter = candidates[previous].begin();
-                    iter != candidates[previous].end(); ++iter) {
-                dict.erase(*iter);
-            }
-
-            candidates[current].clear();
-
-            for (auto iter = candidates[previous].begin();
-                    iter != candidates[previous].end(); ++iter) {
-                for (size_t pos = 0; pos < iter->size(); ++pos) {
-                    std::string word = *iter;
-                    for (int i = 'a'; i <= 'z'; ++i) {
-                        if (word[pos] == i) continue;
-
-                        word[pos] = i;
-
-                        if (dict.count(word) > 0) {
-                            prevMap[word].push_back(*iter);
-                            candidates[current].insert(word);
+    vector<vector<string> > findLadders(string start, string end,
+            const unordered_set<string> &dict) {
+        unordered_set<string> visited; // 判重
+        unordered_map<string, vector<string> > father; // 树
+        unordered_set<string> current, next;  // 当前层，下一层，用集合是为了去重
+
+        int level = 0; // 层数
+        bool found = false;
+
+        current.insert(start);
+        while (!current.empty() && !found) {
+            ++level;
+            // 先将本层全部置为已访问，防止同层之间互相指向
+            for (auto iter = current.begin(); iter != current.end(); ++iter)
+                visited.insert(*iter);
+            for (auto iter = current.begin(); iter != current.end(); ++iter) {
+            //while (!current.empty()) {
+                const string word = *iter;
+
+                for (size_t i = 0; i < word.size(); ++i) {
+                    string new_word = word;
+                    for (char c = 'a'; c <= 'z'; ++c) {
+                        if (c == new_word[i]) continue;
+                        swap(c, new_word[i]);
+
+                        if (new_word == end) found = true; //找到了
+
+                        if (visited.count(new_word) == 0
+                                && (dict.count(new_word) > 0 ||
+                                        new_word == end)) {
+                            next.insert(new_word);
+                            father[new_word].push_back(word);
+                            // visited.insert(new_word)移动到最上面了
                         }
+
+                        swap(c, new_word[i]);  // restore
                     }
                 }
             }
 
-            if (candidates[current].size() == 0) return result_;  // 此题无解
-            if (candidates[current].count(end)) break; // 没看懂
+            current.clear();
+            swap(current, next);
         }
-
-        std::vector<std::string> path;
-        GeneratePath(prevMap, path, end);
-
-        return result_;
+        vector<vector<string> > result;
+        if (found) {
+            vector<string> path;
+            buildPath(father, path, start, end, result);
+        }
+        return result;
     }
-
 private:
-    std::vector<std::vector<std::string>> result_;
-
-    void GeneratePath(
-            std::unordered_map<std::string, std::vector<std::string>> &prevMap,
-            std::vector<std::string>& path, const std::string& word) {
-        if (prevMap[word].size() == 0) {
-            path.push_back(word);
-            std::vector<std::string> curPath = path;
-            reverse(curPath.begin(), curPath.end());
-            result_.push_back(curPath);
-            path.pop_back();
-            return;
-        }
-
+    void buildPath(unordered_map<string, vector<string> > &father,
+            vector<string> &path, const string &start, const string &word,
+            vector<vector<string> > &result) {
         path.push_back(word);
-        for (auto iter = prevMap[word].begin(); iter != prevMap[word].end();
-                ++iter) {
-            GeneratePath(prevMap, path, *iter);
+        if (word == start) {
+            result.push_back(path);
+            reverse(result.back().begin(), result.back().end());
+        } else {
+            for (auto iter = father[word].begin(); iter != father[word].end();
+                    ++iter) {
+                buildPath(father, path, start, *iter, result);
+            }
         }
         path.pop_back();
     }

C++/chapBFS.tex

@@ -116,7 +116,7 @@ \subsection{二进制法}
 \subsubsection{代码}
 \begin{Code}
 // LeetCode, Subsets
-// 二进制法，也可以看做是位向量法，只不过更加优化
+// 二进制法
 class Solution {
 public:
     vector<vector<int> > subsets(vector<int> &S) {
@@ -176,6 +176,58 @@ \subsubsection{分析}
 \subsubsection{代码}
 \begin{Code}
 // LeetCode, Subsets II
+// 增量构造法
+class Solution {
+public:
+    vector<vector<int> > subsetsWithDup(vector<int> &S) {
+        vector<vector<int> > result;
+        std::sort(S.begin(), S.end()); // 本题对顺序有要求，需要排序
+
+        unordered_map<int, int> count_map; // 记录每个元素的出现次数
+        std::for_each(S.begin(), S.end(), [&count_map](int e) {
+            if (count_map.find(e) != count_map.end())
+                count_map[e]++;
+            else
+                count_map[e] = 1;
+        });
+
+        // 将map里的pair拷贝到一个vector里
+        std::vector<pair<int, int> > elems;
+        std::for_each(count_map.begin(), count_map.end(),
+                [&elems](const pair<int, int> &e) {
+                    elems.push_back(e);
+                });
+        std::sort(elems.begin(), elems.end());
+        std::vector<int> path; // 中间结果
+
+        subsets(elems, 0, path, result);
+        return result;
+    }
+
+private:
+    static void subsets(const std::vector<pair<int, int> > &elems,
+            size_t step, vector<int> &path, vector<vector<int> > &result) {
+        if (step == elems.size()) {
+            result.push_back(path);
+            return;
+        }
+
+        for (int i = 0; i <= elems[step].second; i++) {
+            for (int j = 0; j < i; ++j) {
+                path.push_back(elems[step].first);
+            }
+            subsets(elems, step + 1, path, result);
+            for (int j = 0; j < i; ++j) {
+                path.pop_back();
+            }
+        }
+    }
+};
+\end{Code}
+
+\begin{Code}
+// LeetCode, Subsets II
+// 位向量法
 class Solution {
 public:
     vector<vector<int> > subsetsWithDup(vector<int> &S) {
@@ -300,9 +352,9 @@ \subsubsection{代码}
 
         // Scan from right to left, find the first element that is greater than
         // `pivot`.
-        auto pos = find_if(rfirst, pivot, bind1st(less<int>(), *pivot));
+        auto change = find_if(rfirst, pivot, bind1st(less<int>(), *pivot));
 
-        swap(*pos, *pivot);
+        swap(*change, *pivot);
         reverse(rfirst, pivot);
 
         return true;
@@ -415,15 +467,17 @@ \subsubsection{代码}
         vector<vector<int>> result; // 最终结果
         vector<int> p;  // 中间结果
 
-        permute(num.size(), elems.begin(), elems.end(), 0, p, result);
+        n = num.size();
+        permute(elems.begin(), elems.end(), p, result);
         return result;
     }
 
 private:
+    size_t n;
     typedef std::vector<pair<int, int> >::const_iterator Iter;
 
-    void permute(const size_t n, Iter first, Iter last,
-            vector<int> &p, vector<vector<int> > &result) {
+    void permute(Iter first, Iter last, vector<int> &p,
+            vector<vector<int> > &result) {
         if (n == p.size()) {  // 收敛条件
             result.push_back(p);
         }
@@ -438,7 +492,7 @@ \subsubsection{代码}
             }
             if (count < i->second) {
                 p.push_back(i->first);
-                permute(n, first, last, p, result);
+                permute(first, last, p, result);
                 p.pop_back(); // 撤销动作，返回上一层
             }
         }

C++/chapBruteforce.tex

@@ -109,10 +109,10 @@ \subsubsection{代码}
     int m, n;
 
     int uniquePathsRecursive(int x, int y) {
-        if (x < 1 or x > m) return 0; // 数据非法
-        if (y < 1 or y > n) return 0;
+        if (x < 1 || x > m) return 0; // 数据非法
+        if (y < 1 || y > n) return 0;
 
-        if (x == 1 and y == 1) return 1; // 终止条件
+        if (x == 1 && y == 1) return 1; // 终止条件
 
         return uniquePathsRecursive(x - 1, y) + uniquePathsRecursive(x, y - 1);
     }
@@ -141,10 +141,10 @@ \subsubsection{代码}
     vector<vector<int> > f;  // 缓存
 
     int uniquePathsRecursive(int x, int y) {
-        if (x < 1 or x > m) return 0; // 数据非法，终止条件
-        if (y < 1 or y > n) return 0;
+        if (x < 1 || x > m) return 0; // 数据非法，终止条件
+        if (y < 1 || y > n) return 0;
 
-        if (x == 1 and y == 1) return 1; // 回到起点，收敛条件
+        if (x == 1 && y == 1) return 1; // 回到起点，收敛条件
 
         return cachedUniquePathsRecursive(x - 1, y) +
                 cachedUniquePathsRecursive(x, y - 1);
@@ -279,8 +279,8 @@ \subsubsection{代码}
 
     int uniquePathsRecursive(const vector<vector<int> > &obstacleGrid,
             int x, int y) {
-        if (x < 1 or x > obstacleGrid.size()) return 0; // 数据非法，终止条件
-        if (y < 1 or y > obstacleGrid[0].size()) return 0;
+        if (x < 1 || x > obstacleGrid.size()) return 0; // 数据非法，终止条件
+        if (y < 1 || y > obstacleGrid[0].size()) return 0;
 
         // (x,y)是障碍
         if (obstacleGrid[x-1][y-1]) return 0;