LeetCode部分題解（二）
LeetCode部分題解（二）
1、[237. 刪除連結串列中的節點
請編寫一個函式，使其可以刪除某個連結串列中給定的（非末尾）節點。傳入函式的唯一引數為 要被刪除的節點 。
現有一個連結串列 – head = [4,5,1,9]，它可以表示為:
示例 1：
輸入：head = [4,5,1,9], node = 5
輸出：[4,1,9]
解釋：給定你連結串列中值為 5 的第二個節點，那麼在呼叫了你的函式之後，該連結串列應變為 4 -> 1 -> 9.
示例 2：
輸入：head = [4,5,1,9], node = 1
輸出：[4,5,9]
提示：
連結串列至少包含兩個節點。
連結串列中所有節點的值都是唯一的。
給定的節點為非末尾節點並且一定是連結串列中的一個有效節點。
不要從你的函式中返回任何結果。
之前寫過一樣的題，把本節點變成下一個節點，然後刪除下一個節點即可
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None 2、[1603. 設計停車系統
請你給一個停車場設計一個停車系統。停車場總共有三種不同大小的車位：大，中和小，每種尺寸分別有固定數目的車位。
請你實現 ParkingSystem 類：
ParkingSystem(int big, int medium, int small) 初始化 ParkingSystem 類，三個引數分別對應每種停車位的數目。
bool addCar(int carType) 檢查是否有 carType 對應的停車位。 carType 有三種類型：大，中，小，分別用數字 1， 2 和 3 表示。一輛車只能停在 carType 對應尺寸的停車位中。如果沒有空車位，請返回 false ，否則將該車停入車位並返回 true 。
示例 1：
輸入：
[“ParkingSystem”, “addCar”, “addCar”, “addCar”, “addCar”]
[[1, 1, 0], [1], [2], [3], [1]]
輸出：
[null, true, true, false, false]
解釋：
ParkingSystem parkingSystem = new ParkingSystem(1, 1, 0);
parkingSystem.addCar(1); // 返回 true ，因為有 1 個空的大車位
parkingSystem.addCar(2); // 返回 true ，因為有 1 個空的中車位
parkingSystem.addCar(3); // 返回 false ，因為沒有空的小車位
parkingSystem.addCar(1); // 返回 false ，因為沒有空的大車位，唯一一個大車位已經被佔據了
提示：
0 <= big, medium, small <= 1000
carType 取值為 1， 2 或 3
最多會呼叫 addCar 函式 1000 次
就是模擬整個過程，按照要求寫下程式碼即可
class ParkingSystem:
def __init__(self, big: int, medium: int, small: int):
self.big = big
self.medium = medium
self.small = small
def addCar(self, carType: int) -> bool:
if carType == 3:
if self.small != 0:
self.small -= 1
return True
else:
return False
if carType == 2:
if self.medium != 0:
self.medium -= 1
return True
else:
return False
if carType == 1:
if self.big != 0:
self.big -= 1
return True
else:
return False
# Your ParkingSystem object will be instantiated and called as such:
# obj = ParkingSystem(big, medium, small)
# param_1 = obj.addCar(carType)
3、1108. IP 地址無效化
給你一個有效的 IPv4 地址 address，返回這個 IP 地址的無效化版本。
所謂無效化 IP 地址，其實就是用 “[.]” 代替了每個 “.”。
示例 1：
輸入：address = “1.1.1.1”
輸出：“1[.]1[.]1[.]1”
示例 2：
輸入：address = “255.100.50.0”
輸出：“255[.]100[.]50[.]0”
提示：
給出的 address 是一個有效的 IPv4 地址
這道題如果我們一個一個去遍歷可能還要花點功夫，如果我們使用replace函式，就又是一個一行秒
class Solution:
def defangIPaddr(self, address: str) -> str:
return address.replace('.','[.]')
4、1678. 設計 Goal 解析器
請你設計一個可以解釋字串 command 的 Goal 解析器 。command 由 “G”、"()" 和/或 “(al)” 按某種順序組成。Goal 解析器會將 “G” 解釋為字串 “G”、"()" 解釋為字串 “o” ，"(al)" 解釋為字串 “al” 。然後，按原順序將經解釋得到的字串連線成一個字串。
給你字串 command ，返回 Goal 解析器 對 command 的解釋結果。
示例 1：
輸入：command = “G()(al)”
輸出：“Goal”
解釋：Goal 解析器解釋命令的步驟如下所示：
G -> G
() -> o
(al) -> al
最後連線得到的結果是 “Goal”
示例 2：
輸入：command = “G()()()()(al)”
輸出：“Gooooal”
示例 3：
輸入：command = “(al)G(al)()()G”
輸出：“alGalooG”
提示：
1 <= command.length <= 100
command 由 “G”、"()" 和/或 “(al)” 按某種順序組成
這道題和上道題一樣，直接替換解決
class Solution:
def interpret(self, command: str) -> str:
comand = command.replace('()','o')
return comand.replace('(al)','al')
5、LCP 06. 拿硬幣
桌上有 n 堆力扣幣，每堆的數量儲存在陣列 coins 中。我們每次可以選擇任意一堆，拿走其中的一枚或者兩枚，求拿完所有力扣幣的最少次數。
示例 1：
輸入：[4,2,1]
輸出：4
解釋：第一堆力扣幣最少需要拿 2 次，第二堆最少需要拿 1 次，第三堆最少需要拿 1 次，總共 4 次即可拿完。
示例 2：
輸入：[2,3,10]
輸出：8
限制：
1 <= n <= 4
1 <= coins[i] <= 10
這道題也是按照他的要求，奇數先拿一枚變偶數，偶數一次拿兩枚即可
class Solution:
def minCount(self, coins: List[int]) -> int:
ans = 0
for coin in coins:
ans += int(coin / 2)
ans += coin % 2
return ans
6、1684. 統計一致字符串的數目
給你一個由不同字元組成的字串 allowed 和一個字串陣列 words 。如果一個字串的每一個字元都在 allowed 中，就稱這個字串是 一致字符串 。
請你返回 words 陣列中 一致字符串 的數目。
示例 1：
輸入：allowed = “ab”, words = [“ad”,“bd”,“aaab”,“baa”,“badab”]
輸出：2
解釋：字串 “aaab” 和 “baa” 都是一致字符串，因為它們只包含字元 ‘a’ 和 ‘b’ 。
示例 2：
輸入：allowed = “abc”, words = [“a”,“b”,“c”,“ab”,“ac”,“bc”,“abc”]
輸出：7
解釋：所有字串都是一致的。
示例 3：
輸入：allowed = “cad”, words = [“cc”,“acd”,“b”,“ba”,“bac”,“bad”,“ac”,“d”]
輸出：4
解釋：字串 “cc”，“acd”，“ac” 和 “d” 是一致字符串。
提示：
1 <= words.length <= 104
1 <= allowed.length <= 26
1 <= words[i].length <= 10
allowed 中的字元 互不相同 。
words[i] 和 allowed 只包含小寫英文字母。
這道題如果我們一個一個去匹配同樣是比較麻煩的，所以這裡我們可以用python中的集合中元素不重複的特點，只需找出所有子集即可
class Solution:
def countConsistentStrings(self, allowed: str, words: List[str]) -> int:
ans = 0
for word in words:
if set(allowed).issuperset(set(word)):
ans+=1
return ans
7、535. TinyURL 的加密與解密
TinyURL是一種URL簡化服務， 比如：當你輸入一個URL https://leetcode.com/problems/design-tinyurl 時，它將返回一個簡化的URL http://tinyurl.com/4e9iAk.
要求：設計一個 TinyURL 的加密 encode 和解密 decode 的方法。你的加密和解密演算法如何設計和運作是沒有限制的，你只需要保證一個URL可以被加密成一個TinyURL，並且這個TinyURL可以用解密方法恢復成原本的URL。
這道題的判題是有些問題的，他只看加密並解密之後結果是否和之前一致，所以哪怕我們什麼都不做都可以AC的，當然這道題我們也可以設計自己的密碼來過，還是比較開放的
class Codec:
def encode(self, longUrl: str) -> str:
"""Encodes a URL to a shortened URL.
"""
return longUrl
def decode(self, shortUrl: str) -> str:
"""Decodes a shortened URL to its original URL.
"""
return shortUrl
# Your Codec object will be instantiated and called as such:
# codec = Codec()
# codec.decode(codec.encode(url))
8、807. 保持城市天際線
在二維陣列grid中，grid[i][j]代表位於某處的建築物的高度。 我們被允許增加任何數量（不同建築物的數量可能不同）的建築物的高度。 高度 0 也被認為是建築物。
最後，從新陣列的所有四個方向（即頂部，底部，左側和右側）觀看的“天際線”必須與原始陣列的天際線相同。 城市的天際線是從遠處觀看時，由所有建築物形成的矩形的外部輪廓。 請看下面的例子。
建築物高度可以增加的最大總和是多少？
例子：
輸入： grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]
輸出： 35
解釋：
The grid is:
[ [3, 0, 8, 4],
[2, 4, 5, 7],
[9, 2, 6, 3],
[0, 3, 1, 0] ]
從陣列豎直方向（即頂部，底部）看“天際線”是：[9, 4, 8, 7]
從水平水平方向（即左側，右側）看“天際線”是：[8, 7, 9, 3]
在不影響天際線的情況下對建築物進行增高後，新陣列如下：
gridNew = [ [8, 4, 8, 7],
[7, 4, 7, 7],
[9, 4, 8, 7],
[3, 3, 3, 3] ]
說明:
1 < grid.length = grid[0].length <= 50。
grid[i][j] 的高度範圍是： [0, 100]。
一座建築物佔據一個grid[i][j]：換言之，它們是 1 x 1 x grid[i][j] 的長方體。
先遍歷一下，把天際線找出來，然後為了不影響天際線，每個建築都不能超過他對應的橫縱天際線，換句話說，就是加上建築物高度和對應橫縱天際線的差值
class Solution:
def maxIncreaseKeepingSkyline(self, grid: List[List[int]]) -> int:
tran = [0 for i in range(len(grid[0]))]
vert = [0 for i in range(len(grid))]
for i in range(len(grid)):
for j in range(len(grid[0])):
if grid[i][j] > tran[j]:
tran[j] = grid[i][j]
if grid[i][j] > vert[i]:
vert[i] = grid[i][j]
ans = 0
for i in range(len(grid)):
for j in range(len(grid[0])):
ans += min(tran[j],vert[i]) - grid[i][j]
return ans
9、1379. 找出克隆二叉樹中的相同節點
給你兩棵二叉樹，原始樹 original 和克隆樹 cloned，以及一個位於原始樹 original 中的目標節點 target。
其中，克隆樹 cloned 是原始樹 original 的一個 副本 。
請找出在樹 cloned 中，與 target 相同 的節點，並返回對該節點的引用（在 C/C++ 等有指標的語言中返回 節點指標，其他語言返回節點本身）。
注意：
你 不能 對兩棵二叉樹，以及 target 節點進行更改。
只能 返回對克隆樹 cloned 中已有的節點的引用。
進階：如果樹中允許出現值相同的節點，你將如何解答？
示例 1
輸入: tree = [7,4,3,null,null,6,19], target = 3
輸出: 3
示例 2:
輸入: tree = [7], target = 7
輸出: 7
示例 3:
輸入: tree = [8,null,6,null,5,null,4,null,3,null,2,null,1], target = 4
輸出: 4
示例 4:
輸入: tree = [1,2,3,4,5,6,7,8,9,10], target = 5
輸出: 5
示例 5:
輸入: tree = [1,2,null,3], target = 2
輸出: 2
提示：
樹中節點的數量範圍為 [1, 10^4] 。
同一棵樹中，沒有值相同的節點。
target 節點是樹 original 中的一個節點，並且不會是 null 。
這道題不清楚python的機制什麼情況，必須要判斷結點是否為空，否則找不到值，但基本的做法就是遍歷，怎麼遍歷應該都可以，因為沒有重複。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def getTargetCopy(self, original: TreeNode, cloned: TreeNode, target: TreeNode) -> TreeNode:
def f(node):
if not node:
return None
if node.val==target.val:
self.res=node
f(node.left)
f(node.right)
f(cloned)
return self.res
10、1281. 整數的各位積和之差
給你一個整數 n，請你幫忙計算並返回該整數「各位數字之積」與「各位數字之和」的差。
示例 1：
輸入：n = 234
輸出：15
解釋：
各位數之積 = 2 * 3 * 4 = 24
各位數之和 = 2 + 3 + 4 = 9
結果 = 24 - 9 = 15
示例 2：
輸入：n = 4421
輸出：21
解釋：
各位數之積 = 4 * 4 * 2 * 1 = 32
各位數之和 = 4 + 4 + 2 + 1 = 11
結果 = 32 - 11 = 21
提示：
1 <= n <= 10^5
把數字切割，每一位進行遍歷即可
class Solution:
def subtractProductAndSum(self, n: int) -> int:
pro = 1
add = 0
while n != 0:
pro *= int(n % 10)
add += int(n % 10)
n /= 10
n = int(n)
return int(pro - add)
11、1389. 按既定順序建立目標陣列
給你兩個整數陣列 nums 和 index。你需要按照以下規則建立目標陣列：
目標陣列 target 最初為空。
按從左到右的順序依次讀取 nums[i] 和 index[i]，在 target 陣列中的下標 index[i] 處插入值 nums[i] 。
重複上一步，直到在 nums 和 index 中都沒有要讀取的元素。
請你返回目標陣列。
題目保證數字插入位置總是存在。
示例 1：
輸入：nums = [0,1,2,3,4], index = [0,1,2,2,1]
輸出：[0,4,1,3,2]
解釋：
nums index target
0 0 [0]
1 1 [0,1]
2 2 [0,1,2]
3 2 [0,1,3,2]
4 1 [0,4,1,3,2]
示例 2：
輸入：nums = [1,2,3,4,0], index = [0,1,2,3,0]
輸出：[0,1,2,3,4]
解釋：
nums index target
1 0 [1]
2 1 [1,2]
3 2 [1,2,3]
4 3 [1,2,3,4]
0 0 [0,1,2,3,4]
示例 3：
輸入：nums = [1], index = [0]
輸出：[1]
提示：
1 <= nums.length, index.length <= 100
nums.length == index.length
0 <= nums[i] <= 100
0 <= index[i] <= i
python寫這個題比較無腦，直接insert按要求填入引數即可
class Solution:
def createTargetArray(self, nums: List[int], index: List[int]) -> List[int]:
target = []
for i in range(len(nums)):
target.insert(index[i],nums[i])
return target
12、1313. 解壓縮編碼列表
給你一個以行程長度編碼壓縮的整數列表 nums 。
考慮每對相鄰的兩個元素 [freq, val] = [nums[2i], nums[2i+1]] （其中 i >= 0 ），每一對都表示解壓後子列表中有 freq 個值為 val 的元素，你需要從左到右連線所有子列表以生成解壓後的列表。
請你返回解壓後的列表。
示例：
輸入：nums = [1,2,3,4]
輸出：[2,4,4,4]
解釋：第一對 [1,2] 代表著 2 的出現頻次為 1，所以生成陣列 [2]。
第二對 [3,4] 代表著 4 的出現頻次為 3，所以生成陣列 [4,4,4]。
最後將它們串聯到一起 [2] + [4,4,4] = [2,4,4,4]。
示例 2：
輸入：nums = [1,1,2,3]
輸出：[1,3,3]
提示：
2 <= nums.length <= 100
nums.length % 2 == 0
1 <= nums[i] <= 100
這道題直接遍歷然後按照要求把數字壓入ans陣列然後返回即可
class Solution:
def decompressRLElist(self, nums: List[int]) -> List[int]:
ans = []
for i in range(0,len(nums),2):
for j in range(nums[i]):
ans.append(nums[i+1])
return ans