【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{{"0", "0"}, {"1", "1"}, {"6", "9"}, {"9", "6"}, {"8", "8"}};
        vector<string> res;
        if (n & 1) {
            vector<string> list = {"0", "1", "8"};
            for (int i = 0; i < 3; ++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[0] != '0' || s == "0") {
                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 0;
        }
        this->low = low, this->high = high;
        vector<string> start = {"", "1", "8", "0", "69", "96"};
        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 = 0; 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() > 1 && s[0] == '0' ) {
            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 = {{"6","9"}, {"9","6"}, {"8","8"}, {"1","1"}, {"0","0"}};
    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 = 0; i < n; ++i) {
            pairs[i] = to_string(i+1);
        }
        dfs(pairs);
        return pairs[0];
    }
    void dfs(vector<string>& pairs) {
        if (pairs.size() == 1) {return;}
        int start = 0, end = pairs.size() - 1;
        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 == 1) {return 1;}
        string s;
        dfs(a, s);
        return hasAns ? res : 0;
    }
    bool hasAns = false;
    int res = INT_MAX;
    void dfs(int a, string& s) {
        if (a == 1) {
            long long temp = stoll(s);
            if (s.size() <= 10 && temp <= INT_MAX) {
                hasAns = true;
                res = min(res, stoi(s));
            }
            return;
        }
        for (int i = 9; i > 1; --i) {
            if (a % i == 0 && s.size() + 1 <= to_string(res).size()) {
                s.push_back(i + '0');
                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 == 0) {return false;}
        int tot = 0;
        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, 0);
        return dfs(nums, visit, 0, 0, length, 0);
    }
    int size = 0, k = 0;
    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] = 1;
            bool res = false;
            if (curLen + nums[i] == target) { //如果当前这个子集的元素的和等于target，就去寻找下一个子集。
                res = dfs(nums, visit, 0, cnt + 1, target, 0);
            } else if (curLen + nums[i] < target) {
                res = dfs(nums, visit, curLen + nums[i], cnt, target, i + 1); //如果当前这个子集的元素的和小于target，就继续递归找当前子集的其他元素。
            }
            visit[i] = 0;
            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 == 1) {return 0;}
        int preNumber = kthGrammar(N-1, (K+1)/2);
        int res = -1;
        if (preNumber == 0) { //01
            res = K & 1 ? 0 : 1;
        } else if (preNumber == 1){ //10
            res = K & 1 ? 1 : 0;
        }
        return res;
    }
};

794 Valid Tic-Tac-Toe State

894 All Possible Full Binary Trees