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

時間 2019-11-18

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

原文原文鏈接

Contest 71 （）

Contest 72 （）

Contest 73 （2019年1月30日模擬）

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

結果：2/4，會作第一題和第三題，第二題和第四題不會作。數組

【788】Rotated Digits（第一題 4分）（谷歌tag）dom

給了一個 good number 的定義，X is a good number if after rotating each digit individually by 180 degrees, we get a valid number that is different from X. ide

0， 1， 8旋轉以後是自己，2，5旋轉以後互爲另外一個數，6，9 同 2，5。ui

給定一個 N，問 1～N 裏面有多少個 good number？（N < 10000）編碼

題解：直接枚舉。注意旋轉是說每一個數字單獨旋轉，並非把整個數旋轉。spa

 1 class Solution {
 2 public:
 3     int rotatedDigits(int N) {
 4         unordered_map<int, int> mp;
 5         mp[0] = 0, mp[1] = 1, mp[8] = 8, mp[2]= 5, mp[5] = 2, mp[6] = 9, mp[9] = 6; 
 6         int ans = 0;
 7         for (int i = 1; i <= N; ++i) {
 8             string s = to_string(i);
 9             string rev = "";
10             bool valid = true;
11             for (auto c : s) {
12                 if (mp.find(c-'0') == mp.end()) {
13                     valid = false; 
14                     break;
15                 }
16                 rev += string(1, mp[c-'0'] + '0');
17             }
18             if (valid && s != rev && rev[0] != '0') {
19                 ans++;
20             }
21         }
22         return ans;
23     }
24 };

View Code

【789】Escape The Ghosts（第二題 5分）逃離鬼魂（谷歌tag，數學題）code

假設你站在原點，有個去的目標 target 座標，在二維平面上有一些鬼魂（鬼也有座標）。每一步，你和鬼魂都能上下左右移動一格。問有沒有可能在鬼怪抓到你以前，到達target。若是你和鬼怪同時到達target的話，那麼鬼贏了。blog

題解：我比賽的時候想成了比較複雜的bfs，去模擬每一個位置。幸虧沒有寫。本題的本質是隻要你和target 的曼哈頓距離小於任何一個鬼怪距離target的目標距離，你就有可能會贏。因此只要判斷一下距離就好了。排序

 1 class Solution {
 2 public:
 3     bool escapeGhosts(vector<vector<int>>& ghosts, vector<int>& target) {
 4         const int dist = abs(target[0]) + abs(target[1]);
 5         for (auto& ele : ghosts) {
 6             int d = abs(target[0] - ele[0]) + abs(target[1] - ele[1]);
 7             if (d < dist) {
 8                 return false;
 9             }
10         }
11         return true;
12     }
13 };

View Code

比賽的時候理解有問題，我一直覺得某個時間人和鬼都必需要移動，不能站着不動。可是總監說不能站着不動的話，這題的難度也沒有增長，由於若是有個鬼到target的距離和人到target距離若是差了一步的話，人就能到target，若是差了兩步的話，鬼就能先離開，而後再回到target，因此這個時候鬼贏了。

而後還有一個變種，若是鬼不能到target，它最多在target周圍四個格子，有點像貓和老鼠那題。

【791】Custom Sort String（第三題 5分）

給了兩個字符串 S 和 T，S 定義了一種新的字母順序，要求把 T 按照 S 定義的順序排序。

題解：我是先用了一個 hashmap 記錄了 T 的每一個字母的頻次，而後再遍歷一遍 S，構造ans字符串，最後遍歷hashmap中剩下的字符，組成新的字符串。

 1 class Solution {
 2 public:
 3     string customSortString(string S, string T) {
 4         const int n = T.size();
 5         unordered_map<char, int> mp;
 6         for (int i = 0; i < n; ++i) {
 7             mp[T[i]]++;
 8         }
 9         string ret;
10         for (auto c : S) {
11             if (mp.find(c) == mp.end() || mp[c] == 0) {continue;}
12             ret += string(mp[c], c);
13             mp[c] = 0;
14         }
15         for (auto ele : mp) {
16             if (ele.second > 0) {
17                 ret += string(ele.second, ele.first);
18             }
19         }
20         return ret;
21     }
22 };

View Code

