【Leetcode周賽】從contest-121開始。（通常是10個contest寫一篇文章）

時間 2019-11-18

標籤 Leetcode周賽 contest 開始通常一篇文章简体版

原文原文鏈接

Contest 121 （題號981～984）（2019年1月27日）

連接：https://leetcode.com/contest/weekly-contest-121node

總結：2019年2月22日補充的報告。當時不想寫。rank：1093/3924，AC：2/4。仍是太慢了。數組

【984】String Without AAA or BBB（第一題 4分）（Greedy， M）ide

給了兩個數字，A 表明 A 個 ‘A’， B 表明 B 個‘B’ 在字符串裏面。返回一個可行的字符串，字符串中包含 A 個‘A’， B 個 ‘B’，可是沒有連續的 'AAA' 或者 'BBB'。google

題解：當時寫的很長。如今說下greedy的方法，咱們每次只想着只放一個a或者一個b，而後若是當前字符串的長度大於等於2，就須要判斷前面是否是有兩個連續的a或者連續的b。若是有的話，那麼當前確定不能放a或者放b。spa

 1 class Solution {
 2 public:
 3     string strWithout3a3b(int A, int B) {
 4         string res;
 5         while (A > 0 || B > 0) {
 6             if (res.size() >= 2) {
 7                 int size = res.size();
 8                 if (res[size-1] == 'a' && res[size-2] == 'a') {
 9                     res += "b"; --B;
10                 } else if (res[size-1] == 'b' && res[size-2] == 'b') {
11                     res += "a"; --A;
12                 } else if (A >= B) {
13                     res += "a"; --A;
14                 } else {
15                     res += "b"; --B;
16                 }
17             } else {
18                 if (A >= B) {
19                     res += "a"; --A;
20                 } else {
21                     res += "b"; --B;
22                 }
23             }
24         }
25         return res;
26     }
27 };

View Code

【981】Time Based Key-Value Store（第二題 5分）3d

【983】Minimum Cost For Tickets（第三題 5分）（DP）指針

某個旅遊景點有日票，周票和月票三種類型的票價。給了一個array，表明一年中的第幾天去景點，問遍歷完這個數組最少須要多少花費。code

Train tickets are sold in 3 different ways:blog

a 1-day pass is sold for costs[0] dollars;
a 7-day pass is sold for costs[1] dollars;
a 30-day pass is sold for costs[2] dollars.

Input: days = [1,4,6,7,8,20], costs = [2,7,15] Output: 11 Explanation: For example, here is one way to buy passes that lets you travel your travel plan: On day 1, you bought a 1-day pass for costs[0] = $2, which covered day 1. On day 3, you bought a 7-day pass for costs[1] = $7, which covered days 3, 4, ..., 9. On day 20, you bought a 1-day pass for costs[0] = $2, which covered day 20. In total you spent $11 and covered all the days of your travel.

題解：動態規劃，dp[i] 表明前 i 天的最小花費。轉移方程：排序

若是第 i 天不在訪問的列表裏面： dp[i] = dp[i-1]

else: dp[i] = min(dp[i-1] + cost[0], dp[i-7] + cost[1] + dp[i-30] + cost[2])　　

時間複雜度是： O(N)

 1 class Solution {
 2 public:
 3     //dp[i] represents minimum money need cost in first i days
 4     int mincostTickets(vector<int>& days, vector<int>& costs) {
 5         const int totDays = 400;
 6         vector<int> dp(totDays, INT_MAX); 
 7         dp[0] = 0;
 8         set<int> st(days.begin(), days.end());
 9         for (int i = 1; i < totDays; ++i) {
10             if (st.find(i) == st.end()) {
11                 dp[i] = dp[i-1];
12                 continue;
13             }
14             dp[i] = dp[i-1] + costs[0];
15             dp[i] = min(dp[i], dp[max(i-7, 0)] + costs[1]);
16             dp[i] = min(dp[i], dp[max(i-30, 0)] + costs[2]);
17         }
18         return dp[366];
19     }
20 };

