return n - 1

#

# s = Solution()

# print s.numberOfMatches(10)

"""有一个自行车手打算进行一场公路骑行，这条路线总共由 n + 1 个不同海拔的点组成。自行车手从海拔为 0 的点 0 开始骑行。

给你一个长度为 n 的整数数组 gain ，其中 gain[i] 是点 i 和点 i + 1 的 净海拔高度差(0 <= i < n)。请你返回 最高点的海拔 。

示例 1：

输入：gain = [-5,1,5,0,-7]

输出：1

解释：海拔高度依次为 [0,-5,-4,1,1,-6] 。最高海拔为 1 。

示例 2：

输入：gain = [-4,-3,-2,-1,4,3,2]

输出：0

解释：海拔高度依次为 [0,-4,-7,-9,-10,-6,-3,-1] 。最高海拔为 0 。

"""

class Solution1(object):

def largestAltitude(self, gain):

"""

:type gain: List[int]

:rtype: int

"""

result = [0] * (len(gain) + 1)

for index, value in enumerate(gain):

result[index + 1] = result[index] + value

return max(result)

# s1 = Solution1()

# print s1.largestAltitude([-4,-3,-2,-1,4,3,2])

"""未知 整数数组 arr 由 n 个非负整数组成。

经编码后变为长度为 n - 1 的另一个整数数组 encoded ，其中 encoded[i] = arr[i] XOR arr[i + 1] 。例如，arr = [1,0,2,1] 经编码后得到 encoded = [1,2,3] 。

给你编码后的数组 encoded 和原数组 arr 的第一个元素 first(arr[0])。

请解码返回原数组 arr 。可以证明答案存在并且是唯一的。

示例 1：

输入：encoded = [1,2,3], first = 1

输出：[1,0,2,1]

解释：若 arr = [1,0,2,1] ，那么 first = 1 且 encoded = [1 XOR 0, 0 XOR 2, 2 XOR 1] = [1,2,3]

示例 2：

输入：encoded = [6,2,7,3], first = 4

输出：[4,2,0,7,4]

"""

class Solution2(object):

def decode(self, encoded, first):

"""

:type encoded: List[int]

:type first: int

:rtype: List[int]

"""

result = [0] * (len(encoded) + 1)

result[0] = first

for index, value in enumerate(encoded):

result[index + 1] = result[index] ^ value

return result

# s2 = Solution2()

# print s2.decode([6,2,7,3], 4)

"""给你一个偶数长度的字符串 s 。将其拆分成长度相同的两半，前一半为 a ，后一半为 b 。

两个字符串 相似 的前提是它们都含有相同数目的元音('a'，'e'，'i'，'o'，'u'，'A'，'E'，'I'，'O'，'U')。注意，s 可能同时含有大写和小写字母。

如果 a 和 b 相似，返回 true ；否则，返回 false 。

示例 1：

输入：s = "book"

输出：true

解释：a = "bo" 且 b = "ok" 。a 中有 1 个元音，b 也有 1 个元音。所以，a 和 b 相似。

示例 2：

输入：s = "textbook"

输出：false

解释：a = "text" 且 b = "book" 。a 中有 1 个元音，b 中有 2 个元音。因此，a 和 b 不相似。

注意，元音 o 在 b 中出现两次，记为 2 个。

示例 3：

输入：s = "MerryChristmas"

输出：false

示例 4：

输入：s = "AbCdEfGh"

输出：true

"""

# class Solution3(object):

# def situation_val(self,nums):

# flag = True

# for num in nums:

# if 0 in num:

# flag = False

# break

# if flag:

# return nums

#

# for i, num in enumerate(nums):

# for j, value in enumerate(num):

# if value == 0:

# for n in range(1, 10):

# if self.is_judgment(nums,num,i,j,n):

# nums[i][j] = n

# if not self.situation_val(nums):

# nums[i][j] = 0

#

#

# def is_judgment(self, nums, num, i,j, n):

# if n in num or n in [x[j] for x in nums] or n in self.ssss(nums,i,j):

# return False

# return True

#

# def ssss(self, nums, i, j):

# list_s = []

# for a in range((i/3)*3, (i/3)*3+3):

# for b in range((j/3)*3, (j/3)*3+3):

# list_s.append(nums[a][b])

# return list_s

# S = Solution3()

# nums = [[0,4,3,0,7,0,0,2,0],

# [0,2,0,0,0,0,0,7,0],

# [0,7,0,0,0,9,8,0,0],

# [0,0,0,3,0,0,9,0,0],

# [0,0,6,0,0,0,0,8,2],

# [4,0,0,9,5,0,0,0,7],

# [3,0,0,0,0,5,2,0,1],

# [5,0,0,1,0,8,7,0,0],

# [0,0,4,0,0,0,0,0,8]]

# print S.situation_val(nums)

"""爱丽丝和鲍勃有不同大小的糖果棒：A[i] 是爱丽丝拥有的第 i 根糖果棒的大小，B[j] 是鲍勃拥有的第 j 根糖果棒的大小。

因为他们是朋友，所以他们想交换一根糖果棒，这样交换后，他们都有相同的糖果总量。(一个人拥有的糖果总量是他们拥有的糖果棒大小的总和。)

返回一个整数数组 ans，其中 ans[0] 是爱丽丝必须交换的糖果棒的大小，ans[1] 是 Bob 必须交换的糖果棒的大小。

如果有多个答案，你可以返回其中任何一个。保证答案存在。

示例 1：

输入：A = [1,1], B = [2,2]

输出：[1,2]

示例 2：

输入：A = [1,2], B = [2,3]

输出：[1,2]

示例 3：

输入：A = [2], B = [1,3]

输出：[2,3]

示例 4：

输入：A = [1,2,5], B = [2,4]

输出：[5,4]

"""

class Solution4(object):

def decode(self, A, B):

"""

:type encoded: List[int]

:type first: int

:rtype: List[int]

"""

sum_a = sum(A)

sum_b = sum(B)

if (sum_a + sum_b) % 2 != 0:

return None

ave = (sum_a + sum_b)/2

for j in B:

i = ave + j -sum_b

if i in A:

return [i,j]

"""给你一个仅由大写英文字母组成的字符串，你可以将任意位置上的字符替换成另外的字符，总共可最多替换 k 次。在执行上述操作后，找到包含重复字母的最长子串的长度。

注意：字符串长度 和 k 不会超过 104。

示例 1：

输入：s = "ABAB", k = 2

输出：4

解释：用两个'A'替换为两个'B',反之亦然。

示例 2：

输入：s = "AABABBA", k = 1

输出：4

解释：

将中间的一个'A'替换为'B',字符串变为 "AABBBBA"。

子串 "BBBB" 有最长重复字母, 答案为 4。

"""

class Solution5(object):

def characterReplacement(self, s, k):

"""

:type s: str

:type k: int

:rtype: int

"""

if s == '':

return 0

p1 = 0

len_s = len(s)

max_num = -1

while p1 < len_s:

p2 = p1

t = k

ans = 0

if max_num > len_s - p1:

break

while p2 < len_s:

if s[p2] == s[p1] or t != 0:

if s[p2] != s[p1]:

t -= 1

ans += 1

else:

break

p2 += 1

if t != 0 and ans + t <= len_s:

ans += t

if max_num < ans:

max_num = ans

p1 += 1

return max_num

def characterReplacements(self, s, k):

num = [0] * 26

n = len(s)

