【Leetcode周赛】从contest-81开始。（一般是10个contest写一篇文章）

Contest 81 （2018年11月8日，周四，凌晨）

链接：https://leetcode.com/contest/weekly-contest-81

比赛情况记录：结果：3/4， ranking: 440/2797。这次题目似乎比较简单，因为我比赛的时候前三题全做出来了（1:12:39），然后第四题有思路，正在写，没写完，比赛完了写完提交也对了。

【821】Shortest Distance to a Character（第一题 4分）

给了一个单词（字符串）s，和单词中的任意一个字母 c，问单词中的每个字母到 c 的最近距离是多少。 

Example 1：
Input: S = "loveleetcode", C = 'e'
Output: [3, 2, 1, 0, 1, 0, 0, 1, 2, 2, 1, 0]

题解：我是用了一个vector记录了所有字符 c 的下标，然后用遍历整个字符串，用一根指针辅助遍历 c 下标数组做的。时间复杂度 O(N)。写法不够优秀，c 的下标数组可以左边右边填一个元素，就不用写那么多判断了吧？

class Solution {
public:
    vector<int> shortestToChar(string S, char C) {
        const int n = S.size();
        vector<int> idxs;
        vector<int> ans(n, -1);
        for (int i = 0; i < n; ++i) {
            if (S[i] == C) {
                idxs.push_back(i);
                ans[i] = 0;
            }
        }
        int p1 = 0;
        for (int i = 0; i < n; ++i) {
            if (p1 == 0 && i < idxs[p1]) {
                ans[i] = idxs[p1] - i;
            } else if (p1 + 1 < idxs.size() && i >= idxs[p1] && i <= idxs[p1+1]) {
                ans[i] = min(abs(i - idxs[p1]), abs(idxs[p1+1] - i));
            } else if (p1 + 1 == idxs.size() && idxs[p1] < i) {
                ans[i] = i - idxs[p1];
            }
            if (p1 + 1 < idxs.size() && i == idxs[p1+1]) {
                ++p1;
            }
        }
        return ans;
    }
};

【822】Card Flipping Game （第二题 5分）

给了一排纸牌，纸牌前面和后面都有一个数字，我们可以做两个动作，第一个动作是任意翻动任意的纸牌正反面（形成新的正反面数组），第二个动作是我们拿一张纸牌，如果它反面的数字没有在正面的数组里面出现，那么这个数字就是good，要求返回最小 good 的数字。

题解：我是先把 front 和 back 数组合二为一，然后把大数组做了一个排序。然后遍历正反两面的数组，把正反面数字相同的纸牌上的数字放进了一个set里面，这些数字肯定不是 good 的，因为不论这些纸牌怎么翻，都是一个数字。然后我返回了大数组不在set里面的第一个元素。

class Solution {
public:
    int flipgame(vector<int>& fronts, vector<int>& backs) {
        const int n = fronts.size();
        int ans = 0;
        vector<int> tot(fronts);
        for (auto b : backs) {
            tot.push_back(b);
        }
        sort(tot.begin(), tot.end());
        set<int> st;
        for (int i = 0; i < n; ++i) {
            if (fronts[i] == backs[i]) {
                st.insert(fronts[i]);
            }
        }
        for (int i = 0; i < 2 * n; ++i) {
            if (st.find(tot[i]) == st.end()) {
                ans = tot[i];
                break;
            }
        }
        return ans;
    }
};

  

【820】Short Encoding of Words （第三题 6分）（尝试了一下翻译题目，不好翻译，直接贴原题了）

Given a list of words, we may encode it by writing a reference string S and a list of indexes A.

For example, if the list of words is ["time", "me", "bell"], we can write it as S = "time#bell#" and indexes = [0, 2, 5].

Then for each index, we will recover the word by reading from the reference string from that index until we reach a "#" character.

What is the length of the shortest reference string S possible that encodes the given words?