View Code

【982】Triples with Bitwise AND Equal To Zero（第四題 7分）

Contest 122（題號985～988）（2019年2月3日，新春大禮包）

連接：https://leetcode.com/contest/weekly-contest-122

總結：這周題目很是簡單，四題都過了。

【985】Sum of Even Numbers After Queries（第一題 4分）

給了一個數組，以及一個修改的序列。序列中的一個 pair 表明 p[0] 表明在原來數字上加上的值 val , p[1] 表明數組中須要修改元素的下標。求每次修改以後整個數組的偶數的和。

數據規模：

1 <= A.length <= 10000
-10000 <= A[i] <= 10000
1 <= queries.length <= 10000
-10000 <= queries[i][0] <= 10000
0 <= queries[i][1] < A.length

題解：用一個變量curSum存儲當前數組偶數的和，而後每次執行一個query以後，看當前元素是奇數變成偶數，仍是偶數變成奇數，仍是偶數變成偶數。來作不一樣的處理。

 1 class Solution {
 2 public:
 3     vector<int> sumEvenAfterQueries(vector<int>& A, vector<vector<int>>& queries) {
 4         const int n = A.size(), m = queries.size();
 5         vector<int> ret;
 6         int curSum = 0;
 7         for (auto num : A) {
 8             if ((num & 1) == 0) {
 9                 curSum += num;
10             }
11         }
12         for (auto q : queries) {
13             int val = q[0], idx = q[1];
14             int oriVal = A[idx];
15             int newVal = oriVal + val;
16             if ((oriVal & 1) == 0) {
17                 if (newVal & 1) {
18                     curSum -= oriVal;
19                 } else {
20                     curSum += val;
21                 }
22             } else {
23                 if ((newVal & 1) == 0) {
24                     curSum += newVal;
25                 }
26             }
27             ret.push_back(curSum);
28             A[idx] = newVal;
29         }
30         return ret;
31     }
32 };

View Code

【988】Smallest String Starting From Leaf（第二題 5分）

給了一棵二叉樹，樹上的每一個結點表明一個字母（0-25），問從葉子結點開始到根節點的字典序最小的單詞是哪一個？

題解：dfs 這顆樹，把全部單詞找出來。而後排序。注意這個題要求是從葉子結點開始，若是一個結點只有一個兒子，那麼它自己不能算葉子結點，從它開始的單詞要忽略掉。

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 class Solution {
11 public:
12     string smallestFromLeaf(TreeNode* root) {
13         vector<string> words;
14         string str;
15         if (!root) {
16             return "";
17         }
18         dfs(root, words, str);
19         sort(words.begin(), words.end());
20         return words[0];
21     }
22     void dfs(TreeNode* root, vector<string>& words, string& str) {
23         if (!root) { return; }
24         char c = root->val + 'a';
25         str += string(1, c);
26         if (!root->left && !root->right) {
27             reverse(str.begin(), str.end());
28             words.push_back(str);
29             reverse(str.begin(), str.end());
30             str.pop_back();
31             return;
32         }
33         if (root->left) {
34             dfs(root->left, words, str);
35         }
36         if (root->right) {
37             dfs(root->right, words, str);
38         }
39         str.pop_back();
40         return;
41     }
42 };

View Code

【986】Interval List Intersections（第三題 5分）

給了兩組左閉右閉的線段，返回這兩組線段的交集。

Input: A = [[0,2],[5,10],[13,23],[24,25]], B = [[1,5],[8,12],[15,24],[25,26]] Output: [[1,2],[5,5],[8,10],[15,23],[24,24],[25,25]] Reminder: The inputs and the desired output are lists of Interval objects, and not arrays or lists.

題解：2 pointers 掃描一遍。

 1 /**
 2  * Definition for an interval.
 3  * struct Interval {
 4  *     int start;
 5  *     int end;
 6  *     Interval() : start(0), end(0) {}
 7  *     Interval(int s, int e) : start(s), end(e) {}
 8  * };
 9  */
