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

時間 2019-11-18

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

原文原文鏈接

Contest 41 （）（題號）

Contest 42 （）（題號）

Contest 43 （）（題號）

Contest 44 （2018年12月6日，週四上午）（題號653—656）

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

比賽狀況記錄：就作出來兩題，第三題不難，然而就是在算座標的時候卡住了。orz。結果：2/4，ranking：637/2272。第四題沒看題，第三題搞得心情很差了orz。數組

【653】Two Sum IV - Input is a BST（第一題 3分）負載均衡

輸入是一棵 BST，問能不能在這棵 BST 裏面找到兩個結點，使得兩個結點的和等於 target。ide

題解：我是先 dfs 成了一個有序數組，而後 2 pointers 作的。還能夠 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     bool findTarget(TreeNode* root, int k) {
13         dfs(root);
14         const int n = nums.size();
15         int p1 = 0, p2 = n - 1;
16         while (p1 < p2) {
17             int summ = nums[p1] + nums[p2];
18             if (summ == k) { return true; } 
19             if (summ  < k) { p1++; } 
20             else { p2--; }
21         }
22         return false;
23     }
24     void dfs(TreeNode* root) {
25         if (!root) {return;}
26         dfs(root->left); 
27         nums.push_back(root->val);
28         dfs(root->right);
29         return;
30     }
31     vector<int> nums;
32 };

View Code

【654】Maximum Binary Tree（第二題 5分）優化

給了一個 unique 的數組，沒有重複數字。生成 maximum binary tree。生成規則：根是數組最大的元素，根左邊的子數組作左子樹，根右邊的子數組作右子樹。全部子樹也知足這些性質。spa

題解：直接遞歸生成。設計

 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* constructMaximumBinaryTree(vector<int>& nums) {
13         const int n = nums.size();
14         if (n == 0) {return nullptr;}
15         int maxValue = nums[0], maxIdx = 0;
16         for (int i = 1; i < n; ++i) {
17             if (nums[i] > maxValue) {
18                 maxIdx = i;
19                 maxValue = nums[i];
20             }
21         }
22         TreeNode* root = new TreeNode(maxValue);
23         vector<int> LeftSon(nums.begin(), nums.begin()+maxIdx);
24         vector<int> RightSon(nums.begin() + maxIdx + 1, nums.end());
25         root->left = constructMaximumBinaryTree(LeftSon);
26         root->right = constructMaximumBinaryTree(RightSon);
27         return root;
28     }
29 };

View Code

【655】Print Binary Tree（第三題 7分）3d

打印二叉樹。打印規則見例子。code

Example 1:
Input:
     1
    /
   2
Output:
[["", "1", ""],
 ["2", "", ""]]
Example 2:
Input:
     1
    / \
   2   3
    \
     4
Output:
[["", "", "", "1", "", "", ""],
 ["", "2", "", "", "", "3", ""],
 ["", "", "4", "", "", "", ""]]
Example 3:
Input:
      1
     / \
    2   5
   / 
  3 
 / 
4 
Output:
[["",  "",  "", "",  "", "", "", "1", "",  "",  "",  "",  "", "", ""]
 ["",  "",  "", "2", "", "", "", "",  "",  "",  "",  "5", "", "", ""]
 ["",  "3", "", "",  "", "", "", "",  "",  "",  "",  "",  "", "", ""]
 ["4", "",  "", "",  "", "", "", "",  "",  "",  "",  "",  "", "", ""]]

題解：我在比賽的時候卡住了，算列座標的時候算不出來系列。返回的數組是 n * m 大小， n 是二叉樹的高度，m = 2^n - 1。而後咱們遞歸的生成每棵子樹。列座標實際上是 (l + r)/2。

 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<string>> printTree(TreeNode* root) {
13         if (!root) { 
14             return vector<vector<string>>();
15         }
16         globalHeight = getHeight(root);
17         const int cols = pow(2, globalHeight) - 1;
18         vector<vector<string>> ret(globalHeight, vector<string>(cols, ""));
19         printTree(root, ret, globalHeight, 0, cols);
20         return ret;
21     }
22     void printTree(TreeNode* root, vector<vector<string>>& ret, int height, int l, int r) {
23         if (!root) {return;}
24         int mid = (l + r) / 2;
25         printTree(root->left, ret, height - 1, l, mid);
26         ret[globalHeight - height][mid] = to_string(root->val);
27         printTree(root->right, ret, height - 1, mid + 1, r);
28         return;
29     }
30     
31     int getHeight(TreeNode* root) {
32         if (!root) {return 0;}
33         return max(getHeight(root->left), getHeight(root->right)) + 1;
34     }
35     int globalHeight = 0;
36 };