【790】Domino and Tromino Tiling（第四題 5分）

給了多米諾骨牌，有兩種形狀，

XX  <- domino

XX  <- "L" tromino
X

給定一個 N 問有多少種填充方案能填滿 2 * N 個格子。答案要對 1e9+7 取模。

題解：dp作。

Contest 74 （2019年1月31日模擬）

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

Contest 75 （2019年1月31日模擬）

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

Contest 77 （2019年2月3日模擬）

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

總結：作出來三道題。3/4

【806】Number of Lines To Write String（第一題 4分）

給了一個數組，數組中的元素做爲 'a' ~ 'z' 的每一個佔位符的寬度。每行最多100個字符寬度，問給了一個字符串，返回兩個數字，一個是這個字符串須要佔多少行，第二個是這個字符串的最後一行有多少個字符。

Example :
Input: 
widths = [10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]
S = "abcdefghijklmnopqrstuvwxyz"
Output: [3, 60]
Explanation: 
All letters have the same length of 10. To write all 26 letters,
we need two full lines and one line with 60 units.

題解：用個 curSum 的變量記錄當前行有多少個字符，當 curSum 大於 100 的時候就換行。

 1 class Solution {
 2 public:
 3     vector<int> numberOfLines(vector<int>& widths, string S) {
 4         const int n = S.size();
 5         int curLen = 0;
 6         vector<int> ans(2, 0);
 7         for (int i = 0; i < n; ++i) {
 8             curLen += widths[S[i]-'a'];
 9             if (curLen > 100) {
10                 ans[0]++;
11                 curLen = widths[S[i]-'a'];
12             }
13         }
14         ans[0] += 1;
15         ans[1] = curLen;
16         return ans;
17     }
18 };

View Code

【804】Unique Morse Code Words（第二題 4分）

給了一個數組做爲 'a' 到 'z' 的摩斯碼編碼，給了一個 word list，不一樣的單詞可能有相同的莫斯碼編碼，返回有多少不一樣的摩斯碼編碼的種類。

題解：遍歷，用set去除重複。

 1 class Solution {
 2 public:
 3     int uniqueMorseRepresentations(vector<string>& words) {
 4         vector<string> morse = {".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."};
 5         set<string> st;
 6         for (auto& w : words) {
 7             string str;
 8             for (auto& c : w) {
 9                 str += morse[c - 'a'];
10             }
11             st.insert(str);
12         }
13         return (int)st.size();
14     }
15 };

View Code

【807】Max Increase to Keep City Skyline（第三題 5分）

給了一個二維的grid， grid[i][j] 表明 (i, j) 座標的樓的高度，咱們能從先後和左右看到兩個高度的輪廓，咱們的目標是增長樓的高度，可是讓輪廓線不變。

Example:
Input: grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]
Output: 35
Explanation: 
The grid is:
[ [3, 0, 8, 4], 
  [2, 4, 5, 7],
  [9, 2, 6, 3],
  [0, 3, 1, 0] ]

The skyline viewed from top or bottom is: [9, 4, 8, 7]
The skyline viewed from left or right is: [8, 7, 9, 3]

The grid after increasing the height of buildings without affecting skylines is:

gridNew = [ [8, 4, 8, 7],
            [7, 4, 7, 7],
            [9, 4, 8, 7],
            [3, 3, 3, 3] ]

題解：咱們先計算出 top 和 left 的輪廓線，grid[i][j] 能取到的最大的高度就是 min(top[j], left[i])

 1 class Solution {
 2 public:
 3     int maxIncreaseKeepingSkyline(vector<vector<int>>& grid) {
 4         const int n = grid.size(), m = grid[0].size();
 5         vector<int> fromTop(m, 0), fromLeft(n, 0);
 6         for (int i = 0; i < n; ++i) {
 7             for (int j = 0; j < m; ++j) {
 8                 fromTop[j] = max(fromTop[j], grid[i][j]);
 9                 fromLeft[i] = max(fromLeft[i], grid[i][j]);
10             }
11         }
12         int ret = 0;
13         for (int i = 0; i < n; ++i) {
14             for (int j = 0; j < m; ++j) {
15                 ret += min(fromTop[j], fromLeft[i]) - grid[i][j];
16             }
17         }
18         return ret;
19     }
20 };