maxn = left = right = 0

while right < n:

num[ord(s[right]) - ord("A")] += 1

maxn = max(maxn, num[ord(s[right]) - ord("A")])

if right - left + 1 - maxn > k:

num[ord(s[left]) - ord("A")] -= 1

left += 1

right += 1

return right - left

# S = Solution5()

"""给你一个偶数长度的字符串 s 。将其拆分成长度相同的两半，前一半为 a ，后一半为 b 。

两个字符串 相似 的前提是它们都含有相同数目的元音('a'，'e'，'i'，'o'，'u'，'A'，'E'，'I'，'O'，'U')。注意，s 可能同时含有大写和小写字母。

如果 a 和 b 相似，返回 true ；否则，返回 false 。

示例 1：

输入：s = "book"

输出：true

解释：a = "bo" 且 b = "ok" 。a 中有 1 个元音，b 也有 1 个元音。所以，a 和 b 相似。

示例 2：

输入：s = "textbook"

输出：false

解释：a = "text" 且 b = "book" 。a 中有 1 个元音，b 中有 2 个元音。因此，a 和 b 不相似。

注意，元音 o 在 b 中出现两次，记为 2 个。

示例 3：

输入：s = "MerryChristmas"

输出：false

示例 4：

输入：s = "AbCdEfGh"

输出：true

"""

class Solution7(object):

def halvesAreAlike(self, s):

"""

:type s: str

:rtype: bool

"""

yy = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U']

len_s = len(s)