View Code

【656】Coin Path（第四題 9分）

Contest 45 （2018年12月4日，週二下午）（題號657-660）

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

比賽狀況記錄：3/4，ranking：298/2292。第三題我預估是勉強卡線過的，應該能夠更加優化。第四題一點想法都沒有，懷疑是否是要把含有9的數都生成出來。

【657】Robot Return to Origin（第一題 3分）

給了一個字符串，由 "L", "R", "U", "D" 組成，表明機器人走的方向，一個字符表明一步，機器人起點在原點，問它能不能最後回到原點。

題解：簽到題。分別數出這四個字符的個數，判斷上下，左右能不能徹底抵消。

 1 class Solution {
 2 public:
 3     bool judgeCircle(string moves) {
 4         int cntL = 0, cntR = 0, cntU = 0, cntD = 0;
 5         for (auto& c : moves) {
 6             if (c == 'L') {cntL++;}
 7             if (c == 'R') {cntR++;}
 8             if (c == 'U') {cntU++;}
 9             if (c == 'D') {cntD++;}
10         }
11         return (cntL == cntR) && (cntU == cntD) ? true : false;
12     }
13 };

View Code

【658】Find K Closest Elements（第二題 6分）

給了一個有序遞增數組，和兩個數字 x 和 k。咱們的目標是在數組中找到 k 個離 x 最近的數，若是答案有多個，就返回小的那個。從小到大返回這 k 個數。

題解：我先二分找到 x 的 upper_bound，而後分類處理的。若是 iter 在最左或者最右，就返回前面或者後面 k 個數。若是在中間，就 2 pointers。

 1 class Solution {
 2 public:
 3     vector<int> findClosestElements(vector<int>& arr, int k, int x) {
 4         const int n = arr.size();
 5         auto iter = upper_bound(arr.begin(), arr.end(), x);
 6         if (iter == arr.end()) {
 7             vector<int> ret(arr.end() - k, arr.end());
 8             return ret;
 9         } else if (iter == arr.begin()) {
10             vector<int> ret(arr.begin(), arr.begin() + k);
11             return ret;
12         }
13         int p2 = distance(arr.begin(), iter), p1 = p2 - 1;
14         vector<int> ret(k);
15         for (int i = 0; i < k; ++i) {
16             int number = -1;
17             if (p1 >= 0 && p2 < n) {
18                 if (abs(arr[p1] - x) <= abs(arr[p2] - x)) {
19                     number = arr[p1--];
20                 } else {
21                     number = arr[p2++];
22                 }
23             } else if (p1 >= 0) {
24                 number = arr[p1--];
25             } else if (p2 < n) {
26                 number = arr[p2++];
27             }
28             ret[i] = number;
29         }
30         sort(ret.begin(), ret.end());
31         return ret;
32     }
33 };

View Code

應該能夠更快，我這個解法只 beats 了 53%+。

【659】Split Array into Consecutive Subsequences（第三題 8分）

給了一個有序 int 數組arr，數組裏面可能有重複元素，問能不能把這個 int 數組分割成幾個連續的整數序列。（每一個整數序列的元素個數必須大於3個）。能的話返回 true，不能的話返回 false。