Example:
Input: words = ["time", "me", "bell"]
Output: 10
Explanation: S = "time#bell#" and indexes = [0, 2, 5].

Note:
1 <= words.length <= 2000.
1 <= words[i].length <= 7.
Each word has only lowercase letters.

题解：我一开始想的是把相同后缀的字符串用map分组，然鹅，代码写出来了但是超时。后来仔细想了一下，相同的后缀如果翻转一下字符串就能变成相同的前缀，然后按照字母序sort一下，就能逐条比较了。最后的时间复杂度降低成了O(nlogn)，（要排序的复杂度）

class Solution {
public:
    int minimumLengthEncoding(vector<string>& words) {
        const int n = words.size();
        vector<string> newWords(words);
        for (auto& w : newWords) {
            reverse(w.begin(), w.end());
        }
        sort(newWords.begin(), newWords.end());
        vector<string> temp;
        for (int i = 0; i < n-1; ++i) {
            string cur = newWords[i], ne = newWords[i+1];
            int curSize = cur.size(), neSize = ne.size();
            if (neSize < curSize || ne.substr(0, curSize) != cur) {
                temp.push_back(cur);
                continue;
            }
        }
        temp.push_back(newWords.back());
        int ans = 0;
        for (auto w : temp) {
            ans += (1 + w.size()); 
        }
        return ans;
        
    }
};

【823】Binary Trees With Factors （第四题 7 分）

 给了一个 unique 的数组 A，题目定义说二叉树的一个非叶子结点的值一定等于它左右儿子的乘积，问这个数组能组成多少种类的二叉树，数组中的元素可以用任意次。因为答案可能很大，所以需要模 1e9 + 7.

Example 1:
Input: A = [2, 4]
Output: 3
Explanation: We can make these trees: [2], [4], [4, 2, 2]

Example 2:
Input: A = [2, 4, 5, 10]
Output: 7
Explanation: We can make these trees: [2], [4], [5], [10], [4, 2, 2], [10, 2, 5], [10, 5, 2].

题解：我首先一个感觉就是应该先每个元素能表达成乘积形式的东西列出来。比如 4 -> (2, 2); 10 ->(2, 5), (5,2)。然后枚举每一个元素为根，然后我开始纠结了一下，难道要dfs吗？结果那么多，我估计dfs不是超时就是要挂。所以就往 dp 上面想。

dp[i] 表示以 A[i] 为根的二叉树的种类，如果 A[i] = A[x] * A[y]，那么dp[i] = dp[x] * dp[y]。dp[i] 初始化为 1， 因为这棵树可以选择没有孩子，只有它自己作为根。

然后就是 MOD 了。这种大数我就是容易写挂，不知道为啥，是不是还有什么原理没有摸透。唉。

class Solution {
public:
    const int MOD = 1e9 + 7;
    int numFactoredBinaryTrees(vector<int>& A) {
        int n = A.size();
        sort(A.begin(), A.end());
        map<int, vector<pair<int, int>>> mp, debugMap;
        for (int i = 1; i < n; ++i) {
            int p1 = 0, p2 = i - 1;
            while (p1 <= p2) {
                int mul = A[p1] * A[p2];
                if (A[i] == mul) {
                    debugMap[A[i]].push_back(make_pair(A[p1], A[p2]));
                    mp[i].push_back(make_pair(p1, p2));
                    if (A[p1] != A[p2]) {
                        debugMap[A[i]].push_back(make_pair(A[p2], A[p1]));
                        mp[i].push_back(make_pair(p2, p1));
                    }
                    p1++, p2--;
                } else if (A[i] > mul) {
                    ++p1;
                } else if (A[i] < mul) {
                    --p2;
                }
            }
        }
        vector<long long> dp(n, 1); //dp[i] 表示用 A[i] 为根的二叉树有几棵
        for (int i = 0; i < n; ++i) {
            //int root = A[i];
            if (mp.find(i) == mp.end()) {continue;}
            vector<pair<int, int>> vec = mp[i];
            for (auto p : vec) {
                int x = p.first, y = p.second;
                dp[i] = (dp[i] + dp[x] * dp[y]) % MOD;
            }
        }
        int ans = 0;
        for (auto e : dp) {
            ans = (ans + e) % MOD;
        }
        return ans;
    }
};

