【LeetCode】Recursion（共11题）

链接：https://leetcode.com/tag/recursion/

247 Strobogrammatic Number II (2019年2月22日，谷歌tag)

给了一个 n，给出长度为 n 的所有上下颠倒 180度以后都看起来一样的数字字符串。

题解：dfs，回溯。注意所有的能有pair的序列是 0， 1， 8， 6， 9

 class Solution {
 public:
     vector<string> findStrobogrammatic(int n) {
         vector<pair<string, string>> digits{{"", ""}, {"", ""}, {"", ""}, {"", ""}, {"", ""}};
         vector<string> res;
         if (n & ) {
             vector<string> list = {"", "", ""};
             for (int i = ; i < ; ++i) {
                 string s = list[i];
                 dfs(res, s, digits, n);
             }
         } else {
             string s = "";
             dfs(res, s, digits, n);
         }
         return res;
     }
     void dfs(vector<string>& res, string& s, vector<pair<string, string>>& digits, const int n) {
         if (s.size() == n) {
             if (s[] != '' || s == "") {
                 res.push_back(s);
             }
             return;
         }
         for (auto& p : digits) {
             string s1 = p.first, s2 = p.second;
             string oriS = s;
             s = s1 + s + s2;
             dfs(res, s, digits, n);
             s = oriS;
         }
     }
 };

248 Strobogrammatic Number III （2019年1月17日，谷歌高频）

给了两个字符串一个low，一个high，找出 low 和 high 之间所有的 strobogrammatic number 的数量。strobogrammatic number 是说一个数字上下颠倒180度之后看起来一样

题解：找出所有上下颠倒看起来一样的数字。有 0， 1， 8， 69， 和 96， 我们可以用这些number做recursion。每次在两边加上这些数字。就能生成一个上下颠倒后看起来一样的数。

 class Solution {
 public:
     int strobogrammaticInRange(string low, string high) {
         if (low.size() > high.size() || low.size() == high.size() && low > high) {
             return ;
         }
         this->low = low, this->high = high;
         vector<string> start = {"", "", "", "", "", ""};
         for (auto s : start) {
             dfs(s);
         }
         return ret.size();
     }
     void dfs(string s) {
         if (check(s)) {
             ret.insert(s);
         }
         if (s.size() <= high.size()) {
             for (int i = ; i < model.size(); ++i) {
                 string pre = model[i].first, suff = model[i].second;
                 dfs(pre + s + suff);
             }
         }
         if (s > high) {
             return;
         }
     }
     bool check(string s) {
         if (s.empty() || s.size() >  && s[] == '' ) {
             return false;
         }
         if (low.size() == high.size()) {
             return s.size() == low.size() && s >= low && s <= high;
         } else {
             if (s.size() > low.size() && s.size() < high.size()) {
                 return true;
             } else if (s.size() == low.size()) {
                 return s >= low;
             } else if (s.size() == high.size()) {
                 return s <= high;
             }
             return false;
         }
         return false;
     }
     set<string> ret;
     vector<pair<string, string>> model = {{"",""}, {"",""}, {"",""}, {"",""}, {"",""}};
     string low, high;
 };

544 Output Contest Matches（2019年2月22日，谷歌tag）

给定一个 n，假设 n 只队伍比赛（n是2的幂），我们每次安排比赛要把最强的队伍和最弱的队伍安排在一起。给出最后比赛的排列字符串。

Input: 8
Output: (((1,8),(4,5)),((2,7),(3,6)))
Explanation:
First round: (1,8),(2,7),(3,6),(4,5)
Second round: ((1,8),(4,5)),((2,7),(3,6))
Third round: (((1,8),(4,5)),((2,7),(3,6)))
Since the third round will generate the final winner, you need to output the answer (((1,8),(4,5)),((2,7),(3,6))).

