資訊專欄INFORMATION COLUMN
摘要：第五題對稱二叉樹難度簡單給定一個(gè)二叉樹，檢查它是否是鏡像對稱的。第十六題最大連續(xù)的個(gè)數(shù)難度簡單給定一個(gè)二進(jìn)制數(shù)組，計(jì)算其中最大連續(xù)的個(gè)數(shù)。第十八題平方數(shù)之和難度簡單給定一個(gè)非負(fù)整數(shù)，你要判斷是否存在兩個(gè)整數(shù)和，使得。
寫在前面
最近忙著調(diào)教新裝備，沒有及時(shí)的寫題解，但是沒有在偷懶沒刷題喔~
來認(rèn)真整理下最近做的題目~
之前考慮按tag來刷題，后來收到了推薦的leetcode題解，就根據(jù)上面的說明陸續(xù)刷題啦~
tag主要做了：數(shù)組、雙指針
找時(shí)間要開始部署gitbook了，然后將題解部署到電子書上~
387. 字符串中的第一個(gè)唯一字符
難度：簡單
給定一個(gè)字符串，找到它的第一個(gè)不重復(fù)的字符，并返回它的索引。如果不存在，則返回-1。
案例:
s = "leetcode"
返回 0.
s = "loveleetcode",
返回 2.
我的題解：
class Solution(object):
def firstUniqChar(self, s):
"""
:type s: str
:rtype: int
"""
mapa = dict()
for i in s:
if i not in mapa:
mapa[i] = 1
else:
mapa[i] += 1
for j in range(len(s)):
a = s[j]
if a in mapa and mapa[a] == 1:
return j
return -1
我的思路：
做兩次循環(huán)，第一次循環(huán)用來做映射表，用hash表可以快速查詢。
第二遍從頭檢查，在hash表中僅出現(xiàn)一次的字母，即最早不重復(fù)的字母。
283. 移動零
難度：簡單
給定一個(gè)數(shù)組 nums，編寫一個(gè)函數(shù)將所有0移動到數(shù)組的末尾，同時(shí)保持非零元素的相對順序。
案例:
輸入: [0,1,0,3,12]
輸出: [1,3,12,0,0]
返回 2.
我的題解：
class Solution(object):
def moveZeroes(self, nums):
"""
:type nums: List[int]
:rtype: None Do not return anything, modify nums in-place instead.
"""
l = len(nums)
j = 0
for i in range(l):
if nums[i] !=0:
nums[j] = nums[i]
j +=1
nums[j:l] = [0 for i in range(l-j)]
我的思路：
從頭遍歷數(shù)組，如果對應(yīng)數(shù)組的值不為0，則利用慢指針，將非零項(xiàng)向前移動歸并。
最后一個(gè)非零項(xiàng)對應(yīng)的索引到數(shù)組的最后則被0包圍了~
268. 缺失數(shù)字
難度：簡單
給定一個(gè)包含0, 1, 2, ..., n中 n 個(gè)數(shù)的序列，找出 0 .. n 中沒有出現(xiàn)在序列中的那個(gè)數(shù)。
案例:
輸入: [3,0,1]
輸出: 2
輸入: [9,6,4,2,3,5,7,0,1]
輸出: 8
我的題解：
class Solution(object):
def missingNumber(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
sum = 0
l =len(nums)
sum_a = (1+l)*l/2
for i in nums:
sum += i
return sum_a - sum```
我的思路：
缺少的值 = 未缺失數(shù)的序列綜合 - 當(dāng)前的序列總和
229. 求眾數(shù) II
難度：簡單
給定一個(gè)大小為 n 的數(shù)組，找出其中所有出現(xiàn)超過? n/3 ?次的元素。
說明: 要求算法的時(shí)間復(fù)雜度為O(n)，空間復(fù)雜度為O(1)。
案例:
輸入: [3,2,3]
輸出: [3]
輸入: [1,1,1,3,3,2,2,2]
輸出: [1,2]
我的題解：
class Solution(object):
def majorityElement(self, nums):
"""
:type nums: List[int]
:rtype: List[int]
"""
a = dict()
b = list()
n = len(nums) / 3
for i in nums:
if i not in a:
a[i] = 1
else:
a[i] += 1
for j in a:
if a[j] > n:
b.append(j)
return b
我的思路：
同第一題的思路一致，兩次循環(huán)，第一次檢查每個(gè)數(shù)的重復(fù)情況。
第二遍循環(huán)用于找出對應(yīng)的值。
101. 對稱二叉樹
難度：簡單
給定一個(gè)二叉樹，檢查它是否是鏡像對稱的。
例如，二叉樹[1,2,2,3,4,4,3]是對稱的。
但是下面這個(gè)[1,2,2,null,3,null,3]則不是鏡像對稱的:
我的題解：
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def isSymmetric(self, root):
"""
:type root: TreeNode
:rtype: bool
"""
if not root:
return True
return self.isSame(root.left,root.right)
def isSame(self,leftNode,rightNode):
if leftNode == None:
return rightNode == None
if rightNode == None:
return leftNode == None
if rightNode.val == leftNode.val:
return self.isSame(leftNode.left,rightNode.right) and self.isSame(leftNode.right,rightNode.left)
return False
我的思路：
使用遞歸的思路，跳出條件為，左右節(jié)點(diǎn)不一致，包括兩者某一個(gè)為空的情況。
當(dāng)還存在下一級的左右節(jié)點(diǎn)的時(shí)候，就做遞歸進(jìn)行查找。
905. 按奇偶排序數(shù)組
難度：簡單
給定一個(gè)非負(fù)整數(shù)數(shù)組A，返回一個(gè)由A的所有偶數(shù)元素組成的數(shù)組，后面跟A的所有奇數(shù)元素。
你可以返回滿足此條件的任何數(shù)組作為答案。
示例：
輸入：[3,1,2,4]
輸出：[2,4,3,1]
輸出 [4,2,3,1]，[2,4,1,3] 和 [4,2,1,3] 也會被接受。
我的題解：
class Solution(object):
def sortArrayByParity(self, A):
"""
:type A: List[int]
:rtype: List[int]
"""
n = [0]*len(A)
k = 0
j = len(A) - 1
for i in range(len(A)):
if A[i] % 2 ==1: #奇數(shù)
n[j] = A[i]
j -= 1
else:
n[k] = A[i]
k += 1
return n
我的思路：
新建一個(gè)數(shù)組，然后頭尾兩個(gè)指針，分別用于指向偶數(shù)和奇數(shù)。
832. 翻轉(zhuǎn)圖像
難度：簡單
給定一個(gè)二進(jìn)制矩陣A，我們想先水平翻轉(zhuǎn)圖像，然后反轉(zhuǎn)圖像并返回結(jié)果。
水平翻轉(zhuǎn)圖片就是將圖片的每一行都進(jìn)行翻轉(zhuǎn)，即逆序。例如，水平翻轉(zhuǎn)[1, 1, 0]的結(jié)果是[0, 1, 1]。
反轉(zhuǎn)圖片的意思是圖片中的0全部被1替換，1全部被0替換。例如，反轉(zhuǎn)[0, 1, 1]的結(jié)果是[1, 0, 0]。
我的題解：
class Solution(object):
def flipAndInvertImage(self, A):
"""
:type A: List[List[int]]
:rtype: List[List[int]]
"""
#逆序
return [[j ^ 1 for j in i[::-1]] for i in A]
我的思路：
python感覺有很多小作弊的方式，比如這題先進(jìn)行了逆序，然后再進(jìn)行了位運(yùn)算。
僅僅用了一行代碼也是很奇特了。
922. 按奇偶排序數(shù)組 II
難度：簡單
給定一個(gè)非負(fù)整數(shù)數(shù)組A，A中一半整數(shù)是奇數(shù)，一半整數(shù)是偶數(shù)。
對數(shù)組進(jìn)行排序，以便當(dāng)A[i]為奇數(shù)時(shí)，i也是奇數(shù)；當(dāng)A[i]為偶數(shù)時(shí)，i也是偶數(shù)。
你可以返回任何滿足上述條件的數(shù)組作為答案。
我的題解：
class Solution(object):
def sortArrayByParityII(self, A):
"""
:type A: List[int]
:rtype: List[int]
"""
count0 = 0
count1 = 1
re = []
for i in A:
if i%2 == 0:
re.insert(count0, i)
count0 += 2
else:
re.insert(count1, i)
count1 += 2
return re
我的思路：
適用兩個(gè)指針，一個(gè)從0開始，一個(gè)從1開始，每次的步數(shù)為2，對應(yīng)放入奇數(shù)和偶數(shù)幾顆。
509. 斐波那契數(shù)
難度：簡單
斐波那契數(shù)，通常用F(n)表示，形成的序列稱為斐波那契數(shù)列。該數(shù)列由0和1開始，后面的每一項(xiàng)數(shù)字都是前面兩項(xiàng)數(shù)字的和。也就是：
F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
給定N，計(jì)算F(N)。
我的題解：
class Solution(object):
def fib(self, N):
"""
:type N: int
:rtype: int
"""
if N == 0:return 0
if N==1 or N == 2:return 1
return (self.fib(N-1)+self.fib(N-2))
我的思路：
因?yàn)槊恳粋€(gè)數(shù)的構(gòu)成，都是由前面的數(shù)的基礎(chǔ)構(gòu)成，所以用遞歸的思路去尋找遞歸棧。
遞歸棧的跳出條件為：n=0/1/2。
561. 數(shù)組拆分 I
難度：簡單
給定長度為2n的數(shù)組, 你的任務(wù)是將這些數(shù)分成 n 對, 例如 (a1, b1), (a2, b2), ..., (an, bn) ，使得從1 到 n 的 min(ai, bi) 總和最大。
輸入: [1,4,3,2]輸出: 4
解釋: n 等于 2, 最大總和為 4 = min(1, 2) + min(3, 4).
提示:
n 是正整數(shù),范圍在 [1, 10000].
數(shù)組中的元素范圍在 [-10000, 10000].
我的題解：
class Solution(object):
def arrayPairSum(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
nums.sort()
return sum(nums[::2])
我的思路：
最大的算法，其實(shí)是排序后獲取2個(gè)一組中最小的那個(gè)數(shù)，獲得的總值最大。
867. 轉(zhuǎn)置矩陣
難度：簡單
給定一個(gè)矩陣A， 返回A的轉(zhuǎn)置矩陣。
矩陣的轉(zhuǎn)置是指將矩陣的主對角線翻轉(zhuǎn)，交換矩陣的行索引與列索引。
我的題解：
class Solution(object):
def transpose(self, A):
"""
:type A: List[List[int]]
:rtype: List[List[int]]
"""
return zip(*A)
我的思路：
zip()函數(shù)，打包為元組的列表。
zip(*)返回二維矩陣。--->解壓
1002. 查找常用字符
難度：簡單
給定僅有小寫字母組成的字符串?dāng)?shù)組 A，返回列表中的每個(gè)字符串中都顯示的全部字符（包括重復(fù)字符）組成的列表。例如，如果一個(gè)字符在每個(gè)字符串中出現(xiàn)3次，但不是4次，則需要在最終答案中包含該字符3次。
你可以按任意順序返回答案。
示例 1：
輸入：["bella","label","roller"]
輸出：["e","l","l"]
我的題解：
class Solution(object):
def commonChars(self, A):
"""
:type A: List[str]
:rtype: List[str]
"""
tmp = list(A[0])
for i in range(1,len(A)):
tmp_list =list()
for j in A[i]:
if j in tmp:
index = tmp.index(j)
del tmp[index]
tmp_list.append(j)
tmp = tmp_list
return tmp
我的思路：
最基礎(chǔ)的思路是雙重循環(huán)，外層數(shù)組要是遍歷一維，內(nèi)層主要是循環(huán)每個(gè)二維。
最開始以a[0]作為重復(fù)值的參考，如果比對過程中發(fā)現(xiàn)了重復(fù)的值，就記錄下來，并因?yàn)榭紤]到參考值本身可能存在重復(fù)值，所以刪除對應(yīng)索引上的值，并根據(jù)記錄下來的重復(fù)值，不斷的遍歷過程中，就減少，最終獲得的就是正確值。
350. 兩個(gè)數(shù)組的交集 II
難度：簡單
給定兩個(gè)數(shù)組，編寫一個(gè)函數(shù)來計(jì)算它們的交集。
示例 1:
輸入: nums1 = [1,2,2,1], nums2 = [2,2]
輸出: [2,2]
輸入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
輸出: [4,9]
說明：
輸出結(jié)果中每個(gè)元素出現(xiàn)的次數(shù)，應(yīng)與元素在兩個(gè)數(shù)組中出現(xiàn)的次數(shù)一致。
我們可以不考慮輸出結(jié)果的順序。
我的題解：
class Solution(object):
def intersect(self, nums1, nums2):
"""
:type nums1: List[int]
:type nums2: List[int]
:rtype: List[int]
"""
l = list()
for i in nums2:
if i in nums1:
index = nums1.index(i)
del nums1[index]
l.append(i)
return l
我的思路：
另外增加一個(gè)數(shù)組用于記錄重復(fù)值，因?yàn)榭赡艽嬖谕瑐€(gè)數(shù)組中重復(fù)值，所以需要?jiǎng)h除對應(yīng)的索引上的值。
349. 兩個(gè)數(shù)組的交集
難度：簡單
給定兩個(gè)數(shù)組，編寫一個(gè)函數(shù)來計(jì)算它們的交集。
示例:
輸入: nums1 = [1,2,2,1], nums2 = [2,2]
輸出: [2]
輸入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
輸出: [9,4]
說明:
輸出結(jié)果中的每個(gè)元素一定是唯一的。
我們可以不考慮輸出結(jié)果的順序。
我的題解：
class Solution(object):
def intersection(self, nums1, nums2):
"""
:type nums1: List[int]
:type nums2: List[int]
:rtype: List[int]
"""
l = dict()
a = list()
for i in nums2:
if i in nums1:
if i not in l:
l[i] = 1
for key in l:
a.append(key)
return a
我的思路：
循環(huán)其中一個(gè)數(shù)組，并新建hash記錄重復(fù)值。最后遍歷hash表，得出最終結(jié)果。
566. 重塑矩陣
難度：簡單
在MATLAB中，有一個(gè)非常有用的函數(shù)reshape，它可以將一個(gè)矩陣重塑為另一個(gè)大小不同的新矩陣，但保留其原始數(shù)據(jù)。
給出一個(gè)由二維數(shù)組表示的矩陣，以及兩個(gè)正整數(shù)r和c，分別表示想要的重構(gòu)的矩陣的行數(shù)和列數(shù)。
重構(gòu)后的矩陣需要將原始矩陣的所有元素以相同的行遍歷順序填充。
如果具有給定參數(shù)的reshape操作是可行且合理的，則輸出新的重塑矩陣；否則，輸出原始矩陣。
示例：
輸入:
nums =
[[1,2],
[3,4]]
r = 1, c = 4
輸出:
[[1,2,3,4]]
解釋:
行遍歷nums的結(jié)果是 [1,2,3,4]。新的矩陣是 1 * 4 矩陣, 用之前的元素值一行一行填充新矩陣。
我的題解：
class Solution(object):
def matrixReshape(self, nums, r, c):
"""
:type nums: List[List[int]]
:type r: int
:type c: int
:rtype: List[List[int]]
"""
l_a = len(nums)
l_b = len(nums[0])
if l_a*l_b != r*c:
return nums
if l_a == r:
return nums
list_a = list()
list_b = list()
count = 0
for i in range(l_a):
for j in range(l_b):
list_b.append(nums[i][j])
count += 1
if count == c:
list_a.append(list_b)
list_b = list()
count = 0
return list_a
我的思路：
首先判斷行數(shù)和列數(shù)是否和給出的值一致，乘積是否一致，用于判斷是否是否直接輸出結(jié)果或者是否可行。
然后新建兩個(gè)數(shù)組用于新建矩陣，遍歷原有矩陣即可。
485. 最大連續(xù)1的個(gè)數(shù)
難度：簡單
給定一個(gè)二進(jìn)制數(shù)組， 計(jì)算其中最大連續(xù)1的個(gè)數(shù)。
示例 1:
輸入: [1,1,0,1,1,1]
輸出: 3
解釋: 開頭的兩位和最后的三位都是連續(xù)1，所以最大連續(xù)1的個(gè)數(shù)是3
注意：
輸入的數(shù)組只包含0和1。
輸入數(shù)組的長度是正整數(shù)，且不超過10,000。
我的題解：
class Solution(object):
def findMaxConsecutiveOnes(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
max_l = 0
count = 0
for i in nums:
if i == 1 :
count +=1
else: ###遇到0
if count > max_l:
max_l = count
count = 0
if count > max_l:
max_l = count
return max_l
我的思路：
使用動態(tài)規(guī)劃的思路，記錄每次的最大值并進(jìn)行比對。最后輸出最大值。
167. 兩數(shù)之和 II - 輸入有序數(shù)組
難度：簡單
給定一個(gè)已按照升序排列 的有序數(shù)組，找到兩個(gè)數(shù)使得它們相加之和等于目標(biāo)數(shù)。
函數(shù)應(yīng)該返回這兩個(gè)下標(biāo)值index1 和index2，其中index1必須小于index2。
說明:
返回的下標(biāo)值（index1 和 index2）不是從零開始的。
你可以假設(shè)每個(gè)輸入只對應(yīng)唯一的答案，而且你不可以重復(fù)使用相同的元素。
我的題解：
class Solution(object):
def twoSum(self, numbers, target):
"""
:type numbers: List[int]
:type target: int
:rtype: List[int]
"""
l = len(numbers)
i = 0
j = l - 1
l_a = list()
while i < j:
if numbers[i]+numbers[j] == target:
l_a.append(i+1)
l_a.append(j+1)
return l_a
elif numbers[i]+numbers[j] > target:
j -= 1
else:
i +=1
return null
我的思路：
使用頭尾兩個(gè)指針，當(dāng)兩者對應(yīng)的值相加，當(dāng)大于目標(biāo)值的時(shí)候，則尾指針左移，當(dāng)小于目標(biāo)值得時(shí)候，則尾指針右移。
633. 平方數(shù)之和
難度：簡單
給定一個(gè)非負(fù)整數(shù) c ，你要判斷是否存在兩個(gè)整數(shù)a和b，使得a2+b2= c。
示例:
輸入: 5
輸出: True
解釋: 1 1 + 2 2 = 5
我的題解：
import math
class Solution(object):
def judgeSquareSum(self, c):
"""
:type c: int
:rtype: bool
"""
a = int(math.sqrt(c))
b = 0
while a > b:
if a**2 + b**2 == c:
return True
elif a**2 + b**2 > c:
a -= 1
else:
b += 1
if a**2 + b**2 == c:
return True
else:
return False
我的思路：
兩個(gè)指針，一個(gè)從0開始，一個(gè)從開方數(shù)開始，不斷逼近，判定是否平方和為對應(yīng)值。
345. 反轉(zhuǎn)字符串中的元音字母
難度：簡單
編寫一個(gè)函數(shù)，以字符串作為輸入，反轉(zhuǎn)該字符串中的元音字母。
示例:
輸入: "hello"
輸出: "holle"
我的題解：
class Solution(object):
def reverseVowels(self, s):
"""
:type s: str
:rtype: str
"""
y = ["a","e","i","o","u","A","E","I","O","U"]
p = 0
q = len(s) - 1
s = list(s)
while p<=q:
if s[q] not in y and s[p] not in y:
p += 1
q -= 1
elif s[p] in y and s[q] not in y:
q -= 1
elif s[q] in y and s[p] not in y:
p += 1
else:
flag = s[q]
s[q] = s[p]
s[p] = flag
p += 1
q -= 1
return "".join(s)
我的思路：
使用自定義hash表，并使用雙指針，不斷逼近，當(dāng)于到兩者都是元音的時(shí)候，進(jìn)行數(shù)值交換。
141. 環(huán)形鏈表
難度：簡單
給定一個(gè)鏈表，判斷鏈表中是否有環(huán)。
為了表示給定鏈表中的環(huán)，我們使用整數(shù) pos 來表示鏈表尾連接到鏈表中的位置（索引從 0 開始）。 如果pos是-1，則在該鏈表中沒有環(huán)。
我的題解：
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def hasCycle(self, head):
"""
:type head: ListNode
:rtype: bool
"""
if not head:
return False
l1 = head
l2 = head.next
while l1 and l2 and l2.next:
if l1 == l2:
return True
l1 = l1.next
l2 = l2.next.next
return False
我的思路：
使用快慢兩個(gè)指針，一個(gè)步數(shù)為1，一個(gè)步數(shù)為2，當(dāng)存在環(huán)的時(shí)候，兩者一定會相遇。
985. 查詢后的偶數(shù)和
難度：簡單
給出一個(gè)整數(shù)數(shù)組A和一個(gè)查詢數(shù)組queries。
對于第i次查詢，有val=queriesi, index = queriesi，我們會把val加到A[index]上。然后，第i次查詢的答案是A中偶數(shù)值的和。
（此處給定的 index = queriesi 是從 0 開始的索引，每次查詢都會永久修改數(shù)組 A。）
返回所有查詢的答案。
你的答案應(yīng)當(dāng)以數(shù)組 answer 給出，answer[i] 為第 i 次查詢的答案。
示例：
輸入：A = [1,2,3,4], queries = [[1,0],[-3,1],[-4,0],[2,3]]
輸出：[8,6,2,4]
解釋：
開始時(shí)，數(shù)組為 [1,2,3,4]。
將 1 加到 A[0] 上之后，數(shù)組為 [2,2,3,4]，偶數(shù)值之和為 2 + 2 + 4 = 8。
將 -3 加到 A[1] 上之后，數(shù)組為 [2,-1,3,4]，偶數(shù)值之和為 2 + 4 = 6。
將 -4 加到 A[0] 上之后，數(shù)組為 [-2,-1,3,4]，偶數(shù)值之和為 -2 + 4 = 2。
將 2 加到 A[3] 上之后，數(shù)組為 [-2,-1,3,6]，偶數(shù)值之和為 -2 + 6 = 4。
我的題解：
class Solution(object):
def sumEvenAfterQueries(self, A, queries):
"""
:type A: List[int]
:type queries: List[List[int]]
:rtype: List[int]
"""
l =list()
sum = 0
sum_a = 0
for j in A:
if j%2 ==0:
sum_a += j
for i in range(len(queries)):
A[queries[i][1]] += queries[i][0]#增加數(shù)值
if A[queries[i][1]] % 2 ==0:#是偶數(shù)
if queries[i][0]%2 ==0:#是偶數(shù)
sum = sum_a + queries[i][0]
else:#是奇數(shù)
sum = sum_a + A[queries[i][1]]
else:#是奇數(shù)
if queries[i][0]%2 ==0:#是偶數(shù)
sum = sum_a
else:
sum = sum_a - A[queries[i][1]] + queries[i][0]
l.append(sum)
sum_a =sum
return l
我的思路
每次比對前，比對所加數(shù)的奇偶，以及對應(yīng)的數(shù)原有的奇偶。
當(dāng)奇數(shù)+奇數(shù)，則總值加上倆奇數(shù)之和；當(dāng)奇數(shù)+偶數(shù)，則總值不增加；當(dāng)偶數(shù)加偶數(shù)，則總數(shù)增加新增值；當(dāng)偶數(shù)+奇數(shù)，則總值減少原有偶數(shù)值。
按tag來刷，會對對應(yīng)思路有更為深刻的理解，小李要繼續(xù)加油呀！
文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。
轉(zhuǎn)載請注明本文地址：http://systransis.cn/yun/43600.html
摘要：寫在前面今天沒有叨逼叨但是又一次錯(cuò)過了競賽愛睡覺的小李下周要上班，下下周一定要參加了握拳認(rèn)真做題的分割線第一題兩地調(diào)度公司計(jì)劃面試人。第人飛往市的費(fèi)用為，飛往市的費(fèi)用為。示例輸入輸出解釋第一個(gè)人去市，費(fèi)用為。 寫在前面 今天沒有叨逼叨...但是又一次錯(cuò)過了競賽...愛睡覺的小李...下周要上班，下下周一定要參加了（握拳 認(rèn)真做題的分割線 第一題 1029. 兩地調(diào)度公司計(jì)劃面試2N人。...
摘要：第二題漢明距離難度簡單兩個(gè)整數(shù)之間的漢明距離指的是這兩個(gè)數(shù)字對應(yīng)二進(jìn)制位不同的位置的數(shù)目。給出兩個(gè)整數(shù)和，計(jì)算它們之間的漢明距離。第三題買賣股票的最佳時(shí)機(jī)難度簡單給定一個(gè)數(shù)組，它的第個(gè)元素是一支給定股票第天的價(jià)格。 寫在前面 這幾天斷斷續(xù)續(xù)做了題目，也在慢慢體會一些數(shù)據(jù)思維。終于不用邊做視頻邊寫題目啦~開心~把這幾天的題解發(fā)一下~ 認(rèn)真做題的分割線 第一題 977. 有序數(shù)組的平方難度...
摘要：寫在前面今天的小李的目標(biāo)是排序算法，果然還是要下手寫才會更有體會，也更記得住。排序算法冒泡排序主要是比對相鄰兩個(gè)數(shù)之間的大小關(guān)系，不斷將較大值交換至最后。 寫在前面 今天的小李的目標(biāo)是排序算法，果然還是要下手寫才會更有體會，也更記得住。 認(rèn)真做題的分割線 第一題 215. 數(shù)組中的第K個(gè)最大元素難度：中等在未排序的數(shù)組中找到第k個(gè)最大的元素。請注意，你需要找的是數(shù)組排序后的第k個(gè)最大的...
摘要：給定的字符串只含有小寫英文字母，并且長度不超過。其他這題了，要重做看了其他的人的題解，使用的是無限逼近中位值的辦法，理論基礎(chǔ)應(yīng)該是泰勒公式。萬萬沒想到居然用到了泰勒公式手工執(zhí)行了下算法，反而理解的更快，但是泰勒公式還得再復(fù)習(xí)下。 寫在前面的話 今天持續(xù)做題ing，python有意思~今天的題有點(diǎn)虐心...興許是我太笨了...會努力學(xué)習(xí)的！動態(tài)規(guī)劃我來啦~ 開始做題 第一題 459. 重...
摘要：認(rèn)真做題的分割線第一題乘積最大子序列難度中等給定一個(gè)整數(shù)數(shù)組，找出一個(gè)序列中乘積最大的連續(xù)子序列該序列至少包含一個(gè)數(shù)。 寫在前面的話 慢慢轉(zhuǎn)變思路，不再死磕不會做的題，思路可以先借鑒，但是一定要吃透透。上周末看完看完了《算法圖解》，感覺對一些題目的思路有比較大的幫助，但是還是要在實(shí)踐中理解。 認(rèn)真做題的分割線 第一題 152. 乘積最大子序列難度：中等給定一個(gè)整數(shù)數(shù)組nums，找出一個(gè)...
閱讀 3902·2021-09-27 13:35
閱讀 1083·2021-09-24 09:48
閱讀 2912·2021-09-22 15:42
閱讀 2353·2021-09-22 15:28
閱讀 3156·2019-08-30 15:43
閱讀 2624·2019-08-30 13:52
閱讀 2981·2019-08-29 12:48
閱讀 1459·2019-08-26 13:55