Contest 82 （2018年11月8日，周四）

链接：https://leetcode.com/contest/weekly-contest-82

比赛情况记录：结果：3/4， ranking：345/2564。这次四道题都不难，我比赛做出来三题，有个逻辑判断的题想了比较久， friends of appropriate ages，这个题推导了半天。第四题没空写了，结果第四题下午写WA了好几次。

Goat Latin（第一题 4分）

Friends Of Appropriate Ages（第二题 5分）（这题也要看答案）

Most Profit Assigning Work （第三题 7分）（感觉这题还能更快，要记得看答案）

Making A Large Island （第四题 8 分）

Contest 83 （2018年11月12日，周一）

链接：https://leetcode.com/contest/weekly-contest-83

比赛情况记录：比赛结果记录：2/4。 ranking：675/2688。好像这场是随便做了两题签到题就有事出去了orz。（11月21日才写log，有点忘记了orz）第三题我有印象，好像做了，然而超时啊啊啊啊啊。

【830】Positions of Large Groups （第一题 3分）

给了一个小写字母的字符串，每一段相同的字母叫做一个 group， 如果 group 的字母数量 大于等于 3个字符就叫做 large group。返回所有 large group 的开始和结束下标。

Input: "abcdddeeeeaabbbcd"
Output: [[3,5],[6,9],[12,14]]

题解：两根指针扫一遍。

class Solution {
public:
    vector<vector<int>> largeGroupPositions(string S) {
        const int n = S.size();
        vector<vector<int>> ans;
        int p1 = 0, p2 = 0;
        while (p2 < n) {
            while (p2 < n && S[p1] == S[p2]) {
                p2++;
            }
            if (p2 - p1 >= 3) {
                ans.push_back({p1, p2-1});
            }
            p1 = p2;
        }
        return ans;
    }
};

【831】Masking Personal Information （第二题 5分）

给了一个字符串，可能是 email address 也可能是 phone number。题目的意思要给这个字符串打码。

如果是 email 的字符串，它一定满足这个格式："name1@name2.name3"，给它 masking 的方法是 name1 只留首尾两个字母，其他的name保留原来格式，但是 所有的 name 都必须是小写字母。

如果是 phone number， 它可能有国家地区编码，也可能没有。一个 phone number 的长度是 10 - 13 个数字，最后 10个数字做 local number，前面可能有 1 - 3 个数字做 country-code。local number masking 之后要保留这个格式："***-***-DDDD"。

如果有 country-code 的话，country-code 前面的 ‘+’ 和后面的 ‘-’ 需要保留。

Example 1:
Input: "LeetCode@LeetCode.com"
Output: "l*****e@leetcode.com"
Explanation: All names are converted to lowercase, and the letters between the
             first and last letter of the first name is replaced by 5 asterisks.
             Therefore, "leetcode" -> "l*****e".

Example 2:
Input: "AB@qq.com"
Output: "a*****b@qq.com"
Explanation: There must be 5 asterisks between the first and last letter 
             of the first name "ab". Therefore, "ab" -> "a*****b".

Example 3:
Input: "1(234)567-890"
Output: "***-***-7890"
Explanation: 10 digits in the phone number, which means all digits make up the local number.

Example 4:
Input: "86-(10)12345678"
Output: "+**-***-***-5678"
Explanation: 12 digits, 2 digits for country code and 10 digits for local number. 

 题解：模拟题，读懂题意开始搞就行了。