题解：本题看起来比较复杂，但是其实仔细研究一下，我们只需要把所有team的编号放在一个数组里面，把第一个和最后一个组队形成pair，第二个和倒数第二个组队形成pair，生成新的数组，然后调用dfs递归生成即可。

 class Solution {
 public:
     string findContestMatch(int n) {
         vector<string> pairs(n);
         for (int i = ; i < n; ++i) {
             pairs[i] = to_string(i+);
         }
         dfs(pairs);
         return pairs[];
     }
     void dfs(vector<string>& pairs) {
         if (pairs.size() == ) {return;}
         int start = , end = pairs.size() - ;
         vector<string> newPairs;
         while (start < end) {
             string str = "(" + pairs[start++] + "," + pairs[end--] + ")";
             newPairs.push_back(str);
         }
         pairs = newPairs;
         dfs(pairs);
     }
 };

625 Minimum Factorization（2019年2月22日）

给了一个正整数a，返回一个最小的正整数b，b中所有数位的乘积等于a。

题解：dfs，backtracking. 很慢，本题可以数学方法。

 class Solution {
 public:
     int smallestFactorization(int a) {
         if (a == ) {return ;}
         string s;
         dfs(a, s);
         return hasAns ? res : ;
     }
     bool hasAns = false;
     int res = INT_MAX;
     void dfs(int a, string& s) {
         if (a == ) {
             long long temp = stoll(s);
             if (s.size() <=  && temp <= INT_MAX) {
                 hasAns = true;
                 res = min(res, stoi(s));
             }
             return;
         }
         for (int i = ; i > ; --i) {
             if (a % i ==  && s.size() +  <= to_string(res).size()) {
                 s.push_back(i + '');
                 dfs(a/i, s);
                 s.pop_back();
             }
         }
     }
 };

687 Longest Univalue Path

698 Partition to K Equal Sum Subsets （2019年2月24日，谷歌tag）

本题和 544 Output Contest Matches 拼火柴棍的这个题非常类似。基本一模一样。

给了一个数组nums，一个k，问这个数组能不能划分成 k 个总和大小相等的子集。每个数组元素只能用一次，并且必须用掉。

题解：dfs。

 class Solution {
 public:
     bool canPartitionKSubsets(vector<int>& nums, int k) {
         this->k = k;
         size = nums.size();
         if (size == ) {return false;}
         int tot = ;
         sort(nums.begin(), nums.end(), greater<int>());  //从大到小排列
         for (auto& num : nums) {
             tot += num;
         }
         if (tot % k) {return false;}
         const int length = tot / k;
         vector<int> visit(size, );
         return dfs(nums, visit, , , length, );
     }
     int size = , k = ;
     bool dfs(const vector<int>& nums, vector<int>& visit, int curLen, int cnt, const int target, int start) {
         if (cnt == k) {return true;}
         for (int i = start; i < size; ++i) {
             if (visit[i]) {continue;}
             if (curLen + nums[i] > target) {continue;}
             visit[i] = ;
             bool res = false;
             if (curLen + nums[i] == target) { //如果当前这个子集的元素的和等于target，就去寻找下一个子集。
                 res = dfs(nums, visit, , cnt + , target, );
             } else if (curLen + nums[i] < target) {
                 res = dfs(nums, visit, curLen + nums[i], cnt, target, i + ); //如果当前这个子集的元素的和小于target，就继续递归找当前子集的其他元素。
             }
             visit[i] = ;
             if (res) {
                 return res;
             }
         }
         return false;
     }
 };

726 Number of Atoms

761 Special Binary String

779 K-th Symbol in Grammar（2019年2月22日，谷歌tag）（和群主mock的那题非常相似。）

当 N = 1 的时候，字符串为 “0”，每当 N 递增1，就把上一个字符串的 “0” 变成 “01”， 把上一个字符串的“1”变成“10”。返回第N个字符串的第K个字符。

题解：我们这题用递归解。我们先求出当前字符串的第 K 个字符是由前一个字符串的字符是 0 还是 1 生成的，然后根据前一个字符，做一点逻辑判断，判断出当前字符是 0 还是 1。

 class Solution {
 public:
     int kthGrammar(int N, int K) {
         if (N == ) {return ;}
         int preNumber = kthGrammar(N-, (K+)/);
         int res = -;
         if (preNumber == ) { //
             res = K &  ?  : ;
         } else if (preNumber == ){ //
             res = K &  ?  : ;
         }
         return res;
     }
 };

794 Valid Tic-Tac-Toe State

894 All Possible Full Binary Trees