10 class Solution {
11 public:
12     vector<Interval> intervalIntersection(vector<Interval>& A, vector<Interval>& B) {
13         const int size1 = A.size(), size2 = B.size();
14         int p1 = 0, p2 = 0;
15         vector<Interval> ret;
16         while (p1 < size1 && p2 < size2) {
17             Interval seg1 = A[p1], seg2 = B[p2];
18             int s = max(seg1.start, seg2.start), e = min(seg1.end, seg2.end);
19             if (s > e) {
20                 if (seg1.end > seg2.end) { p2++; }
21                 else { p1++; }
22                 continue;
23             }
24             Interval seg(s, e);
25             ret.push_back(seg);
26             if (seg1.end > seg2.end) {
27                 p2++;
28             } else if (seg2.end > seg1.end) {
29                 p1++;
30             } else {
31                 p1++, p2++;
32             }
33         }
34         return ret;
35     }
36 };

View Code

【987】Vertical Order Traversal of a Binary Tree（第四題 5分）

給了一棵二叉樹，給了樹的結點上座標的定義。根結點是 (0, 0)， For each node at position (X, Y), its left and right children respectively will be at positions (X-1, Y-1) and (X+1, Y-1). 按照 X 軸升序， Y 軸降序，而後 value 升序的條件，返回這顆樹的值。

題解：dfs一遍樹，用map存起來。

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 class Solution {
11 public:
12     vector<vector<int>> verticalTraversal(TreeNode* root) {
13         vector<vector<int>> ret;
14         if (!root) {return ret;}
15         dfs(root, 0, 0);
16         for (auto& pp : memo) {
17             int x = pp.first; map<int, vector<int>, greater<int>> mp = pp.second;
18             vector<int> temp;
19             for (auto& ele : mp) {
20                 sort(ele.second.begin(), ele.second.end());
21                 for (auto& num : ele.second) {
22                     temp.push_back(num);
23                 }
24             }
25             ret.push_back(temp);
26         }
27         return ret;
28     }
29     map<int, map<int, vector<int>, greater<int>>> memo; // x-idx, list of values, and height
30     void dfs(TreeNode* root, int x, int y) {
31         if (!root) {return;}
32         memo[x][y].push_back(root->val);
33         dfs(root->left, x-1, y-1);
34         dfs(root->right, x+1, y-1);
35     }
36     
37 };

View Code

Contest 123（題號985～988）（2019年2月10日）

Contest 124（題號993～996）（2019年2月17日）

Contest 125（題號997～1001）（2019年2月24日）

連接：https://leetcode.com/contest/weekly-contest-125

總結：這週四道題都不難，最後一題看錯題了，致使浪費了不少時間。結果：3/4，rank：1008/4288

【997】Find the Town Judge（第一題 4分）

在一個小鎮裏，按從 1 到 N 標記了 N 我的。傳言稱，這些人中有一個是小鎮上的祕密法官。

若是小鎮的法官真的存在，那麼：

小鎮的法官不相信任何人。
每一個人（除了小鎮法官外）都信任小鎮的法官。
只有一我的同時知足屬性 1 和屬性 2 。

給定數組 trust，該數組由信任對 trust[i] = [a, b] 組成，表示標記爲 a 的人信任標記爲 b 的人。

若是小鎮存在祕密法官而且能夠肯定他的身份，請返回該法官的標記。不然，返回 -1。

輸入：N = 4, trust = [[1,3],[1,4],[2,3],[2,4],[4,3]]
輸出：3

題解：遍歷trust數組，用count數組， count[i] 表示標記第 i 我的有幾我的信任，用 exist 數組， exist[i] 表示第 i 我的是否信任別人。而後按照規則... 最後有一個corner case，就是當 N = 1, trust 爲空的時候，應該返回1.

 1 class Solution {
 2 public:
 3     int findJudge(int N, vector<vector<int>>& trust) {
 4         const int size = trust.size();
 5         if (N == 1 && size == 0) {return 1;}
 6         vector<int> count(N+1, 0);
 7         vector<int> exist(N+1, 0);
 8         for (auto& t : trust) {
 9             int u = t[0], v = t[1];
10             count[v]++;
11             exist[u] = 1;
12         }
13         int res = -1;
14         for (int i = 0; i <= N; ++i) {
15             if (count[i] == N-1 && exist[i] == 0) {
16                 if (res != -1) {
17                     res = -1;
18                     break;
19                 } else {
20                     res = i;
21                 }
22             }
23         }
24         return res;
25     }
26 };