class Solution {
public:
    string maskPII(string S) {
        const int n = S.size();
        if (S.find("@") != string::npos && S.find(".") != string::npos) {
            return copeEmail(S);
        }
        return copePhone(S);
    }
    string copeEmail(string S) {
        auto pos = S.find("@");
        string name1 = S.substr(0, pos);
        for (auto& p : name1) {
            if (isupper(p)) {
                p = tolower(p);
            }
        }
        string name2 = S.substr(pos);
        //printf("pos = %d, name1 = %s, name2 = %s 
", pos, name1.c_str(), name2.c_str());
        string newName1 = string(1, name1.front()) + "*****" + string(1, name1.back());
        for (auto& p : name2) {
            if (isupper(p)) {
                p = tolower(p);
            }
        }
        S = newName1 + name2;
        return S;
    }
    string copePhone(string S) {
        string newS = "";
        for (auto p : S) {
            if (isdigit(p)) {
                newS += p;
            }
        }
        const int n = newS.size();
        if (n < 10) {cout << "err" << endl;}
        if (n == 10) {
            S = "***-***-" + newS.substr(n-4);
        } else {
            int countryCodeNum = n  - 10;
            string countryCode(countryCodeNum, '*');
            S = "+" + countryCode + "-" +  "***-***-" + newS.substr(n-4);
        }
        return S;
    }
};

【829】Consecutive Numbers Sum（第三题 7分）

 给了一个数字 N，返回它有几种拆法能把它表示成一段连续的自然数相加。

Example 1:
Input: 5
Output: 2
Explanation: 5 = 5 = 2 + 3
Example 2:
Input: 9
Output: 3
Explanation: 9 = 9 = 4 + 5 = 2 + 3 + 4
Example 3:
Input: 15
Output: 4
Explanation: 15 = 15 = 8 + 7 = 4 + 5 + 6 = 1 + 2 + 3 + 4 + 5
Note: 1 <= N <= 10 ^ 9.

题解：我好像在哪个地方见过这个题，然而解法超时。解法就是用 两个变量 small 和 big，一开始他们两个都是 1， 如果现在的 [small, big] 区间和 summ 小于 N，就 ++big，这样 summ 就会变大。如果现在的 [small, big] 区间和 summ 大于 N，就 ++small， 这样 summ 就会减小。这个是超时解法，时间复杂度应该是 O(N)。（吐了）

【828】Unique Letter String（第四题 9分）

这题我看了应该也不是很难。估计我会解。 

Contest 84 （2018年11月21日，周三）

链接：https://leetcode.com/contest/weekly-contest-84

比赛情况记录：第三题算法群前两天才出过，所以迅速的用了25分钟AC了三题。结果： 3/4，ranking：104/2421。第四题我用 bfs 和 floyed 都超时了。唉。

【832】Flipping an Image（第一题 3分）

给了一个 0/1 矩阵，按照题意先把每行前后翻转，然后把 0 变成 1，1 变成 0。返回新矩阵。

题解：按照题意解。

class Solution {
public:
    vector<vector<int>> flipAndInvertImage(vector<vector<int>>& A) {
        const int n = A.size();
        for (auto& row : A) {
            reverse(row.begin(), row.end());
            for (auto& ele : row) {
                ele = 1 - ele;
            }
        }
        return A;
    }
};

【833】Find And Replace in String（第二题 4分）

给了一个字符串 S，一个下标数组 indexes， 一个原字符串数组 sources， 一个目标字符串数组 targets。如果在 S 中 indexes[i] 开始的子串是 sources[i]，就把它替换成 targets[i] （sources[i] 和 target[i] 不是同一个长度）。如果不是那就不用替换。然后题目设定所有的替换都是同时发生的，也就是不存在先把前面替换之后因为 sources[i] 和targets[i] 的长度不同而导致错位什么的。

