乘積最大子序列
給定一個整數數組 nums ，找出一個序列中乘積最大的連續子序列（該序列至少包含一個數）。
示例 1:
輸入: [2,3,-2,4]
輸出: 6
解釋: 子數組 [2,3] 有最大乘積 6。
示例 2:
輸入: [-2,0,-1]
輸出: 0
解釋: 結果不能爲 2, 因爲 [-2,-1] 不是子數組。
解法：
第一時間想到的是動態規劃，想找當前位置上的乘積最大值，但是發現正負號的問題，即前一個位置上乘積最小值乘以當前位置上的數，可能會變成乘積最大值。
也就是兩個dp數組，簡化一下存儲空間的話，就是兩個值：前一個位置上的乘積最大值和乘積最小值。
每有一個新的數字加入，最大值要麼是當前最大值*新數，要麼是當前最小值（負數）*新數（負數），要麼是新值。
class Solution(object):
def maxProduct(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
cur_min = cur_max = res = nums[0]
for i in range(1, len(nums)):
tmp_max = max(max(cur_min * nums[i], cur_max * nums[i]), nums[i])
tmp_min = min(min(cur_min * nums[i], cur_max * nums[i]), nums[i])
cur_min = tmp_min
cur_max = tmp_max
if cur_max > res:
res = cur_max
return res
旋轉數組
給定一個數組，將數組中的元素向右移動 k 個位置，其中 k 是非負數。
示例 1:
輸入: [1,2,3,4,5,6,7] 和 k = 3
輸出: [5,6,7,1,2,3,4]
解釋:
向右旋轉 1 步: [7,1,2,3,4,5,6]
向右旋轉 2 步: [6,7,1,2,3,4,5]
向右旋轉 3 步: [5,6,7,1,2,3,4]
示例 2:
輸入: [-1,-100,3,99] 和 k = 2
輸出: [3,99,-1,-100]
解釋:
向右旋轉 1 步: [99,-1,-100,3]
向右旋轉 2 步: [3,99,-1,-100]
說明:
儘可能想出更多的解決方案，至少有三種不同的方法可以解決這個問題。
要求使用空間複雜度爲 O(1) 的 原地 算法。
解法：
- 每次將整個數組向右移動一步，移動k次即可
- 運用python數組自帶的切片方法，非常簡單：nums[:]=nums[length-k:] + nums[:length-k]
- 經過3次子數組的 “對稱翻折”：如 [1,2,3,4,5,6,7] 和 k = 3，第一步[1,2,3,4]->[4,3,2,1]，第二步[5,6,7]->[7,6,5]，最後[4,3,2,1,7,6,5]->[5,6,7,1,2,3,4]。
- 從第一個元素開始進行旋轉，逐個將旋轉位置上的元素移到下一個位置，直到旋轉到該元素的初始位置。同時使用一個變量記錄被旋轉的元素數量，顯然完成所有旋轉後旋轉元素數量應該是數組長度。（比較麻煩）
注意：
- k要對len求一下餘
- 不知道爲什麼不能直接nums = list(reversed(nums))，可能是編輯器設置的問題，不過可以通過加上":"實現相同的功能
第三種解法：
class Solution(object):
def rotate(self, nums, k):
"""
:type nums: List[int]
:type k: int
:rtype: None Do not return anything, modify nums in-place instead.
"""
k = k % len(nums)
pos = len(nums) - k
nums[:pos] = list(reversed(nums[:pos]))
nums[pos:] = list(reversed(nums[pos:]))
nums[:] = list(reversed(nums[:]))
第四種解法：
class Solution:
def rotate(self, nums, k):
"""
:type nums: List[int]
:type k: int
:rtype: void Do not return anything, modify nums in-place instead.
"""
if len(nums)>1:
length = len(nums)
k = k%length
if k>0:
move_num = 0
move_pos = 0
move_value = nums[move_pos]
while move_num<length:
next_pos = (move_pos+k)%length
while next_pos!=move_pos:
save_value = nums[next_pos]
nums[next_pos] = move_value
move_value = save_value
next_pos=(next_pos+k)%length
move_num+=1
nums[move_pos]=move_value
move_num+=1
move_pos+=1
move_value = nums[move_pos]
移動零
給定一個數組 nums，編寫一個函數將所有 0 移動到數組的末尾，同時保持非零元素的相對順序。
示例:
輸入: [0,1,0,3,12]
輸出: [1,3,12,0,0]
說明:
必須在原數組上操作，不能拷貝額外的數組。
儘量減少操作次數。
解法：
- 自己想的一個，用index(0)判斷最左邊的0的位置是否已經是最後了，如果不是，就把0後面的所有內容往前移一個位置。總的看來，就是冒泡排序的加強版
- 其實可以不需要管中間移動的過程，只關注最終的結果即可。只要把數組中所有的非零元素，按順序給數組的前段元素位賦值，剩下的全部直接賦值0就可以。
class Solution(object):
def moveZeroes(self, nums):
"""
:type nums: List[int]
:rtype: None Do not return anything, modify nums in-place instead.
"""
if 0 not in nums:
return nums
right = len(nums)
while nums.index(0) != right:
pos = nums.index(0)
nums[pos:right-1] = nums[pos+1:right]
nums[right-1] = 0
right -= 1
打亂數組
打亂一個沒有重複元素的數組。
示例:
// 以數字集合 1, 2 和 3 初始化數組。
int[] nums = {1,2,3};
Solution solution = new Solution(nums);
// 打亂數組 [1,2,3] 並返回結果。任何 [1,2,3]的排列返回的概率應該相同。
solution.shuffle();
// 重設數組到它的初始狀態[1,2,3]。
solution.reset();
// 隨機返回數組[1,2,3]打亂後的結果。
solution.shuffle();
解法：
注意這裏的隨機要用洗牌方法：在每次迭代中，生成一個範圍在當前下標到數組末尾元素下標之間的隨機整數。接下來，將當前元素和隨機選出的下標所指的元素互相交換。注意，當前元素是可以和它本身互相交換的 - 否則生成最後的排列組合的概率就不對了。
注意randint(min, max)的用法，min和max的值都可能被取到的。
init的時候保存兩個，否則shuffle後就變化了原始數組
不明白： self.ori必須在self.arr前面定義，而且必須是nums[:]，是內部存儲的一些問題麼？如果定義的是self.ori = nums，修改arr的時候會把nums修改，進而把ori修改了。
import random
class Solution(object):
def __init__(self, nums):
"""
:type nums: List[int]
"""
self.ori = nums[:]
self.arr = nums
def reset(self):
"""
Resets the array to its original configuration and return it.
:rtype: List[int]
"""
return self.ori
def shuffle(self):
"""
Returns a random shuffling of the array.
:rtype: List[int]
"""
for i in range(len(self.arr)):
j = random.randint(i, len(self.arr)-1)
self.arr[i], self.arr[j] = self.arr[j], self.arr[i]
return self.arr
# Your Solution object will be instantiated and called as such:
# obj = Solution(nums)
# param_1 = obj.reset()
# param_2 = obj.shuffle()
遞增的三元子序列
給定一個未排序的數組，判斷這個數組中是否存在長度爲 3 的遞增子序列。
數學表達式如下:
如果存在這樣的 i, j, k, 且滿足 0 ≤ i < j < k ≤ n-1，
使得 arr[i] < arr[j] < arr[k] ，返回 true ; 否則返回 false 。
說明: 要求算法的時間複雜度爲 O(n)，空間複雜度爲 O(1) 。
示例 1:
輸入: [1,2,3,4,5]
輸出: true
示例 2:
輸入: [5,4,3,2,1]
輸出: false
解法：
注意是遞增的子序列，並沒有說是“連續”子序列，但是還是走動態規劃的思路，保存兩個指針，一個min，一個medium；
一種方式是把min和medium初始化爲最大值：float(“inf”)
另一種是設置一個flag標記下medium是否已經被初始化了。
因此遍歷一遍數組，隨時更新min和Medium的值，一旦遍歷到比medium還大的數，直接返回ture
class Solution(object):
def increasingTriplet(self, nums):
"""
:type nums: List[int]
:rtype: bool
"""
if not nums:
return False
mi = nums[0]
flag = 0
for i in range(1, len(nums)):
tmp = nums[i]
if tmp < mi:
mi = tmp
elif tmp > mi and (flag == 0 or tmp < me):
me = tmp
flag = 1
elif flag == 1 and tmp > me:
return True
return False
兩個數組的交集 II
給定兩個數組，編寫一個函數來計算它們的交集。
示例 1:
輸入: nums1 = [1,2,2,1], nums2 = [2,2]
輸出: [2,2]
示例 2:
輸入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
輸出: [4,9]
說明：
輸出結果中每個元素出現的次數，應與元素在兩個數組中出現的次數一致。
我們可以不考慮輸出結果的順序。
進階:
如果給定的數組已經排好序呢？你將如何優化你的算法？
如果 nums1 的大小比 nums2 小很多，哪種方法更優？
如果 nums2 的元素存儲在磁盤上，磁盤內存是有限的，並且你不能一次加載所有的元素到內存中，你該怎麼辦？
解法：
- 最簡單的方法就是遍歷兩個數組，遇到相同的就記錄下來，並刪除掉該元素，避免重複。
- 先給兩個數組排序，使用歸併排序的思路。遇到兩個數組的情況，如果要加速處理，就要想到可以設置兩個指針。
解法1：
class Solution(object):
def intersect(self, nums1, nums2):
"""
:type nums1: List[int]
:type nums2: List[int]
:rtype: List[int]
"""
res = []
for idx, x in enumerate(nums1):
if x in nums2:
res.append(x)
nums2.remove(x)
return res
解法2：
class Solution:
def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
res = []
nums1 = sorted(nums1)
nums2 = sorted(nums2)
i = 0
j = 0
while i < len(nums1) and j < len(nums2):
if nums1[i] > nums2[j]:
j += 1
elif nums1[i] < nums2[j]:
i += 1
else:
res.append(nums1[i])
i += 1
j += 1
return res
除自身以外數組的乘積
給定長度爲 n 的整數數組 nums，其中 n > 1，返回輸出數組 output ，其中 output[i] 等於 nums 中除 nums[i] 之外其餘各元素的乘積。
示例:
輸入: [1,2,3,4]
輸出: [24,12,8,6]
說明: 請不要使用除法，且在 O(n) 時間複雜度內完成此題。
進階：
你可以在常數空間複雜度內完成這個題目嗎？（ 出於對空間複雜度分析的目的，輸出數組不被視爲額外空間。）
解法：
最簡單的思路就是用除法或者O(n^2)的遍歷，但是都被禁止了
其實想到用兩個指針了，但是沒想到用兩個數組
因爲是乘法，滿足交換律，所以可以在第一遍遍歷的時候把nums[i]左邊部分的乘積存下來，第二遍的時候把右邊的存下來，最後對應相乘就可以。（注意O(kn)=O(n)）
但是要在常熟空間複雜度的話，就只能保留一個數組，可以選擇保留左邊數組，右邊的用一個數值代替就可以了，因爲每次用完就不用了。
遍歷nums，在遍歷的過程中將對應元素累乘，例如
1 2 3 4
1 1 2 6
這樣我們就得到了對應元素左邊所有元素的乘積。然後我們反向遍歷nums，做相同操作即可。
1 2 3 4
24 12 4 1
再將兩個結果相乘即可。
1 2 3 4
24 12 8 6
Code
class Solution(object):
def productExceptSelf(self, nums):
"""
:type nums: List[int]
:rtype: List[int]
"""
left = [1] * len(nums)
right = 1
for i in range(1, len(nums)):
left[i] = left[i-1] * nums[i-1]
for i in range(len(nums)-1, -1, -1):
left[i] *= right
right *= nums[i]
return left
尋找數組的中心索引
給定一個整數類型的數組 nums，請編寫一個能夠返回數組“中心索引”的方法。
我們是這樣定義數組中心索引的：數組中心索引的左側所有元素相加的和等於右側所有元素相加的和。
如果數組不存在中心索引，那麼我們應該返回 -1。如果數組有多箇中心索引，那麼我們應該返回最靠近左邊的那一個。
示例 1:
輸入:
nums = [1, 7, 3, 6, 5, 6]
輸出: 3
解釋:
索引3 (nums[3] = 6) 的左側數之和(1 + 7 + 3 = 11)，與右側數之和(5 + 6 = 11)相等。
同時, 3 也是第一個符合要求的中心索引。
示例 2:
輸入:
nums = [1, 2, 3]
輸出: -1
解釋:
數組中不存在滿足此條件的中心索引。
說明:
nums 的長度範圍爲 [0, 10000]。
任何一個 nums[i] 將會是一個範圍在 [-1000, 1000]的整數。
class Solution(object):
def pivotIndex(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
if not nums:
return -1
for i in range(len(nums)):
left = sum(nums[:i])
right = sum(nums[i+1:])
if left == right:
return i
return -1
至少是其他數字兩倍的最大數
在一個給定的數組nums中，總是存在一個最大元素 。
查找數組中的最大元素是否至少是數組中每個其他數字的兩倍。
如果是，則返回最大元素的索引，否則返回-1。
示例 1:
輸入: nums = [3, 6, 1, 0]
輸出: 1
解釋: 6是最大的整數, 對於數組中的其他整數,
6大於數組中其他元素的兩倍。6的索引是1, 所以我們返回1.
示例 2:
輸入: nums = [1, 2, 3, 4]
輸出: -1
解釋: 4沒有超過3的兩倍大, 所以我們返回 -1.
提示:
nums 的長度範圍在[1, 50].
每個 nums[i] 的整數範圍在 [0, 100].
解法
就是求數組中的最大數和第二大數即可，注意第二大數的求法
class Solution(object):
def dominantIndex(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
m1, m2 = 0, 0
res = 0
for i, x in enumerate(nums):
if x > m1:
m2 = m1
m1 = x
res = i
elif x > m2:
m2 = x
if m1 >= m2 * 2:
return res
return -1
加一
給定一個由整數組成的非空數組所表示的非負整數，在該數的基礎上加一。
最高位數字存放在數組的首位， 數組中每個元素只存儲單個數字。
你可以假設除了整數 0 之外，這個整數不會以零開頭。
示例 1:
輸入: [1,2,3]
輸出: [1,2,4]
解釋: 輸入數組表示數字 123。
示例 2:
輸入: [4,3,2,1]
輸出: [4,3,2,2]
解釋: 輸入數組表示數字 4321。
解法
主要是對最後面是9的判斷
class Solution(object):
def plusOne(self, digits):
"""
:type digits: List[int]
:rtype: List[int]
"""
if digits[-1] != 9:
digits[-1] += 1
return digits
idx = len(digits) - 1
while idx >= 0 and digits[idx] == 9:
digits[idx] = 0
idx -= 1
if idx == -1:
digits.insert(0, 1)
else:
digits[idx] += 1
return digits
對角線遍歷
給定一個含有 M x N 個元素的矩陣（M 行，N 列），請以對角線遍歷的順序返回這個矩陣中的所有元素，對角線遍歷如下圖所示。
示例:
輸入:
[
[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ]
]
輸出: [1,2,4,7,5,3,6,8,9]
解法
參考：https://leetcode-cn.com/problems/diagonal-traverse/solution/dui-jiao-xian-bian-li-by-leetcode/
初始化數組 result，用於存儲最後結果。
使用一個外層循環遍歷所有的對角線。第一行和最後一列的元素都是對角線的起點。
使用一個內層 while 循環遍歷對角線上的所有元素。可以計算指定對角線上的元素數量，也可以簡單迭代直到索引超出範圍。
因爲不知道每條對角線上的元素數量，需要爲每條對角線分配一個列表或動態數組。但是同樣也可以通過計算得到當前對角線上的元素數量。
對於奇數編號的對角線，只需要將迭代結果翻轉再加入結果數組即可。
class Solution(object):
def findDiagonalOrder(self, matrix):
"""
:type matrix: List[List[int]]
:rtype: List[int]
"""
if not matrix or not matrix[0]:
return []
n, m = len(matrix), len(matrix[0])
res = []
for i in range(m + n + 1):
tmp = []
r, c = 0 if i < m else i - m + 1, i if i < m else m - 1
while r < n and c > -1:
tmp.append(matrix[r][c])
r += 1
c -= 1
if i % 2 == 0:
res.extend(tmp[::-1])
else:
res.extend(tmp)
return res
奇偶位排序
一個2*N長度數組，其中N個奇數，N個偶數，要求實現1個函數，把奇數放置到奇數下標，偶數放置到偶數下標
要求：1. 不能額外開闢一個內存/數組；2. 數組只能遍歷1次
解法
就是可以看成是兩個數組，一個奇數數組，一個偶數數組，所以也就是兩個指針，都從左往右遍歷，找到有問題的就交換。
def try(nums):
i, j = 0, 1
n = len(nums)
while i < n and j < n:
while nums[i] % 2 == 0 and i < n:
i += 2
while nums[j] % 2 == 1 and j < n:
j += 2
nums[i], nums[j] = nums[j], nums[i]
return nums