a = s[:(len_s//2)]

b = s[(len_s//2):]

a_count = 0

b_count = 0

for i in a:

if i in yy:

a_count += 1

for j in b:

if j in yy:

b_count += 1

return a_count == b_count

"""中位数是有序序列最中间的那个数。如果序列的长度是偶数，则没有最中间的数；此时中位数是最中间的两个数的平均数。

例如：

[2,3,4]，中位数是 3

[2,3]，中位数是 (2 + 3) / 2 = 2.5

给你一个数组 nums，有一个长度为 k 的窗口从最左端滑动到最右端。窗口中有 k 个数，每次窗口向右移动 1 位。

你的任务是找出每次窗口移动后得到的新窗口中元素的中位数，并输出由它们组成的数组。

示例：

给出 nums = [1,3,-1,-3,5,3,6,7]，以及 k = 3。

窗口位置 中位数

--------------- -----

[1 3 -1] -3 5 3 6 7 1

1 [3 -1 -3] 5 3 6 7 -1

1 3 [-1 -3 5] 3 6 7 -1

1 3 -1 [-3 5 3] 6 7 3

1 3 -1 -3 [5 3 6] 7 5

1 3 -1 -3 5 [3 6 7] 6

因此，返回该滑动窗口的中位数数组 [1,-1,-1,3,5,6]。

"""

class Solution8(object):

def medianSlidingWindow(self, nums, k):

"""

:type nums: List[int]

:type k: int

:rtype: List[float]

"""

sort_list = nums[:k]

sort_list.sort()

result_list = list()

i = 0

len_num = len(nums)

while i + k < len_num:

if k % 2 == 0:

result_list.append((sort_list[k/2] + sort_list[(k-1)/2])/2.0)

else:

result_list.append(sort_list[k/2])

for index, j in enumerate(sort_list):

if nums[k + i] <= j:

sort_list.insert(index, nums[k + i])

break

if index >= k - 1:

sort_list.append(nums[k + i])

break

sort_list.remove(nums[i])

i += 1

if k % 2 == 0:

result_list.append((sort_list[k / 2] + sort_list[(k - 1) / 2]) / 2.0)

else:

result_list.append(sort_list[k / 2])

return result_list

# s8 = Solution8()

# print s8.medianSlidingWindow([1,3,-1,-3,5,3,6,7],3)

"""给定 n 个整数，找出平均数最大且长度为 k 的连续子数组，并输出该最大平均数。

示例：

输入：[1,12,-5,-6,50,3], k = 4

输出：12.75

解释：最大平均数 (12-5-6+50)/4 = 51/4 = 12.75

"""

class Solution9(object):

def findMaxAverage(self, nums, k):

"""

:type nums: List[int]

:type k: int

:rtype: float

"""

total = sum(nums[:k])

n = len(nums)

max_list = list()

max_list.append(total)

for i in range(k, n):

total = total - nums[i - k] + nums[i]

max_list.append(total)

return max(max_list) / float(k)

#

#

# s9 = Solution9()

# s9.findMaxAverage([0,1,1,3,3],4)

"""给你一个数组 rectangles ，其中 rectangles[i] = [li, wi] 表示第 i 个矩形的长度为 li 、宽度为 wi 。

如果存在 k 同时满足 k <= li 和 k <= wi ，就可以将第 i 个矩形切成边长为 k 的正方形。例如，矩形 [4,6]

可以切成边长最大为 4 的正方形。

设 maxLen 为可以从矩形数组 rectangles 切分得到的 最大正方形 的边长。

返回可以切出边长为 maxLen 的正方形的矩形 数目 。

示例 1：

输入：rectangles = [[5,8],[3,9],[5,12],[16,5]]

输出：3

解释：能从每个矩形中切出的最大正方形边长分别是 [5,3,5,5] 。

最大正方形的边长为 5 ，可以由 3 个矩形切分得到。

示例 2：

输入：rectangles = [[2,3],[3,7],[4,3],[3,7]]

输出：3

"""

class Solution10(object):

def countGoodRectangles(self, rectangles):

"""

:type rectangles: List[List[int]]

:rtype: int

"""

max_list = [min(x) for x in rectangles]

# max_list = list()

# for i in rectangles:

# max_list.append(min(i))

return max_list.count(max(max_list))

"""有效括号字符串为空 ("")、"(" + A + ")" 或 A + B，其中 A 和 B 都是有效的括号字符串，+ 代表字符串的连接。

例如，""，"()"，"(())()" 和 "(()(()))" 都是有效的括号字符串。

如果有效字符串 S 非空，且不存在将其拆分为 S = A+B 的方法，我们称其为原语(primitive)，其中 A 和 B 都是非空有效括号字符串。

给出一个非空有效字符串 S，考虑将其进行原语化分解，使得：S = P_1 + P_2 + ... + P_k，其中 P_i 是有效括号字符串原语。

对 S 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 S 。

示例 1：

输入："(()())(())"

输出："()()()"

解释：

输入字符串为 "(()())(())"，原语化分解得到 "(()())" + "(())"，

删除每个部分中的最外层括号后得到 "()()" + "()" = "()()()"。

示例 2：

输入："(()())(())(()(()))"

输出："()()()()(())"

解释：

输入字符串为 "(()())(())(()(()))"，原语化分解得到 "(()())" + "(())" + "(()(()))"，

删除每个部分中的最外层括号后得到 "()()" + "()" + "()(())" = "()()()()(())"。

示例 3：

输入："()()"

输出：""

解释：

输入字符串为 "()()"，原语化分解得到 "()" + "()"，

删除每个部分中的最外层括号后得到 "" + "" = ""。

"""

import collections

class Solution11(object):

def removeOuterParentheses(self, S):

"""

:type S: str

:rtype: str

"""

stack = []

result = list()

for index, i in enumerate(S):

if not stack:

result.append(index)

if i == '(':

stack.append(i)

else:

stack.pop()

if not stack:

result.append(index)

return ''.join([x for index, x in enumerate(S) if index not in result])

# S11 = Solution11()

# print S11.removeOuterParentheses("(()())(())(()(()))")

"""给你一个整数数组 arr ，以及 a、b 、c 三个整数。请你统计其中好三元组的数量。

如果三元组 (arr[i], arr[j], arr[k]) 满足下列全部条件，则认为它是一个 好三元组 。

0 <= i < j < k < arr.length

|arr[i] - arr[j]| <= a

|arr[j] - arr[k]| <= b

|arr[i] - arr[k]| <= c

其中 |x| 表示 x 的绝对值。

返回 好三元组的数量"""

class Solution12(object):

def countGoodTriplets(self, arr, a, b, c):

"""

:type arr: List[int]

:type a: int

:type b: int

:type c: int

:rtype: int

"""

ans = 0

for i in range(len(arr)):

for j in range(len(arr)):

for k in range(len(arr)):

if i != k and j != i and k != j and abs(arr[i] - arr[j]) <= a and abs(arr[j] - arr[k]) <= b and abs(

arr[i] - arr[k]) <= c and i < j < k < len(arr):

ans+=1

return ans

# s12 = Solution12()

# print s12.countGoodTriplets([3,0,1,1,9,7],7,2,3)

"""给你两个长度相同的字符串，s 和 t。

将 s 中的第 i 个字符变到 t 中的第 i 个字符需要 |s[i] - t[i]| 的开销(开销可能为 0)，也就是两个字符的 ASCII 码值的差的绝对值。

用于变更字符串的最大预算是 maxCost。在转化字符串时，总开销应当小于等于该预算，这也意味着字符串的转化可能是不完 全的。

如果你可以将 s 的子字符串转化为它在 t 中对应的子字符串，则返回可以转化的最大长度。

如果 s 中没有子字符串可以转化成 t 中对应的子字符串，则返回 0。

示例 1：

输入：s = "abcd", t = "bcdf", cost = 3

输出：3

解释：s 中的 "abc" 可以变为 "bcd"。开销为 3，所以最大长度为 3。

示例 2：

输入：s = "abcd", t = "cdef", cost = 3

输出：1

解释：s 中的任一字符要想变成 t 中对应的字符，其开销都是 2。因此，最大长度为 1。

示例 3：

输入：s = "abcd", t = "acde", cost = 0

输出：1

解释：你无法作出任何改动，所以最大长度为 1。

"""

class Solution13(object):

def equalSubstring(self, s, t, maxCost):

"""

:type s: str

:type t: str

:type maxCost: int

:rtype: int

"""

n = len(s)

record = []

for i in range(n):

record.append(abs(ord(t[i]) - ord(s[i])))

start, end = 0, 0

windowsum = 0

res = 0

for end in range(n):

windowsum += record[end]

while windowsum > maxCost:

res = max(res, end - start)

windowsum -= record[start]

start += 1

res = max(res, end - start + 1)

return res

# s13 = Solution13()

"""给你一个整数数组 nums 。

如果一组数字 (i,j) 满足 nums[i] == nums[j] 且 i < j ，就可以认为这是一组 好数对 。

返回好数对的数目。

示例 1：

输入：nums = [1,2,3,1,1,3]

输出：4

解释：有 4 组好数对，分别是 (0,3), (0,4), (3,4), (2,5) ，下标从 0 开始

示例 2：

输入：nums = [1,1,1,1]

输出：6

解释：数组中的每组数字都是好数对

示例 3：

输入：nums = [1,2,3]

输出：0

"""

class Solution14(object):

def numIdenticalPairs(self, nums):

"""

:type nums: List[int]

:rtype: int

"""

# 暴力解法

# lens = len(nums)

# result = 0

# for i in range(lens):

# for j in range(i+1,lens):

# if nums[i] == nums[j]:

# result += 1

# return result

# 数学解法

ans = 0

result_dict = dict()

for i in nums:

if result_dict.get(i) is not None:

result_dict[i] += 1

else:

result_dict[i] = 1

for i in result_dict:

count = result_dict.get(i)

if count >= 2:

ans += ((count - 1)*count)/2

return ans

# s14 = Solution14()

# print s14.numIdenticalPairs([1,2,3,1,1,3])

"""给你一个长度为 n 的整数数组，请你判断在 最多 改变 1 个元素的情况下，该数组能否变成一个非递减数列。

我们是这样定义一个非递减数列的： 对于数组中所有的 i (0 <= i <= n-2)，总满足 nums[i] <= nums[i + 1]。

示例 1:

输入: nums = [4,2,3]

输出: true

解释: 你可以通过把第一个4变成1来使得它成为一个非递减数列。

示例 2:

输入: nums = [4,2,1]

输出: false

解释: 你不能在只改变一个元素的情况下将其变为非递减数列。

"""

class Solution15(object):

def numIdenticalPairs(self, nums):

"""

:type nums: List[int]

:rtype: int

"""

count = 0

for i in range(1,len(nums)):

if nums[i - 1] > nums[i]:

count += 1

if i < len(nums) - 1 and i >= 2 and nums[i - 1] > nums[i + 1] and nums[i - 2] > nums[i]:

return False

if count > 1:

return False

return True

a = [5,7,1,8]

s15 = Solution15()

print s15.numIdenticalPairs(a)

"""输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。

例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 2 个节点是值为 4 的节点。

示例：

给定一个链表: 1->2->3->4->5, 和 k = 2.

返回链表 4->5.

"""

# Definition for singly-linked list.

# class ListNode(object):

# def __init__(self, x):

# self.val = x

# self.next = None

class Solution16(object):

def getKthFromEnd(self, head, k):

"""

:type head: ListNode

:type k: int

:rtype: ListNode

"""

list_head = list()

p = head

while p:

list_head.append(p)

p = p.next

return list_head[-k]

"""检查数组是否经排序和轮转得到

给你一个数组 nums 。nums 的源数组中，所有元素与 nums 相同，但按非递减顺序排列。

如果 nums 能够由源数组轮转若干位置(包括 0 个位置)得到，则返回 true ；否则，返回 false 。

源数组中可能存在 重复项 。

注意：我们称数组 A 在轮转 x 个位置后得到长度相同的数组 B ，当它们满足 A[i] == B[(i+x) % A.length] ，其中 % 为取余运算。

示例 1：

输入：nums = [3,4,5,1,2]

输出：true

解释：[1,2,3,4,5] 为有序的源数组。

可以轮转 x = 3 个位置，使新数组从值为 3 的元素开始：[3,4,5,1,2] 。

示例 2：

输入：nums = [2,1,3,4]

输出：false

解释：源数组无法经轮转得到 nums 。

示例 3：

输入：nums = [1,2,3]

输出：true

解释：[1,2,3] 为有序的源数组。

可以轮转 x = 0 个位置(即不轮转)得到 nums 。

示例 4：

输入：nums = [1,1,1]

输出：true

解释：[1,1,1] 为有序的源数组。

轮转任意个位置都可以得到 nums 。

示例 5：

输入：nums = [2,1]

输出：true

解释：[1,2] 为有序的源数组。

可以轮转 x = 5 个位置，使新数组从值为 2 的元素开始：[2,1] 。"""

class Solution17(object):

def check(self, nums):

"""

:type nums: List[int]

:rtype: bool

"""

ans_i = -1

for i in range(1,len(nums)):

if nums[i] < nums[i - 1]:

ans_i = i

if ans_i == -1:

return True

result_list = nums[ans_i:] + nums[:ans_i]

for i in range(1,len(result_list)):

if result_list[i] < result_list[i - 1]:

return False

return True

"""移除石子的最大得分

你正在玩一个单人游戏，面前放置着大小分别为 a​​​​​​、b 和 c​​​​​​ 的 三堆 石子。

每回合你都要从两个 不同的非空堆 中取出一颗石子，并在得分上加 1 分。当存在 两个或更多 的空堆时，游戏停止。

给你三个整数 a 、b 和 c ，返回可以得到的 最大分数 。

示例 1：

输入：a = 2, b = 4, c = 6

输出：6

解释：石子起始状态是 (2, 4, 6) ，最优的一组操作是：

- 从第一和第三堆取，石子状态现在是 (1, 4, 5)

- 从第一和第三堆取，石子状态现在是 (0, 4, 4)

- 从第二和第三堆取，石子状态现在是 (0, 3, 3)

- 从第二和第三堆取，石子状态现在是 (0, 2, 2)

- 从第二和第三堆取，石子状态现在是 (0, 1, 1)

- 从第二和第三堆取，石子状态现在是 (0, 0, 0)

总分：6 分 。

示例 2：

输入：a = 4, b = 4, c = 6

输出：7

解释：石子起始状态是 (4, 4, 6) ，最优的一组操作是：

- 从第一和第二堆取，石子状态现在是 (3, 3, 6)

- 从第一和第三堆取，石子状态现在是 (2, 3, 5)

- 从第一和第三堆取，石子状态现在是 (1, 3, 4)

- 从第一和第三堆取，石子状态现在是 (0, 3, 3)

- 从第二和第三堆取，石子状态现在是 (0, 2, 2)

- 从第二和第三堆取，石子状态现在是 (0, 1, 1)

- 从第二和第三堆取，石子状态现在是 (0, 0, 0)

总分：7 分 。

示例 3：

输入：a = 1, b = 8, c = 8

输出：8

解释：最优的一组操作是连续从第二和第三堆取 8 回合，直到将它们取空。

注意，由于第二和第三堆已经空了，游戏结束，不能继续从第一堆中取石子。"""

class Solution18(object):

def maximumScore(self, a, b, c):

"""

:type a: int

:type b: int

:type c: int

:rtype: int

"""

if a + b >= c and b + c >= a and a + c >= b:

return (a + b + c)//2

lists = [a,b,c]

return sum(lists) - max(lists)

"""构造字典序最大的合并字符串

给你两个字符串 word1 和 word2 。你需要按下述方式构造一个新字符串 merge ：如果 word1 或 word2 非空，选择 下面选项之一 继续操作：

如果 word1 非空，将 word1 中的第一个字符附加到 merge 的末尾，并将其从 word1 中移除。

例如，word1 = "abc" 且 merge = "dv" ，在执行此选项操作之后，word1 = "bc" ，同时 merge = "dva" 。

如果 word2 非空，将 word2 中的第一个字符附加到 merge 的末尾，并将其从 word2 中移除。

例如，word2 = "abc" 且 merge = "" ，在执行此选项操作之后，word2 = "bc" ，同时 merge = "a" 。

返回你可以构造的字典序 最大 的合并字符串 merge 。

长度相同的两个字符串 a 和 b 比较字典序大小，如果在 a 和 b 出现不同的第一个位置，a 中字符在字母表中的出现顺序位于 b 中相应字符之后，就认为字符串 a 按字典序比字符串 b 更大。例如，"abcd" 按字典序比 "abcc" 更大，因为两个字符串出现不同的第一个位置是第四个字符，而 d 在字母表中的出现顺序位于 c 之后。

示例 1：

输入：word1 = "cabaa", word2 = "bcaaa"

输出："cbcabaaaaa"

解释：构造字典序最大的合并字符串，可行的一种方法如下所示：

- 从 word1 中取第一个字符：merge = "c"，word1 = "abaa"，word2 = "bcaaa"

- 从 word2 中取第一个字符：merge = "cb"，word1 = "abaa"，word2 = "caaa"

- 从 word2 中取第一个字符：merge = "cbc"，word1 = "abaa"，word2 = "aaa"

- 从 word1 中取第一个字符：merge = "cbca"，word1 = "baa"，word2 = "aaa"

- 从 word1 中取第一个字符：merge = "cbcab"，word1 = "aa"，word2 = "aaa"

- 将 word1 和 word2 中剩下的 5 个 a 附加到 merge 的末尾。

示例 2：

输入：word1 = "abcabc", word2 = "abdcaba"

输出：abdcabcabcaba"""

class Solution19(object):

def largestMerge(self, word1, word2):

"""

:type word1: str

:type word2: str

:rtype: str

"""

len_1 = len(word1)

len_2 = len(word2)

i = 0

j = 0

result = ""

while len_1 != 0 and len_2 != 0 :

if word1[i] == word2[j]:

if word1[i:] > word2[j:]:

result += word1[i]

i += 1

len_1 -= 1

else:

result += word2[j]

len_2 -= 1

j += 1

else:

if word1[i] > word2[j]:

result += word1[i]

len_1 -= 1

i += 1

else:

result += word2[j]

len_2 -= 1

j += 1

if len_1 != 0:

result += word1[i:]

if len_2 != 0:

result += word2[j:]

return result

#

# s19 = Solution19()

# print s19.largestMerge("abcabc",

# "abdcaba")

"""给你一个整数数组 nums 和一个目标值 goal 。

你需要从 nums 中选出一个子序列，使子序列元素总和最接近 goal 。也就是说，如果子序列元素和为 sum ，你需要 最小化绝对差 abs(sum - goal) 。

返回 abs(sum - goal) 可能的 最小值 。

注意，数组的子序列是通过移除原始数组中的某些元素(可能全部或无)而形成的数组。

示例 1：

输入：nums = [5,-7,3,5], goal = 6

输出：0

解释：选择整个数组作为选出的子序列，元素和为 6 。

子序列和与目标值相等，所以绝对差为 0 。

示例 2：

输入：nums = [7,-9,15,-2], goal = -5

输出：1

解释：选出子序列 [7,-9,-2] ，元素和为 -4 。

绝对差为 abs(-4 - (-5)) = abs(1) = 1 ，是可能的最小值。

示例 3：

输入：nums = [1,2,3], goal = -7

输出：7

"""

class Solution20(object):

def minAbsDifference(self, nums, goal):

"""

:type nums: List[int]

:type goal: int

:rtype: int

"""

# import numpy as np

# result_list = [0]

# for i in nums:

# result_list.extend(np.add(result_list, [i] * len(result_list)))

# # result_list.extend([i + j for j in result_list])

# result = [abs(x - goal) for x in result_list]

# return min(result)

# 暴力解法一

# result_list = [0]

# result = [0 - goal]

# for i in nums:

# temp = []

# for j in result_list:

# result.append(abs(i + j - goal))

# temp.append(i + j)

# result_list.extend(temp)

# return min(result)

# 暴力解法二

# result_list = [0]

# for i in nums:

# result_list.extend([i + j for j in result_list])

# result = [abs(x - goal) for x in result_list]

# return min(result)

# 双指针解法三

"""nums.length最大是40，如果暴力枚举全部组合是2^40个，太大了。

二分的思路是把这个数组一分为二，从中间分割成两个子数组，例如[5,-7,3,5] -> [5,-7]、[3,5]

然后对这两个子数组分别枚举出他们的所有组合情况并将这些组合出来的数字分别存入数组f1,f2中，由于子数组的大小最大是20(即原数组最大值的一半),所以枚举全部情况是2^20~1e6左右。然后问题就转化为，从f1,f2中分别选出一个数，使他们的和最接近goal。(也可能是只从f1/f2中选出一个数，比赛时没考虑但是也AC了)。

对f2进行排序，然后枚举所有的f1[i]，问题转化为从f2中选出一个数，使这个数最接近goal-f1[i]，这里对f2数组使用二分查找lower_bound查找 >= goal-f1[i]的第一个位置index，然后看下f2[index](如果存在的话)、f2[index-1](如果存在的话)哪个最接近(因为是最接近，所以可能大于也可能小于，lower_bound查找到的是大于等于的情况，index-1就表示小于时最接近的情况)。

"""

ans = float('inf') ###### 初始化

def flat(array, pos, flat_array):

'''

param..

array: 原数组

pos 当前位置

flat_array : 当前枚举数组的结果

'''

if pos > len(array) - 1:

return flat_array

temp = flat_array + [ele + array[pos] for ele in flat_array]

return flat(array, pos + 1, temp)

mid = (len(nums)) // 2 ### 取一半

left = flat(nums[:mid], 0, [0]) #### 初始应加入 [0] 作为不选元素时候的子序列总和

right = flat(nums[mid:], 0, [0])

left = sorted(left)

right = sorted(right, reverse=True)

left_id = 0

right_id = 0

####### 双指针

while (left_id < len(left) and right_id < len(right)):

cur = left[left_id] + right[right_id]

ans = min(abs(cur - goal), ans)

if cur > goal:

right_id += 1

elif cur < goal:

left_id += 1

else:

return 0

return ans

# s20 = Solution20()

# print s20.minAbsDifference([3346,-3402,-9729,7432,2475,6852,5960,-7497,3229,6713,8949,9156,3945,-8686,1528,5022,-9791,-3782,-191,-9820,7720,-6067,-83,6793,340,7793,8742,8067],

# -20357)

"""唯一元素的和

给你一个整数数组 nums 。数组中唯一元素是那些只出现 恰好一次 的元素。

请你返回 nums 中唯一元素的 和 。

示例 1：

输入：nums = [1,2,3,2]

输出：4

解释：唯一元素为 [1,3] ，和为 4 。

示例 2：

输入：nums = [1,1,1,1,1]

输出：0

解释：没有唯一元素，和为 0 。

示例 3 ：

输入：nums = [1,2,3,4,5]

输出：15

解释：唯一元素为 [1,2,3,4,5] ，和为 15 。

"""

class Solution21(object):

def sumOfUnique(self, nums):

"""

:type nums: List[int]

:rtype: int

"""

nums_dict = dict()

for i in nums:

if nums_dict.get(i) is not None:

nums_dict[i] += 1

else:

nums_dict[i] = 1

anc = 0

for i, v in nums_dict.items():

if v == 1:

anc += i

return anc

"""任意连续子数组和的绝对值的最大值

给你一个整数数组 nums 。一个子数组 [numsl, numsl+1, ..., numsr-1, numsr] 的 和的绝对值 为 abs(numsl + numsl+1 + ... + numsr-1 + numsr) 。

请你找出 nums 中 和的绝对值 最大的任意子数组(可能为空)，并返回该 最大值 。

abs(x) 定义如下：

如果 x 是负整数，那么 abs(x) = -x 。

如果 x 是非负整数，那么 abs(x) = x 。

示例 1：

输入：nums = [1,-3,2,3,-4]

输出：5

解释：子数组 [2,3] 和的绝对值最大，为 abs(2+3) = abs(5) = 5 。

示例 2：

输入：nums = [2,-5,1,-4,3,-2]

输出：8

解释：子数组 [-5,1,-4] 和的绝对值最大，为 abs(-5+1-4) = abs(-8) = 8 。

"""

class Solution22(object):

def maxAbsoluteSum(self, nums):

"""

:type nums: List[int]

:rtype: int

"""

anc_i = 0

anc_j = 0

result_i = 0

result_j = 0

for i in nums:

result_i += i

if result_i > 0:

anc_i = max(anc_i, result_i)

else:

result_i = 0

result_j += i

if result_j < 0:

anc_j = max(anc_j, abs(result_j))

else:

result_j = 0

return max(anc_j,anc_i)

# s22 = Solution22()

# print s22.maxAbsoluteSum([2,-5,1,-4,3,-2])

"""删除字符串两端相同字符后的最短长度

给你一个只包含字符 'a'，'b' 和 'c' 的字符串 s ，你可以执行下面这个操作(5 个步骤)任意次：

选择字符串 s 一个 非空 的前缀，这个前缀的所有字符都相同。

选择字符串 s 一个 非空 的后缀，这个后缀的所有字符都相同。

前缀和后缀在字符串中任意位置都不能有交集。

前缀和后缀包含的所有字符都要相同。

同时删除前缀和后缀。

请你返回对字符串 s 执行上面操作任意次以后(可能 0 次)，能得到的 最短长度 。

示例 1：

输入：s = "ca"

输出：2

解释：你没法删除任何一个字符，所以字符串长度仍然保持不变。

示例 2：

输入：s = "cabaabac"

输出：0

解释：最优操作序列为：

- 选择前缀 "c" 和后缀 "c" 并删除它们，得到 s = "abaaba" 。

- 选择前缀 "a" 和后缀 "a" 并删除它们，得到 s = "baab" 。

- 选择前缀 "b" 和后缀 "b" 并删除它们，得到 s = "aa" 。

- 选择前缀 "a" 和后缀 "a" 并删除它们，得到 s = "" 。

示例 3：

输入：s = "aabccabba"

输出：3

解释：最优操作序列为：

- 选择前缀 "aa" 和后缀 "a" 并删除它们，得到 s = "bccabb" 。

- 选择前缀 "b" 和后缀 "bb" 并删除它们，得到 s = "cca" 。

"""

class Solution23(object):

def minimumLength(self, s):

"""

:type s: str

:rtype: int

"""

p1 = 0

p2 = len(s) - 1

for _ in s:

if s[p1] == s[p2] and p1 < p2:

temp = s[p1]

while temp == s[p1] and p1 < len(s) - 1:

p1 += 1

while temp == s[p2] and p2 >= 0:

p2 -= 1

else:

break

if p1 > p2:

return 0

return p2 - p1 + 1

# s23 = Solution23()

# print s23.minimumLength("bbbbbbbbbbbbbbbbbbb")

""" 最长湍流子数组

当 A 的子数组 A[i], A[i+1], ..., A[j] 满足下列条件时，我们称其为湍流子数组：

若 i <= k < j，当 k 为奇数时， A[k] > A[k+1]，且当 k 为偶数时，A[k] < A[k+1]；

或 若 i <= k < j，当 k 为偶数时，A[k] > A[k+1] ，且当 k 为奇数时， A[k] < A[k+1]。

也就是说，如果比较符号在子数组中的每个相邻元素对之间翻转，则该子数组是湍流子数组。

返回 A 的最大湍流子数组的长度。

示例 1：

输入：[9,4,2,10,7,8,8,1,9]

输出：5

解释：(A[1] > A[2] < A[3] > A[4] < A[5])

示例 2：

输入：[4,8,12,16]

输出：2

示例 3：

输入：[100]

输出：1

"""

class Solution24(object):

def maxTurbulenceSize(self, arr):

"""

:type arr: List[int]

:rtype: int

"""

up = [1] * len(arr)

down = [1] * len(arr)

ans = 1

for i in range(1, len(arr)):

if arr[i] > arr[i - 1]:

up[i] = down[i - 1] + 1

elif arr[i] < arr[i - 1]:

down[i] = up[i - 1] + 1

ans = max(ans, down[i], up[i])

return ans

# s24 = Solution24()

# print s24.maxTurbulenceSize([0,1,1,0,1,0,1,1,0,0])

"""最初在一个记事本上只有一个字符 'A'。你每次可以对这个记事本进行两种操作：

Copy All (复制全部) : 你可以复制这个记事本中的所有字符(部分的复制是不允许的)。

Paste (粘贴) : 你可以粘贴你上一次复制的字符。

给定一个数字 n 。你需要使用最少的操作次数，在记事本中打印出恰好 n 个 'A'。输出能够打印出 n 个 'A' 的最少操作次数。

示例 1:

输入: 3

输出: 3

解释:

最初, 我们只有一个字符 'A'。

第 1 步, 我们使用 Copy All 操作。

第 2 步, 我们使用 Paste 操作来获得 'AA'。

第 3 步, 我们使用 Paste 操作来获得 'AAA'。

"""

class Solution25(object):

def minSteps(self, n):

"""

:type n: int

:rtype: int

"""

import math

result_list = [0]

anc = n

for i in range(2, int(math.sqrt(n)) + 1):

while anc % i == 0:

anc = anc / i

result_list.append(i)

if anc != 1:

result_list.append(anc)

print result_list

return sum(result_list)

# s25 = Solution25()

# print s25.minSteps(3)

"""如果一个十进制数字不含任何前导零，且每一位上的数字不是 0 就是 1 ，那么该数字就是一个 十-二进制数 。例如，101 和 1100 都是 十-二进制数，而 112 和 3001 不是。

给你一个表示十进制整数的字符串 n ，返回和为 n 的 十-二进制数 的最少数目。

示例 1：

输入：n = "32"

输出：3

解释：10 + 11 + 11 = 32

示例 2：

输入：n = "82734"

输出：8

示例 3：

输入：n = "27346209830709182346"

输出：9

"""

class Solution26(object):

def minPartitions(self, n):

"""

:type n: str

:rtype: int

"""

return max(n)

"""给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

示例 1：

输入：n = 3

输出：[[1,2,3],[8,9,4],[7,6,5]]

示例 2：

输入：n = 1

输出：[[1]]

"""

class Solution27(object):

def generateMatrix(self, n):

"""

:type n: int

:rtype: List[List[int]]

"""

list_n = [[0] * n for i in range(n)]

i = c = 0

j = 1

list_n[0][0] = 1

for num in range(2, n*n + 1):

list_n[i][j] = num

if i == j or i + j == n-1:

c += 1

if c % 4 == 0:

j += 1

elif c % 4 == 1:

i += 1

elif c % 4 == 2:

j -= 1

else:

if list_n[i-1][j] == 0:

i -= 1

else:

j += 1

print list_n

# s27 = Solution27()

# s27.generateMatrix(3)

"""

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]

输出：[1,2,3,6,9,8,7,4,5]

示例 2：

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]

输出：[1,2,3,4,8,12,11,10,9,5,6,7]

"""

class Solution28(object):

def spiralOrder(self, matrix):

"""

:type matrix: List[List[int]]

:rtype: List[int]

"""

m = len(matrix)

n = len(matrix[0])

result_matrix = [[0]*n for _ in range(m)]

result = list()

i = 0

j = 0

c = 0

for list_k in matrix:

for k in list_k:

result_matrix[i][j] = k

result.append(matrix[i][j])

if c % 4 == 0:

if j < n - 1 and result_matrix[i][j+1]==0:

j += 1

else:

c += 1

i += 1

elif c % 4 == 1:

if i < m - 1 and result_matrix[i+1][j]==0:

i += 1

else:

c += 1

j -= 1

elif c % 4 == 2:

if j > 0 and result_matrix[i][j-1] == 0:

j -= 1

else:

c += 1

i -= 1

else:

if result_matrix[i - 1][j] == 0:

i -= 1

else:

j += 1

c += 1

print result

# s28 = Solution28()

# s28.spiralOrder([[1,2,3,4],[5,6,7,8],[9,10,11,12]])

"""K 个不同整数的子数组

给定一个正整数数组 A，如果 A 的某个子数组中不同整数的个数恰好为 K，则称 A 的这个连续、不一定独立的子数组为好子数组。

(例如，[1,2,3,1,2] 中有 3 个不同的整数：1，2，以及 3。)

返回 A 中好子数组的数目。

示例 1：

输入：A = [1,2,1,2,3], K = 2

输出：7

解释：恰好由 2 个不同整数组成的子数组：[1,2], [2,1], [1,2], [2,3], [1,2,1], [2,1,2], [1,2,1,2].

示例 2：

输入：A = [1,2,1,3,4], K = 3

输出：3

解释：恰好由 3 个不同整数组成的子数组：[1,2,1,3], [2,1,3], [1,3,4].

"""

class Solution29(object):

def subarraysWithKDistinct(self, A, K):

"""

:type A: List[int]

:type K: int

:rtype: int

"""

i = 0

anc = 0

t = len(A)

if len(set(A)) < K:

return 0

while i + K - 1 < t:

j = i + K - 1

list_c = set(A[i:j + 1])

count = len(list_c)

while j < t:

if A[j] not in list_c:

count += 1

list_c.add(A[j])

if count == K:

anc += 1

j += 1

elif count < K:

j += 1

else:

break

i += 1

print anc

return anc

# s29 = Solution29()

"""旋转矩阵

给你一幅由 N × N 矩阵表示的图像，其中每个像素的大小为 4 字节。请你设计一种算法，将图像旋转 90 度。

不占用额外内存空间能否做到？

示例 1:

给定 matrix =

[

[1,2,3],

[4,5,6],

[7,8,9]

],

原地旋转输入矩阵，使其变为:

[

[7,4,1],

[8,5,2],

[9,6,3]

]

示例 2:

给定 matrix =

[

[ 5, 1, 9,11],

[ 2, 4, 8,10],

[13, 3, 6, 7],

[15,14,12,16]

],

原地旋转输入矩阵，使其变为:

[

[15,13, 2, 5],

[14, 3, 4, 1],

[12, 6, 8, 9],

[16, 7,10,11]

]

"""

class Solution30(object):

def rotate(self, matrix):

"""

:type matrix: List[List[int]]

:rtype: None Do not return anything, modify matrix in-place instead.

"""

l1 = len(matrix)

for i in range(l1):

for j in range(i,l1):

matrix[j][i], matrix[i][j] = matrix[i][j], matrix[j][i]

for j in range(l1//2):

matrix[i][j],matrix[i][l1-j-1] = matrix[i][l1-j-1],matrix[i][j]

return matrix

# s30 = Solution30()

# print s30.rotate([

# [1,2,3],

# [4,5,6],

# [7,8,9]

# ])

"""字符串的排列

给定两个字符串 s1 和 s2，写一个函数来判断 s2 是否包含 s1 的排列。

换句话说，第一个字符串的排列之一是第二个字符串的子串。

示例1:

输入: s1 = "ab" s2 = "eidbaooo"

输出: True

解释: s2 包含 s1 的排列之一 ("ba").

示例2:

输入: s1= "ab" s2 = "eidboaoo"

输出: False

"""

class Solution31(object):

def checkInclusion(self, s1, s2):

"""

:type s1: str

:type s2: str

:rtype: bool

"""

s1_1 = dict()

for i in s1:

if i not in s1_1:

s1_1[i] = 1

else:

s1_1[i] += 1

i = 0

len_s1 = len(s1)

len_s2 = len(s2)

set_s1 = list(set(s1))

len_set = len(set_s1)

while i + len_s1 <= len_s2:

j = len_s1 + i

count = 0

for k in set_s1:

if s2[i:j].count(k) != s1_1[k]:

break

count += 1

if count == len_set:

return True

i += 1

return False

# s31 = Solution31()

# print s31.checkInclusion("abcdxabcde",

# "abcdeabcdx")

"""K 连续位的最小翻转次数

在仅包含 0 和 1 的数组 A 中，一次 K 位翻转包括选择一个长度为 K 的(连续)子数组，

同时将子数组中的每个 0 更改为 1，而每个 1 更改为 0。

返回所需的 K 位翻转的最小次数，以便数组没有值为 0 的元素。如果不可能，返回 -1。

示例 1：

输入：A = [0,1,0], K = 1

输出：2

解释：先翻转 A[0]，然后翻转 A[2]。

示例 2：

输入：A = [1,1,0], K = 2

输出：-1

解释：无论我们怎样翻转大小为 2 的子数组，我们都不能使数组变为 [1,1,1]。

示例 3：

输入：A = [0,0,0,1,0,1,1,0], K = 3

输出：3

解释：

翻转 A[0],A[1],A[2]: A变成 [1,1,1,1,0,1,1,0]

翻转 A[4],A[5],A[6]: A变成 [1,1,1,1,1,0,0,0]

翻转 A[5],A[6],A[7]: A变成 [1,1,1,1,1,1,1,1]

"""

class Solution32(object):

def minKBitFlips(self, A, K):

"""

:type A: List[int]

:type K: int

:rtype: int

上面方法超时的主要原因是我们真实地进行了翻转。根据结论二，位置 ii 现在的状态，

和它被前面 K - 1K−1 个元素翻转的次数(奇偶性)有关。

我们使用队列模拟滑动窗口，该滑动窗口的含义是前面 K - 1K−1 个元素中，以哪些位置起始的 子区间进行了翻转。

该滑动窗口从左向右滑动，如果当前位置 i 需要翻转，则把该位置存储到队列中。

遍历到新位置 j (j < i + K)j(j

当 ii 位置被翻转了偶数次，如果 A[i]A[i] 为 0，那么翻转后仍是 0，当前元素需要翻转；

当 ii 位置被翻转了奇数次，如果 A[i]A[i] 为 1，那么翻转后是 0，当前元素需要翻转。

综合上面两点，我们得到一个结论，如果 len(que) % 2 == A[i]len(que) 时，当前元素需要翻转。

当 i + K > Ni+K>N 时，说明需要翻转大小为 K 的子区间，但是后面剩余的元素不到 K 个了，所以返回 -1。

"""

N = len(A)

que = collections.deque()

res = 0

for i in range(N):

if que and i >= que[0] + K:

que.popleft()

if len(que) % 2 == A[i]:

if i + K > N: return -1

que.append(i)

res += 1

return res

# s32 = Solution32()

# s32.minKBitFlips([0,1,0],

# 1)

"""给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，

否则不为 NULL 的节点将直接作为新二叉树的节点。

示例 1:

输入:

Tree 1 Tree 2

1 2

/ \ / \

3 2 1 3

/ \ \

5 4 7

输出:

合并后的树:

3

/ \

4 5

/ \ \

5 4 7

"""

# Definition for a binary tree node.

# class TreeNode(object):

# def __init__(self, val=0, left=None, right=None):

# self.val = val

# self.left = left

# self.right = right

class Solution33(object):

def mergeTrees(self, root1, root2):

"""

:type root1: TreeNode

:type root2: TreeNode

:rtype: TreeNode

"""

if not root2:

return

if root2 and root1:

root1.val += root2

self.mergeTrees(root1.left, root2.left)

self.mergeTrees(root1.right, root2.right)

if not root1.left and root2.left:

root1.left = root2.left

if not root1.right and root2.right:

root1.right = root2.right

return root1

"""幂集。编写一种方法，返回某集合的所有子集。集合中不包含重复的元素。

说明：解集不能包含重复的子集。

示例:

输入： nums = [1,2,3]

输出：

[

[3],

[1],

[2],

[1,2,3],

[1,3],

[2,3],

[1,2],

[]

]

"""

class Solution34(object):

def subsets(self, nums):

"""

:type nums: List[int]

:rtype: List[List[int]]

"""

result_list = [[]]

for i in nums:

result_list += [[i] + j for j in result_list]

return result_list

# s34 = Solution34()

# print s34.subsets([1,2,3])

"""给你一个待查数组 queries ，数组中的元素为 1 到 m 之间的正整数。 请你根据以下规则处理所有待查项

queries[i](从 i=0 到 i=queries.length-1)：

一开始，排列 P=[1,2,3,...,m]。

对于当前的 i ，请你找出待查项 queries[i] 在排列 P 中的位置(下标从 0 开始)，

然后将其从原位置移动到排列 P 的起始位置(即下标为 0 处)。

注意， queries[i] 在 P 中的位置就是 queries[i] 的查询结果。

请你以数组形式返回待查数组 queries 的查询结果。

示例 1：

输入：queries = [3,1,2,1], m = 5

输出：[2,1,2,1]

解释：待查数组 queries 处理如下：

对于 i=0: queries[i]=3, P=[1,2,3,4,5], 3 在 P 中的位置是 2，接着我们把 3 移动到 P 的起始位置，得到 P=[3,1,2,4,5] 。

对于 i=1: queries[i]=1, P=[3,1,2,4,5], 1 在 P 中的位置是 1，接着我们把 1 移动到 P 的起始位置，得到 P=[1,3,2,4,5] 。

对于 i=2: queries[i]=2, P=[1,3,2,4,5], 2 在 P 中的位置是 2，接着我们把 2 移动到 P 的起始位置，得到 P=[2,1,3,4,5] 。

对于 i=3: queries[i]=1, P=[2,1,3,4,5], 1 在 P 中的位置是 1，接着我们把 1 移动到 P 的起始位置，得到 P=[1,2,3,4,5] 。

因此，返回的结果数组为 [2,1,2,1] 。

示例 2：

输入：queries = [4,1,2,2], m = 4

输出：[3,1,2,0]

示例 3：

输入：queries = [7,5,5,8,3], m = 8

输出：[6,5,0,7,5]

"""

class Solution35(object):

def processQueries(self, queries, m):

"""

:type queries: List[int]

:type m: int

:rtype: List[int]

"""

P = [i for i in range(1,m+1)]

print P

queries = queries

result = list()

i = 0

while i < len(queries):

j = P.index(queries[i])

result.append(j)

P.insert(0, P[j])

P.pop(j+1)

i += 1

return result

# s35 = Solution35()

# print s35.processQueries([7,5,5,8,3],

# 8)

""" 统计作战单位数

n 名士兵站成一排。每个士兵都有一个 独一无二 的评分 rating 。

每 3 个士兵可以组成一个作战单位，分组规则如下：

从队伍中选出下标分别为 i、j、k 的 3 名士兵，他们的评分分别为 rating[i]、rating[j]、rating[k]

作战单位需满足： rating[i] < rating[j] < rating[k] 或者 rating[i] > rating[j] > rating[k] ，

其中 0 <= i < j < k < n

请你返回按上述条件可以组建的作战单位数量。每个士兵都可以是多个作战单位的一部分。

示例 1：

输入：rating = [2,5,3,4,1]

输出：3

解释：我们可以组建三个作战单位 (2,3,4)、(5,4,1)、(5,3,1) 。

示例 2：

输入：rating = [2,1,3]

输出：0

解释：根据题目条件，我们无法组建作战单位。

示例 3：

输入：rating = [1,2,3,4]

输出：4

"""

class Solution36(object):

def numTeams(self, rating):

"""

:type rating: List[int]

:rtype: int

"""

# anc = 0

# l_rating = len(rating)

# for i in range(l_rating - 2):

# for j in range(i+1, l_rating - 1):

# for k in range(j + 1, l_rating):

# if rating[i] < rating[j] < rating[k] or rating[i] > rating[j] > rating[k]:

# anc += 1

# return anc

n = len(rating)

ans = 0

# 枚举三元组中的 j

for j in range(1, n - 1):

iless = imore = kless = kmore = 0

for i in range(j):

if rating[i] < rating[j]:

iless += 1

# 注意这里不能直接写成 else

# 因为可能有评分相同的情况

elif rating[i] > rating[j]:

imore += 1

for k in range(j + 1, n):

if rating[k] < rating[j]:

kless += 1

elif rating[k] > rating[j]:

kmore += 1

ans += iless * kmore + imore * kless

return ans

# s36 = Solution36()

"""子集

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集(幂集)。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]

输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]

输出：[[],[0]]

"""

class Solution37(object):

def subsets(self, nums):

"""

:type nums: List[int]

:rtype: List[List[int]]

"""

result = [[]]

for i in nums:

result += [[i] + j for j in result]

return result

"""设计有序流

有 n 个 (id, value) 对，其中 id 是 1 到 n 之间的一个整数，value 是一个字符串。

不存在 id 相同的两个 (id, value) 对。

设计一个流，以 任意 顺序获取 n 个 (id, value) 对，并在多次调用时 按 id 递增的顺序 返回一些值。

实现 OrderedStream 类：

OrderedStream(int n) 构造一个能接收 n 个值的流，并将当前指针 ptr 设为 1 。

String[] insert(int id, String value) 向流中存储新的 (id, value) 对。存储后：

如果流存储有 id = ptr 的 (id, value) 对，则找出从 id = ptr 开始的 最长 id 连续递增序列 ，

并 按顺序 返回与这些 id 关联的值的列表。然后，将 ptr 更新为最后那个 id + 1 。

否则，返回一个空列表。

示例：

输入

["OrderedStream", "insert", "insert", "insert", "insert", "insert"]

[[5], [3, "ccccc"], [1, "aaaaa"], [2, "bbbbb"], [5, "eeeee"], [4, "ddddd"]]

输出

[null, [], ["aaaaa"], ["bbbbb", "ccccc"], [], ["ddddd", "eeeee"]]

解释

OrderedStream os= new OrderedStream(5);

os.insert(3, "ccccc"); // 插入 (3, "ccccc")，返回 []

os.insert(1, "aaaaa"); // 插入 (1, "aaaaa")，返回 ["aaaaa"]

os.insert(2, "bbbbb"); // 插入 (2, "bbbbb")，返回 ["bbbbb", "ccccc"]

os.insert(5, "eeeee"); // 插入 (5, "eeeee")，返回 []

os.insert(4, "ddddd"); // 插入 (4, "ddddd")，返回 ["ddddd", "eeeee"]

"""

class OrderedStream38(object):

def __init__(self, n):

"""

:type n: int

"""

self.list = [""]*n

self.ptr = 1

def insert(self, idKey, value):

"""

:type idKey: int

:type value: str

:rtype: List[str]

"""

result = []

self.list[idKey] = value

if self.list[self.ptr] is not "":

for index ,e in enumerate(self.list[idKey:]):

if e is not "":

result.append(e)

self.ptr = index + idKey

else:

break

return result

else:

return []

""" 将每个元素替换为右侧最大元素

将每个元素替换为右侧最大元素

给你一个数组 arr ，请你将每个元素用它右边最大的元素替换，如果是最后一个元素，用 -1 替换。

完成所有替换操作后，请你返回这个数组。

示例 1：

输入：arr = [17,18,5,4,6,1]

输出：[18,6,6,6,1,-1]

解释：

- 下标 0 的元素 --> 右侧最大元素是下标 1 的元素 (18)

- 下标 1 的元素 --> 右侧最大元素是下标 4 的元素 (6)

- 下标 2 的元素 --> 右侧最大元素是下标 4 的元素 (6)

- 下标 3 的元素 --> 右侧最大元素是下标 4 的元素 (6)

- 下标 4 的元素 --> 右侧最大元素是下标 5 的元素 (1)

- 下标 5 的元素 --> 右侧没有其他元素，替换为 -1

示例 2：

输入：arr = [400]

输出：[-1]

解释：下标 0 的元素右侧没有其他元素。

"""

class Solution39(object):

def replaceElements(self, arr):

"""

:type arr: List[int]

:rtype: List[int]

"""

max_an = -99999999

for i in range(len(arr)-1):

if max_an <= arr[i]:

max_an = max(arr[i+1:])

arr[i] = max_an

arr[-1] = -1

return arr

"""矩阵对角线 是一条从矩阵最上面行或者最左侧列中的某个元素开始的对角线，沿右下方向一直到矩阵末尾的元素。

例如，矩阵 mat 有 6 行 3 列，从 mat[2][0] 开始的 矩阵对角线 将会经过 mat[2][0]、mat[3][1] 和 mat[4][2] 。

给你一个 m * n 的整数矩阵 mat ，请你将同一条 矩阵对角线 上的元素按升序排序后，返回排好序的矩阵。

示例 1：

输入：mat = [[3,3,1,1],[2,2,1,2],[1,1,1,2]]

输出：[[1,1,1,1],[1,2,2,2],[1,2,3,3]]

示例 2：

输入：mat = [[11,25,66,1,69,7],[23,55,17,45,15,52],[75,31,36,44,58,8],[22,27,33,25,68,4],[84,28,14,11,5,50]]

输出：[[5,17,4,1,52,7],[11,11,25,45,8,69],[14,23,25,44,58,15],[22,27,31,36,50,66],[84,28,75,33,55,68]]

"""

class Solution40(object):

def diagonalSort(self, mat):

"""

:type mat: List[List[int]]

:rtype: List[List[int]]

"""

row = len(mat)

cel = len(mat[0])

ret_list = [(0, j) for j in range(cel - 1)]

ret_list.extend([(i, 0) for i in range(row - 1)])

for i,j in ret_list:

k = i

h = j

result = list()

while k < row and h < cel:

result.append(mat[k][h])

k += 1

h += 1

result.sort()

for e in result:

mat[i][j] = e

i += 1

j += 1

return mat

# s40 = Solution40()

# print s40.diagonalSort([[11,25,66,1,69,7],[23,55,17,45,15,52],[75,31,36,44,58,8],[22,27,33,25,68,4],[84,28,14,11,5,50]])