题解：我是先用了一个 map 存储了可以替换的字符串 S 的下标和对应数组的下标 i。 map<int, int, greater<int>> mp; //idx -> i (pos in sources and targets) 。然后用 greater<int> 使得 map 从大到小排序 key。然后从后往前替换字符串。replace

class Solution {
public:
    string findReplaceString(string S, vector<int>& indexes, vector<string>& sources, vector<string>& targets) {
        const int n = S.size();
        string ret = S;
        map<int, int, greater<int>> mp; //idx -> i (pos in sources and targets) 
        for (int i = 0; i < indexes.size(); ++i) {
            string src = sources[i];
            int idx = indexes[i];
            if (n - i < src.size()) {continue;}
            bool check = true;
            for (int k = 0; k < src.size(); ++k) {
                if (S[idx+k] != src[k]) {
                    check = false;
                    break;
                }
            }
            if (check) {
                mp[idx] = i;
            }
        }
        for (auto p : mp) {
            int idx = p.first, k = p.second;
            string src = sources[k], dest = targets[k];
            ret.replace(idx, (int)src.size(), dest);
        }
        return ret;
    }
};

 【835】Image Overlap（第三题 6分）（前两天才在算法群里做完这个题目，所以巨快的做完了orz）

给了两个 0/1 矩阵 A, B（长和宽都是 N）, 我们可以上下左右四个方向移动一个矩阵，使得它和另外一个矩阵覆盖，这样的话，每次移动不同的方向和偏移量都会有重叠的 1 的个数。问最多的重叠的 1 的个数是多少。

题解：暴力解， O(N ^4)。先枚举偏移量 O(N^2)，再枚举 一个矩阵的位置 O(N^2)。根据这两个东西计算另外一个矩阵的位置。判断累加计算。

class Solution {
public:
    int largestOverlap(vector<vector<int>>& A, vector<vector<int>>& B) {
        n = A.size();
        return max(helper(A, B), helper(B, A));
    }
    int n = 0;
    int helper(const vector<vector<int>>& A, const vector<vector<int>>& B) {
        int res = 0;
        for (int offsetX = 0; offsetX < n; ++offsetX) {
            for (int offsetY = 0; offsetY < n; ++offsetY) {
                int cnt = 0;
                for (int i = offsetX; i < n; ++i) {
                    for (int j = offsetY; j < n; ++j) {
                        if (A[i][j] && B[i-offsetX][j-offsetY]) {
                            cnt++;
                        }
                    }
                }
                res = max(res, cnt);
            }
        }
        return res;
    }
};

discuss里面有 O(N^2) 的解法。然而不一定比这个快，orz

【834】Sum of Distances in Tree（第四题 9分）

给了一个无向的树，有 N 个结点， N-1 条边，要求返回一个 ans list，list 里面记录了每一个结点 i 和其他所有结点的距离之和。

Example 1:
Input: N = 6, edges = [[0,1],[0,2],[2,3],[2,4],[2,5]]
Output: [8,12,6,10,10,10]
Explanation: 
Here is a diagram of the given tree:
  0
 / 
1   2
   /|
  3 4 5
We can see that dist(0,1) + dist(0,2) + dist(0,3) + dist(0,4) + dist(0,5)
equals 1 + 1 + 2 + 2 + 2 = 8.  Hence, answer[0] = 8, and so on.
Note: 1 <= N <= 10000

题解：N 最大可以取到 10000， 我还用了 floyed 或者 bfs 也许就是作死吧。但是根本想不到更快的方法啊orz。

Contest 85 （还没做，待定）

Contest 86 （2018年11月21日，周三）

链接：https://leetcode.com/contest/weekly-contest-86

比赛情况记录：结果：3/4，ranking：326/2323。第三题 backtracking 找斐波那契数列调试了好久。第四题没看。orz

【840】Magic Squares In Grid（第一题 3分）

【841】Keys and Rooms（第二题 5分）

【842】Split Array into Fibonacci Sequence（第三题 6分）

【843】Guess the Word（第四题 8分）