View Code

【999】Available Captures for Rook（第二題 4分）

在一個 8 x 8 的棋盤上，有一個白色車（rook）。也可能有空方塊，白色的象（bishop）和黑色的卒（pawn）。它們分別以字符「R」，「.」，「B」和「p」給出。大寫字符表示白棋，小寫字符表示黑棋。

車按國際象棋中的規則移動：它選擇四個基本方向中的一個（北，東，西和南），而後朝那個方向移動，直到它選擇中止、到達棋盤的邊緣或移動到同一方格來捕獲該方格上顏色相反的卒。另外，車不能與其餘友方（白色）象進入同一個方格。

返回車可以在一次移動中捕獲到的卒的數量。

題解：先找到rook的位置，而後上下左右四個方向，往前走，若是當前方向可以捕獲到 pawn 的話，就 res++。res 最多四個，題目描述很差，不要想太多。

 1 class Solution {
 2 public:
 3     int numRookCaptures(vector<vector<char>>& board) {
 4         vector<int> begin(2);
 5         for (int i = 0; i < 8; ++i) {
 6             for (int j = 0; j < 8; ++j) {
 7                 if (board[i][j] == 'R') {
 8                     begin = {i, j};
 9                     break;
10                 }
11             }
12         }
13         const int dirx[4] = {-1, 0, 1, 0};
14         const int diry[4] = {0, -1, 0, 1};
15         int res = 0;
16         for (int k = 0; k < 4; ++k) {
17             int x = begin[0], y = begin[1];
18             while (x >= 0 && x < 8 && y >= 0 && y < 8) {
19                 if (board[x][y] == 'B') {break;}
20                 if (board[x][y] == 'p') {
21                     ++res; break;
22                 }
23                 x += dirx[k], y += diry[k];
24             }
25         }
26         return res;
27     }    
28 };

View Code

【998】Maximum Binary Tree II（第三題 6分）

最大樹定義：一個樹，其中每一個節點的值都大於其子樹中的任何其餘值。

給出最大樹的根節點 root。

就像以前的問題那樣，給定的樹是從表 A（root = Construct(A)）遞歸地使用下述 Construct(A) 例程構造的：

若是 A 爲空，返回 null
不然，令 A[i] 做爲 A 的最大元素。建立一個值爲 A[i] 的根節點 root
root 的左子樹將被構建爲 Construct([A[0], A[1], ..., A[i-1]])
root 的右子樹將被構建爲 Construct([A[i+1], A[i+2], ..., A[A.length - 1]])
返回 root

請注意，咱們沒有直接給定 A，只有一個根節點 root = Construct(A).

假設 B 是 A 的副本，並附加值 val。保證 B 中的值是不一樣的。

返回 Construct(B)。

題解：看見樹就遞歸，若是當前的根結點小於要插入的幾點，那麼新的結點就是根結點。不然要插入到當前根結點的右子樹當中。

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 class Solution {
11 public:
12     TreeNode* insertIntoMaxTree(TreeNode* root, int val) {
13         if (!root) {
14             root = new TreeNode(val);
15             return root;
16         }
17         TreeNode* node = new TreeNode(val);
18         if (val > root->val) {
19             node->left = root;
20             return node;
21         }
22         root->right = insertIntoMaxTree(root->right, val);
23         return root;
24     }
25 };

View Code

【1001】Grid Illumination（第四題 8分）（網格照明）

在 N x N 的網格上，每一個單元格 (x, y) 上都有一盞燈，其中 0 <= x < N 且 0 <= y < N 。

