設計你的回圈佇列實作， 回圈佇列是一種線性資料結構，其操作表現基于 FIFO（先進先出）原則并且隊尾被連接在隊首之后以形成一個回圈，它也被稱為“環形緩沖器”，

回圈佇列的一個好處是我們可以利用這個佇列之前用過的空間，在一個普通佇列里，一旦一個佇列滿了，我們就不能插入下一個元素，即使在佇列前面仍有空間，但是使用回圈佇列，我們能使用這些空間去存盤新的值，

你的實作應該支持如下操作：

MyCircularQueue(k): 構造器，設定佇列長度為 k ，
Front: 從隊首獲取元素，如果佇列為空，回傳 -1 ，
Rear: 獲取隊尾元素，如果佇列為空，回傳 -1 ，
enQueue(value): 向回圈佇列插入一個元素，如果成功插入則回傳真，
deQueue(): 從回圈佇列中洗掉一個元素，如果成功洗掉則回傳真，
isEmpty(): 檢查回圈佇列是否為空，
isFull(): 檢查回圈佇列是否已滿，
 

示例：

MyCircularQueue circularQueue = new MyCircularQueue(3); // 設定長度為 3
circularQueue.enQueue(1);  // 回傳 true
circularQueue.enQueue(2);  // 回傳 true
circularQueue.enQueue(3);  // 回傳 true
circularQueue.enQueue(4);  // 回傳 false，佇列已滿
circularQueue.Rear();  // 回傳 3
circularQueue.isFull();  // 回傳 true
circularQueue.deQueue();  // 回傳 true
circularQueue.enQueue(4);  // 回傳 true
circularQueue.Rear();  // 回傳 4
 

提示：

所有的值都在 0 至 1000 的范圍內；
運算元將在 1 至 1000 的范圍內；
請不要使用內置的佇列庫，

給定一個整數資料流和一個視窗大小，根據該滑動視窗的大小，計算其所有整數的移動平均值，

實作 MovingAverage 類：

MovingAverage(int size) 用視窗大小 size 初始化物件，
double next(int val) 計算并回傳資料流中最后 size 個值的移動平均值，
 

示例：

輸入：
["MovingAverage", "next", "next", "next", "next"]
[[3], [1], [10], [3], [5]]
輸出：
[null, 1.0, 5.5, 4.66667, 6.0]

解釋：
MovingAverage movingAverage = new MovingAverage(3);
movingAverage.next(1); // 回傳 1.0 = 1 / 1
movingAverage.next(10); // 回傳 5.5 = (1 + 10) / 2
movingAverage.next(3); // 回傳 4.66667 = (1 + 10 + 3) / 3
movingAverage.next(5); // 回傳 6.0 = (10 + 3 + 5) / 3
 

提示：

1 <= size <= 1000
-105 <= val <= 105
最多呼叫 next 方法 104 次

你被給定一個 m × n 的二維網格 rooms ，網格中有以下三種可能的初始化值：

-1 表示墻或是障礙物
0 表示一扇門
INF 無限表示一個空的房間，然后，我們用 231 - 1 = 2147483647 代表 INF，你可以認為通往門的距離總是小于 2147483647 的，
你要給每個空房間位上填上該房間到 最近門的距離 ，如果無法到達門，則填 INF 即可，

示例 1：

輸入：rooms = [[2147483647,-1,0,2147483647],[2147483647,2147483647,2147483647,-1],[2147483647,-1,2147483647,-1],[0,-1,2147483647,2147483647]]
輸出：[[3,-1,0,1],[2,2,1,-1],[1,-1,2,-1],[0,-1,3,4]]
示例 2：

輸入：rooms = [[-1]]
輸出：[[-1]]
示例 3：

輸入：rooms = [[2147483647]]
輸出：[[2147483647]]
示例 4：

輸入：rooms = [[0]]
輸出：[[0]]
 

提示：

m == rooms.length
n == rooms[i].length
1 <= m, n <= 250
rooms[i][j] 是 -1、0 或 231 - 1

給你一個由 '1'（陸地）和 '0'（水）組成的的二維網格，請你計算網格中島嶼的數量，

島嶼總是被水包圍，并且每座島嶼只能由水平方向和/或豎直方向上相鄰的陸地連接形成，

此外，你可以假設該網格的四條邊均被水包圍，