題解：個人解法只beats了 1%。我感受是壓線過的。我設計了一個結構 vector<pair<int, int>> segs 。裏面每一個元素 seg 存儲整數序列的最左和最右值。若是隻是一個元素 number，那麼 p(number, number) 。而後對於 arr 中的每一個元素 number，依次想往 segs 中的元素裏面靠，若是有多個 candidate 能夠靠的話，就作個相似於負載均衡這樣的東西，不要讓一個 seg 太長，力求讓每一個 seg 的長度都平均。（爲啥呢，好比 arr = [1, 2, 3, 3 ,4, 5] ，我期待的結果是 [1, 3], [3, 5]，可是若是不作這個負載均衡的話，就可能出現 [1, 5], [3, 3] 的結果。）靠上了以後，就看能不能合併 seg，若是沒靠上的話，就這個 number 本身生成一個 seg，加入 segs。

 1 class Solution {
 2 public:
 3     bool isPossible(vector<int>& nums) {
 4         const int n = nums.size();
 5         if (n < 3) {return false;}
 6         vector<pair<int, int>> segs(1, make_pair(nums[0], nums[0]));
 7         for (int i = 1; i < n; ++i) {
 8             int number = nums[i];
 9             int mark = -1, sizeMark = n;
10             for (int j = 0; j < segs.size(); ++j) {
11                 const int sizeJ = segs[j].second - segs[j].first + 1;
12                 if (number == segs[j].first - 1) {
13                     //segs[j].first = number;
14                     if (mark == -1) {
15                         mark = j;
16                     } else if (sizeMark > sizeJ) {
17                         sizeMark = sizeJ;
18                         mark = j;
19                     } 
20                 } else if (number == segs[j].second + 1) {
21                     //segs[j].second = number;
22                     if (mark == -1) {
23                         mark = j;
24                     } else if (sizeMark > sizeJ){
25                         sizeMark = sizeJ;
26                         mark = j;
27                     } 
28                 }
29             }
30             //printf("number = %d, mark = %d \n", number, mark);
31             if (mark == -1) {
32                 segs.push_back(make_pair(number, number));
33                 continue;
34             } else {
35                 if (number == segs[mark].first - 1) {
36                     segs[mark].first = number;
37                 } else {
38                     segs[mark].second = number;
39                 }
40                 int del = -1;
41                 if (number == segs[mark].first) {
42                     for (int k = 0; k < segs.size(); ++k) {
43                         if (k == mark) {continue;}
44                         if (number == segs[k].second + 1) {
45                             //printf("combine. %d, segs[%d] && segs[%d] \n", __LINE__ ,k, mark);
46                             segs[k].second = segs[mark].second; //[k, mark]
47                             del = mark;
48                             break;
49                         }
50                     }
51                 } else if (number == segs[mark].second) {
52                     for (int k = 0; k < segs.size(); ++k) {
53                         if (k == mark) {continue;}
54                         if (number == segs[k].first - 1) {
55                             //printf("combine. %d, segs[%d] && segs[%d] \n", __LINE__ ,mark, k);
56                             segs[mark].second = segs[k].second; //[mark, k]
57                             del = k;
58                             break;
59                         }
60                     }
61                 }
62                 if (del != -1) {
63                     segs.erase(segs.begin() + del);
64                 }
65             }
66         }
67         for (auto p : segs) {
68             //printf("(%d, %d) \n", p.first, p.second);
69             if (p.second - p.first < 2) {return false;}
70         }
71         return true;
72     }
73 };

View Code

那麼其實應該還有更優秀的解法，等我學習一下。

【660】Remove 9（第四題 9分）

Contest 46 （2018年12月31日，週一下午）（題號661-664）

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

【661】Image Smoother（第一題 3分）

一個圖像的平滑處理器，每一個像素點的值等於它周圍八個點和它本身的平均值。求平滑後的圖像。

題解：無

 1 class Solution {
 2 public:
 3     vector<vector<int>> imageSmoother(vector<vector<int>>& M) {
 4         vector<vector<int>> ret(M);
 5         const int n = M.size(), m = M[0].size();
 6         for (int i = 0; i < n; ++i) {
 7             for (int j = 0; j < m; ++j) {
 8                 int summ = M[i][j], div = 1;
 9                 for (int k = 0; k < 8; ++k) {
10                     int newx = i + dirx[k], newy = j + diry[k];
11                     if (newx >= 0 && newx < n && newy >= 0 && newy < m) {
12                         div++;
13                         summ += M[newx][newy];
14                     }
15                 }
16                 ret[i][j] = summ / div;
17             }
18         }
19         return ret;
20     }
21     int dirx[8] = {-1, 0, 1, 0, -1, -1, 1, 1};
22     int diry[8] = {0, -1, 0, 1, -1, 1, -1, 1};
23 };

View Code

【662】Maximum Width of Binary Tree（第二題 6分）

返回一棵二叉樹的最寬距離。最寬距離的定義是同一層從最左邊的第一個非空的結點到最右邊的非空結點的結點數（中間能夠包含空結點）。

題解：我用了2個deque作的層級遍歷。dq1用來記錄當前層的結點，dq2用來記錄下一層的結點。在遍歷dq2以前先把它頭部和尾部全部空結點刪除。而後再遍歷。

 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     int widthOfBinaryTree(TreeNode* root) {
13         if (!root) { return 0; }
14         deque<TreeNode*> que, que2;
15         que.push_back(root);
16         int res = 0;
17         while(!que.empty()) {
18             while (!que.empty() && que.front() == nullptr) {
19                 que.pop_front();
20             }
21             while (!que.empty() && que.back() == nullptr) {
22                 que.pop_back();
23             }
24             res = max(res, (int)que.size());
25             while (!que.empty()) {
26                 TreeNode* cur = que.front(); que.pop_front();
27                 if (cur == nullptr) {
28                     que2.push_back(nullptr); 
29                     que2.push_back(nullptr);
30                     continue;
31                 }
32                 que2.push_back(cur->left);
33                 que2.push_back(cur->right);
34             }
35             swap(que, que2);
36         }
37         return res;
38     }
39 };