最初，必定數量的燈是亮着的。lamps[i] 告訴咱們亮着的第 i 盞燈的位置。每盞燈都照亮其所在 x 軸、y 軸和兩條對角線上的每一個正方形（相似於國際象棋中的皇后）

對於第 i 次查詢 queries[i] = (x, y)，若是單元格 (x, y) 是被照亮的，則查詢結果爲 1，不然爲 0 。

在每一個查詢 (x, y) 以後 [按照查詢的順序]，咱們關閉位於單元格 (x, y) 上或其相鄰 8 個方向上（與單元格 (x, y) 共享一個角或邊）的任何燈。

返回答案數組 answer。每一個值 answer[i] 應等於第 i 次查詢 queries[i] 的結果。

題解：咱們用四個map，分別表示第 x 行，第 y 列，座標(x,y) 對應的正向對角線（key是 x-y）和反向對角線 (key 是 x+y)。而後對於每個query，判斷他的行，列，正反對角線是否是有燈照明，有的話，ans[i] = 1，而後把 query 的座標相鄰的九個小格子的燈給關掉。

 1 class Solution {
 2 public:
 3     vector<int> gridIllumination(int N, vector<vector<int>>& lamps, vector<vector<int>>& queries) {
 4         unordered_map<int, int> rows, cols, dia, anti;
 5         set<vector<int>> st(lamps.begin(), lamps.end());
 6         for (auto& l : lamps) {
 7             int x = l[0], y = l[1];
 8             rows[x]++, cols[y]++;
 9             dia[x+y]++, anti[x-y]++;
10         }
11         const int size = queries.size();
12         const int dirx[9] = {-1, -1, -1, 0, 0, 0, 1, 1, 1};
13         const int diry[9] = {-1, 0, 1, -1, 0 ,1, -1, 0, 1};
14         vector<int> res(size, 0);
15         for (int i = 0; i < size; ++i) {
16             int x = queries[i][0], y = queries[i][1];
17             if (rows.find(x) != rows.end() && rows[x] > 0 || cols.find(y) != cols.end() && cols[y] > 0
18                || dia.find(x+y) != dia.end() && dia[x+y] > 0 || anti.find(x-y) != anti.end() && anti[x-y] > 0) {
19                 res[i] = 1;
20             }
21             for (int k = 0; k <= 8; ++k) {
22                 int newx = x + dirx[k], newy = y + diry[k];
23                 if (newx < 0 || newx >= N || newy < 0 || newy >= N) {continue;}
24                 if (st.find({newx, newy}) == st.end()) {continue;}
25                 rows[newx]--;
26                 cols[newy]--;
27                 dia[newx + newy]--;
28                 anti[newx - newy]--;
29             }
30         }
31         return res;
32     }
33 };

View Code

Contest 126（題號1000，1002～1004）（2019年3月3日）

連接：https://leetcode.com/contest/weekly-contest-126

總結：結果：3/4，rank：333/4564，這周怎麼說，第一題愣住了，第二題用了一個錯誤的解法AC了，第三題 sliding window 快忘完了，第四題不會作。第四題合併石子，兩堆會合並，k 堆不會合並。

【1002】Find Common Characters（第一題 3分）

返回一個wordlist裏面全部word相同的字母，若是一個字母在這全部的單詞裏面都出現了至少m次，那麼這個字母在結果的數組中也應該出現 m 次。

Example 1:
Input: ["bella","label","roller"]
Output: ["e","l","l"]
Example 2:
Input: ["cool","lock","cook"]
Output: ["c","o"]