示例 1：

輸入：grid = [
  ["1","1","1","1","0"],
  ["1","1","0","1","0"],
  ["1","1","0","0","0"],
  ["0","0","0","0","0"]
]
輸出：1
示例 2：

輸入：grid = [
  ["1","1","0","0","0"],
  ["1","1","0","0","0"],
  ["0","0","1","0","0"],
  ["0","0","0","1","1"]
]
輸出：3
 

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 300
grid[i][j] 的值為 '0' 或 '1'

你有一個帶有四個圓形撥輪的轉盤鎖，每個撥輪都有10個數字： '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' ，每個撥輪可以自由旋轉：例如把 '9' 變為 '0'，'0' 變為 '9' ，每次旋轉都只能旋轉一個撥輪的一位數字，

鎖的初始數字為 '0000' ，一個代表四個撥輪的數字的字串，

串列 deadends 包含了一組死亡數字，一旦撥輪的數字和串列里的任何一個元素相同，這個鎖將會被永久鎖定，無法再被旋轉，

字串 target 代表可以解鎖的數字，你需要給出解鎖需要的最小旋轉次數，如果無論如何不能解鎖，回傳 -1 ，

示例 1:

輸入：deadends = ["0201","0101","0102","1212","2002"], target = "0202"
輸出：6
解釋：
可能的移動序列為 "0000" -> "1000" -> "1100" -> "1200" -> "1201" -> "1202" -> "0202"，
注意 "0000" -> "0001" -> "0002" -> "0102" -> "0202" 這樣的序列是不能解鎖的，
因為當撥動到 "0102" 時這個鎖就會被鎖定，
示例 2:

輸入: deadends = ["8888"], target = "0009"
輸出：1
解釋：
把最后一位反向旋轉一次即可 "0000" -> "0009"，
示例 3:

輸入: deadends = ["8887","8889","8878","8898","8788","8988","7888","9888"], target = "8888"
輸出：-1
解釋：
無法旋轉到目標數字且不被鎖定，
示例 4:

輸入: deadends = ["0000"], target = "8888"
輸出：-1
 

提示：

1 <= deadends.length <= 500
deadends[i].length == 4
target.length == 4
target 不在 deadends 之中
target 和 deadends[i] 僅由若干位數字組成

給定正整數 n，找到若干個完全平方數（比如 1, 4, 9, 16, ...）使得它們的和等于 n，你需要讓組成和的完全平方數的個數最少，

給你一個整數 n ，回傳和為 n 的完全平方數的 最少數量 ，

完全平方數 是一個整數，其值等于另一個整數的平方；換句話說，其值等于一個整數自乘的積，例如，1、4、9 和 16 都是完全平方數，而 3 和 11 不是，

示例 1：

輸入：n = 12
輸出：3 
解釋：12 = 4 + 4 + 4
示例 2：

輸入：n = 13
輸出：2
解釋：13 = 4 + 9
 
提示：

1 <= n <= 104

設計一個支持 push ，pop ，top 操作，并能在常數時間內檢索到最小元素的堆疊，

push(x) —— 將元素 x 推入堆疊中，
pop() —— 洗掉堆疊頂的元素，
top() —— 獲取堆疊頂元素，
getMin() —— 檢索堆疊中的最小元素，
 

示例:

輸入：
["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]

輸出：
[null,null,null,null,-3,null,0,-2]

解釋：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> 回傳 -3.
minStack.pop();
minStack.top();      --> 回傳 0.
minStack.getMin();   --> 回傳 -2.
 

提示：

pop、top 和 getMin 操作總是在 非空堆疊 上呼叫，

給定一個只包括 '('，')'，'{'，'}'，'['，']' 的字串 s ，判斷字串是否有效，

有效字串需滿足：

左括號必須用相同型別的右括號閉合，
左括號必須以正確的順序閉合，
 

示例 1：

輸入：s = "()"
輸出：true
示例 2：

輸入：s = "()[]{}"
輸出：true
示例 3：

輸入：s = "(]"
輸出：false
示例 4：

輸入：s = "([)]"
輸出：false
示例 5：

輸入：s = "{[]}"
輸出：true

請根據每日 氣溫 串列 temperatures ，請計算在每一天需要等幾天才會有更高的溫度，如果氣溫在這之后都不會升高，請在該位置用 0 來代替，

示例 1:

輸入: temperatures = [73,74,75,71,69,72,76,73]
輸出: [1,1,4,2,1,1,0,0]
示例 2:

輸入: temperatures = [30,40,50,60]
輸出: [1,1,1,0]
示例 3:

輸入: temperatures = [30,60,90]
輸出: [1,1,0]

根據 逆波蘭表示法，求運算式的值，

有效的算符包括 +、-、*、/ ，每個運算物件可以是整數，也可以是另一個逆波蘭運算式，

說明：

整數除法只保留整數部分，
給定逆波蘭運算式總是有效的，換句話說，運算式總會得出有效數值且不存在除數為 0 的情況，
 

示例 1：

輸入：tokens = ["2","1","+","3","*"]
輸出：9
解釋：該算式轉化為常見的中綴算術運算式為：((2 + 1) * 3) = 9
示例 2：

輸入：tokens = ["4","13","5","/","+"]
輸出：6
解釋：該算式轉化為常見的中綴算術運算式為：(4 + (13 / 5)) = 6
示例 3：

輸入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
輸出：22
解釋：
該算式轉化為常見的中綴算術運算式為：
  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22
 

提示：

1 <= tokens.length <= 104
tokens[i] 要么是一個算符（"+"、"-"、"*" 或 "/"），要么是一個在范圍 [-200, 200] 內的整數
 

逆波蘭運算式：

逆波蘭運算式是一種后綴運算式，所謂后綴就是指算符寫在后面，

平常使用的算式則是一種中綴運算式，如 ( 1 + 2 ) * ( 3 + 4 ) ，
該算式的逆波蘭運算式寫法為 ( ( 1 2 + ) ( 3 4 + ) * ) ，
逆波蘭運算式主要有以下兩個優點：

去掉括號后運算式無歧義，上式即便寫成 1 2 + 3 4 + * 也可以依據次序計算出正確結果，
適合用堆疊操作運算：遇到數字則入堆疊；遇到算符則取出堆疊頂兩個數字進行計算，并將結果壓入堆疊中，

給你一個由 '1'（陸地）和 '0'（水）組成的的二維網格，請你計算網格中島嶼的數量，

島嶼總是被水包圍，并且每座島嶼只能由水平方向和/或豎直方向上相鄰的陸地連接形成，

此外，你可以假設該網格的四條邊均被水包圍，

示例 1：

輸入：grid = [
  ["1","1","1","1","0"],
  ["1","1","0","1","0"],
  ["1","1","0","0","0"],
  ["0","0","0","0","0"]
]
輸出：1
示例 2：

輸入：grid = [
  ["1","1","0","0","0"],
  ["1","1","0","0","0"],
  ["0","0","1","0","0"],
  ["0","0","0","1","1"]
]
輸出：3
 

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 300
grid[i][j] 的值為 '0' 或 '1'

給你無向 連通 圖中一個節點的參考，請你回傳該圖的 深拷貝（克隆），

圖中的每個節點都包含它的值 val（int） 和其鄰居的串列（list[Node]），

class Node {
    public int val;
    public List<Node> neighbors;
}
 

測驗用例格式：

簡單起見，每個節點的值都和它的索引相同，例如，第一個節點值為 1（val = 1），第二個節點值為 2（val = 2），以此類推，該圖在測驗用例中使用鄰接串列表示，

鄰接串列 是用于表示有限圖的無序串列的集合，每個串列都描述了圖中節點的鄰居集，

給定節點將始終是圖中的第一個節點（值為 1），你必須將 給定節點的拷貝 作為對克隆圖的參考回傳，

示例 1：

輸入：adjList = [[2,4],[1,3],[2,4],[1,3]]
輸出：[[2,4],[1,3],[2,4],[1,3]]
解釋：
圖中有 4 個節點，
節點 1 的值是 1，它有兩個鄰居：節點 2 和 4 ，
節點 2 的值是 2，它有兩個鄰居：節點 1 和 3 ，
節點 3 的值是 3，它有兩個鄰居：節點 2 和 4 ，
節點 4 的值是 4，它有兩個鄰居：節點 1 和 3 ，
示例 2：

輸入：adjList = [[]]
輸出：[[]]
解釋：輸入包含一個空串列，該圖僅僅只有一個值為 1 的節點，它沒有任何鄰居，
示例 3：

輸入：adjList = []
輸出：[]
解釋：這個圖是空的，它不含任何節點，
示例 4：

輸入：adjList = [[2],[1]]
輸出：[[2],[1]]
 

提示：

節點數不超過 100 ，
每個節點值 Node.val 都是唯一的，1 <= Node.val <= 100，
無向圖是一個簡單圖，這意味著圖中沒有重復的邊，也沒有自環，
由于圖是無向的，如果節點 p 是節點 q 的鄰居，那么節點 q 也必須是節點 p 的鄰居，
圖是連通圖，你可以從給定節點訪問到所有節點，

給你一個整數陣列 nums 和一個整數 target ，

向陣列中的每個整數前添加 '+' 或 '-' ，然后串聯起所有整數，可以構造一個 運算式 ：

例如，nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加 '-' ，然后串聯起來得到運算式 "+2-1" ，
回傳可以通過上述方法構造的、運算結果等于 target 的不同 運算式 的數目，

示例 1：

輸入：nums = [1,1,1,1,1], target = 3
輸出：5
解釋：一共有 5 種方法讓最終目標和為 3 ，
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3
示例 2：

輸入：nums = [1], target = 1
輸出：1
 

提示：

1 <= nums.length <= 20
0 <= nums[i] <= 1000
0 <= sum(nums[i]) <= 1000
-1000 <= target <= 1000

給定一個二叉樹的根節點 root ，回傳它的 中序 遍歷，

示例 1：

輸入：root = [1,null,2,3]
輸出：[1,3,2]
示例 2：

輸入：root = []
輸出：[]
示例 3：

輸入：root = [1]
輸出：[1]
示例 4：

輸入：root = [1,2]
輸出：[2,1]
示例 5：

輸入：root = [1,null,2]
輸出：[1,2]

請你僅使用兩個堆疊實作先入先出佇列，佇列應當支持一般佇列支持的所有操作（push、pop、peek、empty）：

實作 MyQueue 類：

void push(int x) 將元素 x 推到佇列的末尾
int pop() 從佇列的開頭移除并回傳元素
int peek() 回傳佇列開頭的元素
boolean empty() 如果佇列為空，回傳 true ；否則，回傳 false
 

說明：

你只能使用標準的堆疊操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的，
你所使用的語言也許不支持堆疊，你可以使用 list 或者 deque（雙端佇列）來模擬一個堆疊，只要是標準的堆疊操作即可，
 

進階：

你能否實作每個操作均攤時間復雜度為 O(1) 的佇列？換句話說，執行 n 個操作的總時間復雜度為 O(n) ，即使其中一個操作可能花費較長時間，
 

示例：

輸入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
輸出：
[null, null, null, 1, 1, false]

解釋：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false
 

提示：

1 <= x <= 9
最多呼叫 100 次 push、pop、peek 和 empty
假設所有操作都是有效的 （例如，一個空的佇列不會呼叫 pop 或者 peek 操作）

請你僅使用兩個佇列實作一個后入先出（LIFO）的堆疊，并支持普通堆疊的全部四種操作（push、top、pop 和 empty），

實作 MyStack 類：

void push(int x) 將元素 x 壓入堆疊頂，
int pop() 移除并回傳堆疊頂元素，
int top() 回傳堆疊頂元素，
boolean empty() 如果堆疊是空的，回傳 true ；否則，回傳 false ，
 

注意：

你只能使用佇列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 這些操作，
你所使用的語言也許不支持佇列， 你可以使用 list （串列）或者 deque（雙端佇列）來模擬一個佇列 , 只要是標準的佇列操作即可，
 

示例：

輸入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
輸出：
[null, null, null, 2, 2, false]

解釋：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 回傳 2
myStack.pop(); // 回傳 2
myStack.empty(); // 回傳 False
 

提示：

1 <= x <= 9
最多呼叫100 次 push、pop、top 和 empty
每次呼叫 pop 和 top 都保證堆疊不為空
 

進階：你能否實作每種操作的均攤時間復雜度為 O(1) 的堆疊？換句話說，執行 n 個操作的總時間復雜度 O(n) ，盡管其中某個操作可能需要比其他操作更長的時間，你可以使用兩個以上的佇列，

給定一個經過編碼的字串，回傳它解碼后的字串，

編碼規則為: k[encoded_string]，表示其中方括號內部的 encoded_string 正好重復 k 次，注意 k 保證為正整數，

你可以認為輸入字串總是有效的；輸入字串中沒有額外的空格，且輸入的方括號總是符合格式要求的，

此外，你可以認為原始資料不包含數字，所有的數字只表示重復的次數 k ，例如不會出現像 3a 或 2[4] 的輸入，

示例 1：

輸入：s = "3[a]2[bc]"
輸出："aaabcbc"
示例 2：

輸入：s = "3[a2[c]]"
輸出："accaccacc"
示例 3：

輸入：s = "2[abc]3[cd]ef"
輸出："abcabccdcdcdef"
示例 4：

輸入：s = "abc3[cd]xyz"
輸出："abccdcdcdxyz"

有一幅以二維整數陣串列示的圖畫，每一個整數表示該圖畫的像素值大小，數值在 0 到 65535 之間，

給你一個坐標 (sr, sc) 表示影像渲染開始的像素值（行 ，列）和一個新的顏色值 newColor，讓你重新上色這幅影像，

為了完成上色作業，從初始坐標開始，記錄初始坐標的上下左右四個方向上像素值與初始坐標相同的相連像素點，接著再記錄這四個方向上符合條件的像素點與他們對應四個方向上像素值與初始坐標相同的相連像素點，……，重復該程序，將所有有記錄的像素點的顏色值改為新的顏色值，

最后回傳經過上色渲染后的影像，

示例 1:

輸入: 
image = [[1,1,1],[1,1,0],[1,0,1]]
sr = 1, sc = 1, newColor = 2
輸出: [[2,2,2],[2,2,0],[2,0,1]]
決議: 
在影像的正中間，(坐標(sr,sc)=(1,1)),
在路徑上所有符合條件的像素點的顏色都被更改成2，
注意，右下角的像素沒有更改為2，
因為它不是在上下左右四個方向上與初始點相連的像素點，
注意:

image 和 image[0] 的長度在范圍 [1, 50] 內，
給出的初始點將滿足 0 <= sr < image.length 和 0 <= sc < image[0].length，
image[i][j] 和 newColor 表示的顏色值在范圍 [0, 65535]內，

給定一個由 0 和 1 組成的矩陣 mat ，請輸出一個大小相同的矩陣，其中每一個格子是 mat 中對應位置元素到最近的 0 的距離，

兩個相鄰元素間的距離為 1 ，

示例 1：

輸入：mat = [[0,0,0],[0,1,0],[0,0,0]]
輸出：[[0,0,0],[0,1,0],[0,0,0]]
示例 2：

輸入：mat = [[0,0,0],[0,1,0],[1,1,1]]
輸出：[[0,0,0],[0,1,0],[1,2,1]]
 

提示：

m == mat.length
n == mat[i].length
1 <= m, n <= 104
1 <= m * n <= 104
mat[i][j] is either 0 or 1.
mat 中至少有一個 0 

有 n 個房間，房間按從 0 到 n - 1 編號，最初，除 0 號房間外的其余所有房間都被鎖住，你的目標是進入所有的房間，然而，你不能在沒有獲得鑰匙的時候進入鎖住的房間，

當你進入一個房間，你可能會在里面找到一套不同的鑰匙，每把鑰匙上都有對應的房間號，即表示鑰匙可以打開的房間，你可以拿上所有鑰匙去解鎖其他房間，

給你一個陣列 rooms 其中 rooms[i] 是你進入 i 號房間可以獲得的鑰匙集合，如果能進入 所有 房間回傳 true，否則回傳 false，

示例 1：

輸入：rooms = [[1],[2],[3],[]]
輸出：true
解釋：
我們從 0 號房間開始，拿到鑰匙 1，
之后我們去 1 號房間，拿到鑰匙 2，
然后我們去 2 號房間，拿到鑰匙 3，
最后我們去了 3 號房間，
由于我們能夠進入每個房間，我們回傳 true，
示例 2：

輸入：rooms = [[1,3],[3,0,1],[2],[0]]
輸出：false
解釋：我們不能進入 2 號房間，
 

提示：

n == rooms.length
2 <= n <= 1000
0 <= rooms[i].length <= 1000
1 <= sum(rooms[i].length) <= 3000
0 <= rooms[i][j] < n
所有 rooms[i] 的值 互不相同