Contest 41 （）（題號）

Contest 42 （）（題號）

Contest 43 （）（題號）

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

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

比賽情況記錄：

Two Sum IV - Input is a BST（第一題 3分）

Maximum Binary Tree（第二題 5分）

Print Binary Tree（第三題 7分）

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 };

【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 };

應該可以更快，我這個解法只 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 };

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

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