題解：我先把每一個單詞都sort了一下，這樣能方便統計每一個字符出現的次數。而後對於每一個字母a到z統計每一個單詞中出現的最小頻次。

 1 class Solution {
 2 public:
 3     vector<string> commonChars(vector<string>& A) {
 4         for (auto & s : A) {
 5             sort(s.begin(), s.end());
 6         }
 7         vector<string> res;
 8         for (char c = 'a'; c <= 'z'; ++c) {
 9             int times = INT_MAX;
10             for (auto& s: A) {
11                 int pos1 = s.find_first_of(c);
12                 if (pos1 == string::npos) {times = 0; break;}
13                 int pos2 = s.find_last_of(c);
14                 times = min(times, pos2 - pos1 + 1);
15             }
16             if (times) {
17                 for (int i = 0; i < times; ++i) {
18                     res.push_back(string(1, c));
19                 }
20             }
21         }
22         return res;
23     }
24 };

View Code

【1003】Check If Word Is Valid After Substitutions（第二題 5分）

給定的字符串"abc"是 valid的，把一個 valid 的字符串拆成兩個部分 X + Y，那麼在 X，Y之間放一個 valid 的字符串， X + valid + Y 也是 valid的。給定一個字符串 S，判斷它是否是 valid 的。

Example 1:
Input: "aabcbc"
Output: true
Explanation: 
We start with the valid string "abc".
Then we can insert another "abc" between "a" and "bc", resulting in "a" + "abc" + "bc" which is "aabcbc".

Example 2:
Input: "abcabcababcc"
Output: true
Explanation: 
"abcabcabc" is valid after consecutive insertings of "abc".
Then we can insert "abc" before the last letter, resulting in "abcabcab" + "abc" + "c" which is "abcabcababcc".

Example 3:
Input: "abccba"
Output: false

Example 4:
Input: "cababc"
Output: false

數據規模：

Note:

1 <= S.length <= 20000
S[i] is 'a', 'b', or 'c'

題解：我比賽裏面是用了三個變量 a，b，c 統計這三個字母出現的頻次，若是不符合 cntA >= cntB >= cntC 就是 invalid 的字符串。可是若是輸入是"aabbcc"這個條件是符合的，可是結果是這個字符串依舊是invalid的。

因此比賽以後的解法用了stack來作。

 1 class Solution {
 2 public:
 3     bool isValid(string S) {
 4         const int n = S.size();
 5         string cur = "";
 6         stack<string> stk;
 7         for (auto& c : S) {
 8             if (c == 'a') {
 9                 if (!cur.empty()) { stk.push(cur); }
10                 cur = "a";
11             } else {
12                 cur += c;
13                 if (cur != "ab" && cur != "abc") {return false;}
14             }
15             
16             if (cur == "abc") {
17                 if (stk.empty()) {
18                     cur = "";
19                 } else {
20                     cur = stk.top(); stk.pop();
21                 }
22             }
23         }
24         return stk.empty() && cur.empty();
25     }
26 };

View Code

【1004】Max Consecutive Ones III（第三題 6分）

Given an array A of 0s and 1s, we may change up to K values from 0 to 1.

Return the length of the longest (contiguous) subarray that contains only 1s.

Example 1:
Input: A = [1,1,1,0,0,0,1,1,1,1,0], K = 2
Output: 6
Explanation: 
[1,1,1,0,0,1,1,1,1,1,1]
Bolded numbers were flipped from 0 to 1.  The longest subarray is underlined.

Example 2:
Input: A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3
Output: 10
Explanation: 
[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
Bolded numbers were flipped from 0 to 1.  The longest subarray is underlined.
 

Note:
1 <= A.length <= 20000
0 <= K <= A.length
A[i] is 0 or 1

題解：這題用了 sliding window 標準模版，用一個變量統計已經 flip 以後的 0 的個數，若是 cnt > k 的時候，咱們就嘗試往前移動begin指針。

 1 class Solution {
 2 public:
 3     int longestOnes(vector<int>& A, int K) {
 4         const int n = A.size();
 5         int start = 0, cnt = 0, res = 0;
 6         for (int i = 0; i < n; ++i) {
 7             if (A[i] == 0) {
 8                 cnt++;
 9             }
10             while (cnt > K) {
11                 if (A[start] == 0) {--cnt;}
12                 ++start;
13             }
14             res = max(res, i - start + 1);
15         }
16         return res;
17     }
18 };