数组

1.两数之和

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:

Given nums = [2, 7, 11, 15], target = 9,
Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

python解答：

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        data = {}
        for i, n in enumerate(nums):
            # data[n] = i
            if target-n in data:
                return [data[target-n], i]
            data[n] = i

答案解析：本题的关键点在于，需要想到如何查询，是否存在两个数的和等于目标值，即求当给出一个数，数组中是否存在另一个数等于目标值-这个数。为了更加有效率，使用字典的形式。注意：这里的data[n]=i一定需要放在if函数后面，这是防止出现类似目标值为6，其中数组中一个数为3的现象。

26. 删除排序数组中的重复项

Given a sorted array nums, remove the duplicates in-place such that each element appear only once and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

Example 1:

Given nums = [1,1,2],

Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively.

It doesn't matter what you leave beyond the returned length.

Example 2:

Given nums = [0,0,1,1,1,2,2,3,3,4],

Your function should return length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively.

It doesn't matter what values are set beyond the returned length.

python解答：

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        i = 0
        for j in range(1, len(nums)):
            if nums[i] != nums[j]:
                i += 1
                nums[i] = nums[j]
        return i+1

答案解析：首先需要注意题意说的是排序数组，那么数组中的每一个元素比较之后，只需要继续比较后面的数值即可，无需重复比较。

27. 移除元素

Given an array nums and a value val, remove all instances of that value in-place and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

The order of elements can be changed. It doesn’t matter what you leave beyond the new length.

Example 1:

Given nums = [3,2,2,3], val = 3,

Your function should return length = 2, with the first two elements of nums being 2.

It doesn't matter what you leave beyond the returned length.

Example 2:

Given nums = [0,1,2,2,3,0,4,2], val = 2,

Your function should return length = 5, with the first five elements of nums containing 0, 1, 3, 0, and 4.

Note that the order of those five elements can be arbitrary.

It doesn't matter what values are set beyond the returned length.

python解答：

class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        i = 0
        for j in range(0, len(nums)):
        	if nums[j] != val:
        		nums[i] = nums[j]
         	         i = i + 1
        return i

答案解析：本题类似于26，只需要使用两个指针，将不为目标值的数值存储到数组中，即可起到对应的目的。

35.搜索插入位置

Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.
You may assume no duplicates in the array.

Example 1:

Input: [1,3,5,6], 5
Output: 2

Example 2:

Input: [1,3,5,6], 2
Output: 1

Example 3:

Input: [1,3,5,6], 7
Output: 4

Example 4:

Input: [1,3,5,6], 0
Output: 0

python解答：

class Solution(object):
    def searchInsert(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        if nums[-1] < target:
            return len(nums)
        if nums[0] >= target:
            return 0
        i = 0
        j = len(nums) - 1
        while(i <= j):
            mid = i + (j - i)/2
            if nums[mid] == target:
                return mid
            if nums[mid] > target:
                j = mid - 1
            elif nums[mid] < target:
                i = mid + 1
        return i

答案解析：本题使用的是二分法搜索，相比较一个个顺序搜索，会极大地节省时间，本题需要注意的就是left(i)和right(j)下标移动的时候，mid是否需要增加减少1，可以试一下会发现，如果不减1或增1，会陷入while循环。

53.最大子序列

Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.
Example:

Input: [-2,1,-3,4,-1,2,1,-5,4],
Output: 6
Explanation: [4,-1,2,1] has the largest sum = 6.

python解答：

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        last_sum = nums[0]
        sub = 0
        for item in nums:
            sub = max(sub + item, item)
            last_sum = max(last_sum, sub)
        return last_sum

答案解析：本题采用的是动态规划方法，类似于“滚动数组”的思想。

66.加一

Given a non-empty array of digits representing a non-negative integer, increment one to the integer.
The digits are stored such that the most significant digit is at the head of the list, and each element in the array contains a single digit.
You may assume the integer does not contain any leading zero, except the number 0 itself.
Example 1:

Input: [1,2,3]
Output: [1,2,4]
Explanation: The array represents the integer 123.

Example 2:

Input: [4,3,2,1]
Output: [4,3,2,2]
Explanation: The array represents the integer 4321.

python解答：

class Solution(object):
    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """
        for i in range(len(digits)-1, -1, -1):
            if digits[i] != 9:
                digits[i] += 1
                return digits
            digits[i] = 0
        ans = [0]*(len(digits)+1)
        ans[0] = 1
        return ans

答案解析：本题解答的巧妙之处在于一旦末尾数字为9，则自动加一，并且原位置归0。而如果所有位置都为9，则全部设为0，最后数组长度加一，首位设为1即可。

88.合并两个有序数组

Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.

Note:
The number of elements initialized in nums1 and nums2 are m and n respectively.
You may assume that nums1 has enough space (size that is equal to m + n) to hold additional elements from nums2.
Example:

Input:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6],       n = 3
Output: [1,2,2,3,5,6]

Constraints:

-10^9 <= nums1[i], nums2[i] <= 10^9
nums1.length == m + n
nums2.length == n

python解答：

class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: None Do not return anything, modify nums1 in-place instead.
        """
        nums3 = nums1[:m]
        nums1[:] = []
        i, j = 0, 0
        while i < m and j < n:
            if nums3[i] < nums2[j]:
                nums1.append(nums3[i])
                i += 1
            else:
                nums1.append(nums2[j])
                j += 1
        if i < m:
            nums1[i+j:] = nums3[i:]
        if j < n:
            nums1[i+j:] = nums2[j:]

答案解析：本题的思路是首选复制nums1数组，然后将nums1数组清空，按照各个数组的大小顺序依次加入到nums1数组中，最后再将某一数组中剩下的元素全部加入到nums1数组内。

118.杨辉三角

Given a non-negative integer numRows, generate the first numRows of Pascal’s triangle.

In Pascal’s triangle, each number is the sum of the two numbers directly above it.
Example:

Input: 5
Output:
[
     [1],
    [1,1],
   [1,2,1],
  [1,3,3,1],
 [1,4,6,4,1]
]

python解答：

class Solution(object):
    def generate(self, numRows):
        """
        :type numRows: int
        :rtype: List[List[int]]
        """
        triangle = []
        for num in range(0, numRows):
            row = [None for i in range(num+1)]
            row[0], row[-1] = 1, 1
            for i in range(1, len(row)-1):
                row[i] = triangle[num-1][i-1]+triangle[num-1][i]
            triangle.append(row)

        return triangle

答案解析：三角结构中，首先可以注明第一个和最后一个元素都为0，其余的每一个元素都是上一行对应的三角形中的两个元素相加。

119.杨辉三角2

Given a non-negative index k where k ≤ 33, return the kth index row of the Pascal’s triangle.

Note that the row index starts from 0.

In Pascal’s triangle, each number is the sum of the two numbers directly above it.

Example:

Input: 3
Output: [1,3,3,1]

python解答：

class Solution(object):
    def getRow(self, rowIndex):
        """
        :type rowIndex: int
        :rtype: List[int]
        """
        triangle = []
        for i in range(0, rowIndex+1):
            row = [None for _ in range(0, i+1)]
            row[0], row[-1] = 1, 1
            for j in range(1, i):
                row[j] = triangle[i-1][j-1] + triangle[i-1][j]
            triangle.append(row)
        return triangle[rowIndex]

答案解析：本题和118题思路是一样的，就是需要注意一下第一个循环里，应该是rowIndex+1，否则输出的其实是rowIndex-1行的内容，出现错误。

121.买卖股票的最佳时机

Say you have an array for which the ith element is the price of a given stock on day i.

If you were only permitted to complete at most one transaction (i.e., buy one and sell one share of the stock), design an algorithm to find the maximum profit.

Note that you cannot sell a stock before you buy one.

Example 1:

Input: [7,1,5,3,6,4]
Output: 5
Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
             Not 7-1 = 6, as selling price needs to be larger than buying price.

Example 2:

Input: [7,6,4,3,1]
Output: 0
Explanation: In this case, no transaction is done, i.e. max profit = 0.

python解答：

class Solution(object):
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        minprice = int(1e9)
        maxprice = 0 
        for price in prices:
            maxprice = max(price-minprice, maxprice)
            minprice = min(price, minprice)
        return  maxprice

答案解析：本题的思路是搜寻到历史最低纪录，在历史最低处购买，在未来最高的某天卖出即可，如果依次遍历，在leetcode上运行会显示超时。

122.买卖股票的最佳时机2

Say you have an array prices for which the ith element is the price of a given stock on day i.

Design an algorithm to find the maximum profit. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times).

Note: You may not engage in multiple transactions at the same time (i.e., you must sell the stock before you buy again).

Example 1:

Input: [7,1,5,3,6,4]
Output: 7
Explanation: Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
             Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.

Example 2:

Input: [1,2,3,4,5]
Output: 4
Explanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
             Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are
             engaging multiple transactions at the same time. You must sell before buying again.

Example 3:

Input: [7,6,4,3,1]
Output: 0
Explanation: In this case, no transaction is done, i.e. max profit = 0.

Constraints:

1 <= prices.length <= 3 * 10 ^ 4
0 <= prices[i] <= 10 ^ 4

python解答：

class Solution(object):
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        maxpro = 0
        for i in range(1, len(prices)):
            if prices[i] > prices[i-1]:
                maxpro += prices[i] - prices[i-1]
        return maxpro

答案解析：本题暴力解法相对复杂，最优解反而最易想到，即判断前后值大小，类似于峰值和低谷，并将其差值相加即可。

167.两数之和2

Given an array of integers that is already sorted in ascending order, find two numbers such that they add up to a specific target number.

The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2.

Note:

• Your returned answers (both index1 and index2) are not zero-based.
• You may assume that each input would have exactly one solution and you may not use the same element twice.

Example:

Input: numbers = [2,7,11,15], target = 9
Output: [1,2]
Explanation: The sum of 2 and 7 is 9. Therefore index1 = 1, index2 = 2.

python解答：

# 双指针法
class Solution(object):
    def twoSum(self, numbers, target):
        """
        :type numbers: List[int]
        :type target: int
        :rtype: List[int]
        """
		low = 0
        high = len(numbers)-1
        while (low < high):
            num_type = numbers[low] + numbers[high]
            if num_type == target:
                return low+1, high+1
            elif num_type < target:
                low += 1
            else:
                high -= 1

## 二分法
class Solution(object):
    def twoSum(self, numbers, target):
        """
        :type numbers: List[int]
        :type target: int
        :rtype: List[int]
        """
        n = len(numbers)
        for i in range(len(numbers)):
            low = i + 1
            high = n - 1
            while(low <= high):  
                mid = low + (high - low)/2
                if numbers[mid] == (target-numbers[i]):
                    return i+1, mid+1
                elif numbers[mid] < (target-numbers[i]):
                    low = mid + 1
                else:
                    high = mid - 1
        return [-1, -1]

答案解析：本题运行效果来看似乎是双指针法更高效率，但是实际上二分法在数据极多的情况下，会首先排除一半的元素，效率更高一些。而且，二分法需要注意的是low=mid+1/high=mid-1，这样可以防止重复用某些元素。

169.多数元素

Given an array of size n, find the majority element. The majority element is the element that appears more than ⌊ n/2 ⌋ times.

You may assume that the array is non-empty and the majority element always exist in the array.

Example 1:

Input: [3,2,3]
Output: 3

Example 2:

Input: [2,2,1,1,1,2,2]
Output: 2

python解答：

class Solution(object):
    def majorityElement(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        # counts = collections.Counter(nums)
        # return max(counts.keys(), key=counts.get)
        candidate = nums[0]
        num = 0
        for i in range(len(nums)):
            if num == 0:
                candidate = nums[i]
            if candidate == nums[i]:
                num += 1
            else:
                num -= 1
        return candidate

答案解析：最开始注释的两行是一般的使用哈希表来记下每个元素的数量，最后输出最大数量的元素即可，时间复杂度较高。第二种方法是投票法，通过投票最后肯定是众数胜利的原理，用candidate来作为候选众数。

189.旋转数组

Given an array, rotate the array to the right by k steps, where k is non-negative.

Follow up:

Try to come up as many solutions as you can, there are at least 3 different ways to solve this problem.
Could you do it in-place with O(1) extra space?

Example 1:

Input: nums = [1,2,3,4,5,6,7], k = 3
Output: [5,6,7,1,2,3,4]
Explanation:
rotate 1 steps to the right: [7,1,2,3,4,5,6]
rotate 2 steps to the right: [6,7,1,2,3,4,5]
rotate 3 steps to the right: [5,6,7,1,2,3,4]

Example 2:

Input: nums = [-1,-100,3,99], k = 2
Output: [3,99,-1,-100]
Explanation: 
rotate 1 steps to the right: [99,-1,-100,3]
rotate 2 steps to the right: [3,99,-1,-100]

python解答：

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)
        def reverse(arr, start, end):
            while start < end:
                inter = arr[end]
                arr[end] = arr[start]
                arr[start] = inter
                start += 1
                end -= 1
        reverse(nums, 0, len(nums)-1)
        reverse(nums, 0, k-1)
        reverse(nums, k, len(nums)-1)

答案解析：本题采用的是反转法，也就是分三次翻转，首先把所有的元素前后翻转，然后把前k个元素前后翻转，最后把后n-k个元素前后翻转。

217.存在重复元素

Given an array of integers, find if the array contains any duplicates.

Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.

Example 1:

Input: [1,2,3,1]
Output: true

Example 2:

Input: [1,2,3,4]
Output: false

Example 3:

Input: [1,1,1,3,3,4,3,2,4,2]
Output: true

python解答：

class Solution(object):
    def containsDuplicate(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        dict1 = {}
        i = 0
        for n in nums:
            if n not in dict1:
                dict1[n] = i
                i += 1
            else:
                return True
        return False 

答案解析：本题很容易想到使用字典，类似于Java中的哈希表，先将未出现过的元素加入到dict中，一旦有个元素已经在dict中，则说明出现了重复元素，即可返回true。

219.存在重复元素2

Given an array of integers and an integer k, find out whether there are two distinct indices i and j in the array such that nums[i] = nums[j] and the absolute difference between i and j is at most k.
Example 1:

Input: nums = [1,2,3,1], k = 3
Output: true

Example 2:

Input: nums = [1,0,1,1], k = 1
Output: true

Example 3:

Input: nums = [1,2,3,1,2,3], k = 2
Output: false

python解答：

class Solution(object):
    def containsNearbyDuplicate(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: bool
        """
        dict1 = {}
        m = False
        for i, n in enumerate(nums):
            if n in dict1:
                if (i - dict1[n]) <= k:
                    m = True
                else:
                    dict1[n] = i
            elif n not in dict1:
                dict1[n] = i
        return m

答案解析：本题我只用了一个字典来存储数组的元素，维护一个m值，当重复元素出现的时候，比较它和上一个元素的index差值即可，内存消耗打败了100%的用户。这一题很容易解决，但是容易出错在理解题意上，我最初的理解是求最小的两个重复元素index的差值即可，后来没有通过，才仔细看了一下例子，发现是任意两个重复的元素的index的绝对值都不能大于k。

268.缺失数字

Given an array containing n distinct numbers taken from 0, 1, 2, …, n, find the one that is missing from the array.

Example 1:

Input: [3,0,1]
Output: 2

Example 2:

Input: [9,6,4,2,3,5,7,0,1]
Output: 8

python解答：

class Solution(object):
    def missingNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        # nums.sort()
        # for i, n in enumerate(nums):
        #     if i != n:
        #         return i
        # return len(nums)
        dict1 = set(nums)
        for i in range(len(nums) + 1):
            if i not in dict1:
                return i

答案解析：本题注释的部分采用的是首先将数组排序，之后index和元素不同的即返回。或者使用哈希表类的方式，直接看是否有对应的数字在数组内。官方给出了另一种很巧妙的方式，就是利用数学法，数组内数字补全的时候和减去实际上数组的和，即为所缺失的数字。

283.移动零

Given an array nums, write a function to move all 0’s to the end of it while maintaining the relative order of the non-zero elements.

Example:

Input: [0,1,0,3,12]
Output: [1,3,12,0,0]

Note:
You must do this in-place without making a copy of the array.
Minimize the total number of operations.

python解答：

class Solution(object):
    def moveZeroes(self, nums):
        """
        :type nums: List[int]
        :rtype: None Do not return anything, modify nums in-place instead.
        """
        stack = 0
        for i in range(len(nums)):
            if nums[i] == 0:
                stack += 1
            else:
                nums[i-stack] = nums[i]
        nums[len(nums)-stack:] = [0] * stack

答案解析：本题的官方解释写的很模糊，也很难得出官方一定是最优的，所以这是我个人的解答，但是运行时间也超过92%的用户。我的思想是最后是要把元素排除掉0而不打乱位置，那也就是这个原有元素前面有几个0，就往前移几个位置，这里面的stack一直纪录出现0的数量，到最后有几个0 ，就直接让数组最后的几个元素为0即可。

414.第三大的数

Given a non-empty array of integers, return the third maximum number in this array. If it does not exist, return the maximum number. The time complexity must be in O(n).

Example 1:

Input: [3, 2, 1]

Output: 1

Explanation: The third maximum is 1.

Example 2:

Input: [1, 2]

Output: 2

Explanation: The third maximum does not exist, so the maximum (2) is returned instead.

Example 3:

Input: [2, 2, 3, 1]
Output: 1
Explanation: Note that the third maximum here means the third maximum distinct number.
Both numbers with value 2 are both considered as second maximum.

python解答：

class Solution(object):
    def thirdMax(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        # list1 = []
        # for num in nums:
        #     if num not in list1:
        #         list1.append(num)
        # list1.sort()
        # if len(list1) < 3:
        #     return list1[-1]
        # else:
        #     return list1[-3]
        list1 = set(nums)
        if len(list1) < 3:
            return max(list1)
        else:
            list1.remove(max(list1))
            list1.remove(max(list1))
            return max(list1)

答案解析：本题最开始的思路是注释掉的那部分，也就是先将元素依次存储在新的列表中，然后排序，返回第三个数字，但是时间复杂度较高，需要500ms。参考了评论的解题方法，使用set和remove来去重和返回第三大数字。

448.找到所有数组中消失的数字

Given an array of integers where 1 ≤ a[i] ≤ n (n = size of array), some elements appear twice and others appear once.

Find all the elements of [1, n] inclusive that do not appear in this array.

Could you do it without extra space and in O(n) runtime? You may assume the returned list does not count as extra space.

Example:

Input:
[4,3,2,7,8,2,3,1]

Output:
[5,6]

python解答：

class Solution(object):
    def findDisappearedNumbers(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        # dict1 = set(nums)
        # list1 = []
        # if len(nums) == 0:
        #     return []
        # for i in range(0, len(nums)):
        #     if (i + 1) not in dict1:
        #         list1.append(i+1)
        # return list1
        list1 = []
        for i in range(len(nums)):
            index = abs(nums[i]) - 1
            if nums[index] > 0:
                nums[index] *= -1 
        for i in range(len(nums)):
            if nums[i] > 0:
                list1.append(i+1)

        return list1

答案解析：注释掉的部分是首选对数组去重，之后依次看index哪个不在dict1中，则加入到列表中，最后返回。第二种方法没有使用额外的空间，如果某个元素存在，则让它作为index的对应的元素为负，最后数组中元素还为正的index+1则为缺失的数值。

485.最大连续1的个数

Given a binary array, find the maximum number of consecutive 1s in this array.

Example 1:

Input: [1,1,0,1,1,1]
Output: 3
Explanation: The first two digits or the last three digits are consecutive 1s.
    The maximum number of consecutive 1s is 3.

python解答：

class Solution(object):
    def findMaxConsecutiveOnes(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        count, res = 0, 0
        # list1 = []
        for num in nums:
            if num == 1:
                count += 1
            else:
                res = max(res, count)
                count = 0
        # list1.append(count)
        res = max(res, count)
        return res

答案解析：本题比较简单，其实就是当元素为1的时候，就设置一个count来记录出现的次数，当出现0的时候，就把count清零，最后保留最大的count值即可，时间复杂度为O(N)。

498.对角线遍历

Given a matrix of M x N elements (M rows, N columns), return all elements of the matrix in diagonal order as shown in the below image.

Example:

Input:
[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]

Output:  [1,2,4,7,5,3,6,8,9]

Explanation:

Note:
The total number of elements of the given matrix will not exceed 10,000.

python解答：

class Solution(object):
    def findDiagonalOrder(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: List[int]
        """
        # if len(matrix) == 0 or len(matrix[0]) == 0:
        #     return []
        # target = []
        # m = len(matrix)
        # n = len(matrix[0])
        # for d in range(0, m+n-1):
        #     list1 = []
        #     if d < n:
        #         r = 0
        #         c = d
        #     else:
        #         r = d-n+1
        #         c = n-1
        #     while r < m and c > -1:
        #         list1.append(matrix[r][c])
        #         r += 1
        #         c -= 1
        #     if d % 2 == 0:
        #         for item in list1[::-1]:
        #             target.append(item)
        #     else:
        #         for item in list1:
        #             target.append(item)
        # return target
        if len(matrix) == 0 or len(matrix[0]) == 0:
            return []
        direction = 1  # 往上走
        m = len(matrix)
        n = len(matrix[0])
        i, j = 0, 0
        target = []
        while i < m and j < n:
            target.append(matrix[i][j])
            if direction == 1:
                row = i -1
                colomn = j + 1
            else:
                row = i + 1
                colomn = j - 1
            if row < 0 or row == m or colomn < 0 or colomn == n:
                if direction == 1:
                    if j == n-1:
                        i += 1
                    if j < n-1:
                        j += 1
                else:
                    if i == m-1:
                        j += 1
                    if i < m-1:
                        i += 1
                direction = 1 - direction
            else:
                i = row
                j = colomn
        return target

答案解析：本题使用了两种方法，注释的那一种是依次取出对角线的元素，然后按照一上一下的顺序，正序反序替换来取出各个对角线的元素。第二种方法就是依次进行条件判断，存入到数组中，第二种方法相比效率更高，但是条件判断更麻烦一点。

509.斐波那契数

The Fibonacci numbers, commonly denoted F(n) form a sequence, called the Fibonacci sequence, such that each number is the sum of the two preceding ones, starting from 0 and 1. That is,

F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), for N > 1.
Given N, calculate F(N).

Example 1:

Input: 2
Output: 1
Explanation: F(2) = F(1) + F(0) = 1 + 0 = 1.

Example 2:

Input: 3
Output: 2
Explanation: F(3) = F(2) + F(1) = 1 + 1 = 2.

Example 3:

Input: 4
Output: 3
Explanation: F(4) = F(3) + F(2) = 2 + 1 = 3.

python解答：

class Solution(object):
    def fib(self, N):
        """
        :type N: int
        :rtype: int
        """
        x1 = 1
        x2 = 1
        target = 0
        if N == 0:
            return 0
        elif N == 1 or N == 2:
            return 1
        for i in range(3, N+1):
            target = x1 + x2
            x1 = x2
            x2 = target
        return target

答案解析：本题如果使用迭代的方法，复杂度会很高，因为相当于每个数都重新计算一次。而如果使用两个变量来存储前面两个斐波那契数，则可以降低复杂度。

532.数组中的K-diff数对

Given an array of integers and an integer k, you need to find the number of unique k-diff pairs in the array. Here a k-diff pair is defined as an integer pair (i, j), where i and j are both numbers in the array and their absolute difference is k.

Example 1:

Input: [3, 1, 4, 1, 5], k = 2
Output: 2
Explanation: There are two 2-diff pairs in the array, (1, 3) and (3, 5).
Although we have two 1s in the input, we should only return the number of unique pairs.

Example 2:

Input:[1, 2, 3, 4, 5], k = 1
Output: 4
Explanation: There are four 1-diff pairs in the array, (1, 2), (2, 3), (3, 4) and (4, 5).

Example 3:

Input: [1, 3, 1, 5, 4], k = 0
Output: 1
Explanation: There is one 0-diff pair in the array, (1, 1).

python解答：

class Solution(object):
    def findPairs(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: int
        """
        if k < 0:
            return 0
        a, b = set(), set()
        for num in nums:
            if (num - k) in a:
                b.add(num - k)
            if (num + k) in a:
                b.add(num)
            a.add(num)
        return len(b)

答案解析：本题最关键的点是，每次只存储数对中的小的那个数字，这样可以保证不重复。

561.数组拆分

Given an array of 2n integers, your task is to group these integers into n pairs of integer, say (a1, b1), (a2, b2), …, (an, bn) which makes sum of min(ai, bi) for all i from 1 to n as large as possible.

Example 1:

Input: [1,4,3,2]
Output: 4
Explanation: n is 2, and the maximum sum of pairs is 4 = min(1, 2) + min(3, 4).

python解答：

class Solution(object):
    def arrayPairSum(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        # nums.sort()
        # target = 0
        # for i in range(len(nums)):
        #     if i%2 == 0:
        #         target += nums[i]
        # return target
        dict1 = {}
        target = 0
        for num in nums:
            num += 10000
            if num not in dict1:
                dict1[num] = 1
            else:
                dict1[num] += 1
        d = 0
        for i in range(-10000, 10001):
            if (i+10000) in dict1:
                target += ((dict1[i + 10000] + 1 - d) // 2 * i)
                d = (dict1[i + 10000] - d + 2) % 2
        return target

答案解析：根据题目及提示，本题注释的部分是比较容易想到的，首先将数组排序，将奇数位的元素相加即可。另外，本题还有一种解法，即计数排序法，利用哈希表（字典）来依次计算小的元素的数量，如果它是偶数，那么它刚好等于它的数量/2*这个元素，如果是奇数，那么它下一个元素就要首选失去一，因为已经用于和前面这个小的元素配对了。

566.重塑矩阵

In MATLAB, there is a very useful function called ‘reshape’, which can reshape a matrix into a new one with different size but keep its original data.

You’re given a matrix represented by a two-dimensional array, and two positive integers r and c representing the row number and column number of the wanted reshaped matrix, respectively.

The reshaped matrix need to be filled with all the elements of the original matrix in the same row-traversing order as they were.

If the ‘reshape’ operation with given parameters is possible and legal, output the new reshaped matrix; Otherwise, output the original matrix.
Example 1:

Input: 
nums = 
[[1,2],
 [3,4]]
r = 1, c = 4
Output: 
[[1,2,3,4]]
Explanation:
The row-traversing of nums is [1,2,3,4]. The new reshaped matrix is a 1 * 4 matrix, fill it row by row by using the previous list.

Example 2:

Input: 
nums = 
[[1,2],
 [3,4]]
r = 2, c = 4
Output: 
[[1,2],
 [3,4]]
Explanation:
There is no way to reshape a 2 * 2 matrix to a 2 * 4 matrix. So output the original matrix.

python解答：

class Solution(object):
    def matrixReshape(self, nums, r, c):
        """
        :type nums: List[List[int]]
        :type r: int
        :type c: int
        :rtype: List[List[int]]
        """
        target = []
        if len(nums) * len(nums[0]) != r * c:
            return nums
        else:
            list1 = []
            for num in nums:
                for element in num:
                    list1.append(element)
                    if len(list1) == c:
                        target.append(list1)
                        list1 = []
        return target

答案解析：本题的解题思路也比较简单，首先确认元素是否能重组成r行c列，确认可以之后就是依次取出原二维数组中的每个元素，按照每c个元素一组依次存入target中即可。

581.最短无序连续子数组

Given an integer array, you need to find one continuous subarray that if you only sort this subarray in ascending order, then the whole array will be sorted in ascending order, too.

You need to find the shortest such subarray and output its length.

Example 1:

Input: [2, 6, 4, 8, 10, 9, 15]
Output: 5
Explanation: You need to sort [6, 4, 8, 10, 9] in ascending order to make the whole array sorted in ascending order.

python解答：

class Solution(object):
    def findUnsortedSubarray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        list1 = nums[:]
        nums.sort()
        list2 = []
        for i in range(len(nums)):
            if nums[i] != list1[i]:
                list2.append(i)
        if len(list2) == 0:
            return 0
        else:
            return max(list2) - min(list2) + 1

答案解析：本题我的思路比较简单，就是首先对数组排序，之后根据那些位置变动了，最大的index减去最小的index即可。本题还可以考虑堆栈的思想，首选遍历数组，如果发现不是升序的元素，则看它应该在哪个位置，保留最小的那个index，之后逆序遍历一遍，得出最大的index，即可对应的求出。

605.种花问题

Suppose you have a long flowerbed in which some of the plots are planted and some are not. However, flowers cannot be planted in adjacent plots - they would compete for water and both would die.

Given a flowerbed (represented as an array containing 0 and 1, where 0 means empty and 1 means not empty), and a number n, return if n new flowers can be planted in it without violating the no-adjacent-flowers rule.

Example 1:

Input: flowerbed = [1,0,0,0,1], n = 1
Output: True

Example 2:

Input: flowerbed = [1,0,0,0,1], n = 2
Output: False

Note:
The input array won't violate no-adjacent-flowers rule.
The input array size is in the range of [1, 20000].
n is a non-negative integer which won't exceed the input array size.

python解答：

class Solution(object):
    def canPlaceFlowers(self, flowerbed, n):
        """
        :type flowerbed: List[int]
        :type n: int
        :rtype: bool
        """
        count = 0
        i = 0
        while(i <= (len(flowerbed)-1)):
            if flowerbed[i] == 0 and (i == 0 or flowerbed[i-1] == 0) and (i== len(flowerbed)-1 or flowerbed[i+1] == 0):
                count += 1
                flowerbed[i] = 1
            if count >= n:
                return True
            i += 1
        return False

答案解析：本题好像也没有很简单的解决方法，使用的就是普通的依次查询，这里面官方给出的条件查询语句是很巧妙的，包含了全部的情况，比如说当只有一个元素为0的时候，即len = 1, 这个时候i == 0 ，而且 i == len(flowerbed)-1，所以如果n <= 1，则返回True。

628.三个数的最大乘积

Given an integer array, find three numbers whose product is maximum and output the maximum product.

Example 1:

Input: [1,2,3]
Output: 6

Example 2:

Input: [1,2,3,4]
Output: 24

Note:
The length of the given array will be in range [3,104] and all elements are in the range [-1000, 1000].
Multiplication of any three numbers in the input won't exceed the range of 32-bit signed integer.

python解答：

class Solution(object):
    def maximumProduct(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        # if len(nums) == 3:
        #     return(nums[0] * nums[1] * nums[2])
        # else:
        #     nums.sort()
        #     return max(nums[-1] * nums[0] * nums[1], nums[-1] * nums[-2] * nums[-3])
        if len(nums) == 3:
            return(nums[0] * nums[1] * nums[2])
        else:
            max1, max2, max3 = -1001, -1001, -1001
            min1, min2 = 1001, 1001
            for num in nums:
                if num > max1:
                    max3 = max2
                    max2 = max1
                    max1 = num
                elif num > max2:
                    max3 = max2
                    max2 = num
                elif num > max3:
                    max3 = num
                if num < min2:
                    min1 = min2
                    min2 = num
                elif num < min1:
                    min1 = num
            return max(max1 * max2 * max3, max1 * min1 * min2)

答案解析：本题注释的部分就是先将数组排序，那么考虑几种情况：全部为正数，则肯定是最后三个数相乘最大；全部为负数，那么肯定是最大的那三个负数相乘最大；有正数也有负数的情况下，有可能有三个正数存在，同时一个最大的正数乘上最小的两个负数，这两个里面一定有一个是最大的数，总之肯定都是最后三个数的乘积和前两个数和最后一个数的乘积取最大值即可。未注释的代码是官方给出的一种不需要排序的方法，就是记录三个最大值，和两个最小值，最后返回乘积最大值即可。

643.子数组最大平均数

Given an array consisting of n integers, find the contiguous subarray of given length k that has the maximum average value. And you need to output the maximum average value.

Example 1:

Input: [1,12,-5,-6,50,3], k = 4
Output: 12.75
Explanation: Maximum average is (12-5-6+50)/4 = 51/4 = 12.75

Note:
1 <= k <= n <= 30,000.
Elements of the given array will be in the range [-10,000, 10,000].

python解答：

class Solution(object):
    def findMaxAverage(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: float
        """
        res = 0
        for i in range(0, k):
            res += nums[i]
        if k == len(nums):
            return float(res)/k
        else:
            sum_ite = res
            for i in range(0, len(nums)-k):
                sum_ite = sum_ite - nums[i] + nums[i + k]
                res = max(res, sum_ite)
            return 1.0*res/k

答案解析：本题使用的滑动窗口的方法，首选将数组前k个元素相加，染化依次每次减去第一个数，再加上后面那一个数字，保留最大的和即可。

661.图片平滑器

Given a 2D integer matrix M representing the gray scale of an image, you need to design a smoother to make the gray scale of each cell becomes the average gray scale (rounding down) of all the 8 surrounding cells and itself. If a cell has less than 8 surrounding cells, then use as many as you can.

Example 1:

Input:
[[1,1,1],
 [1,0,1],
 [1,1,1]]
Output:
[[0, 0, 0],
 [0, 0, 0],
 [0, 0, 0]]
Explanation:
For the point (0,0), (0,2), (2,0), (2,2): floor(3/4) = floor(0.75) = 0
For the point (0,1), (1,0), (1,2), (2,1): floor(5/6) = floor(0.83333333) = 0
For the point (1,1): floor(8/9) = floor(0.88888889) = 0

Note:
The value in the given matrix is in the range of [0, 255].
The length and width of the given matrix are in the range of [1, 150].

python解答：

class Solution(object):
    def imageSmoother(self, M):
        """
        :type M: List[List[int]]
        :rtype: List[List[int]]
        """
        target = copy.deepcopy(M)
        for i in range(0, len(M)):
            for j in range(0, len(M[0])):
                total = 0
                num = 0
                for k in range(i-1, i+2):
                    for l in range(j-1, j+2):
                        # if k in range(0, len(M)) and l in range(0, len(M[0])):
                        if 0<= k < len(M) and 0 <= l < len(M[0]):
                        
                            total += M[k][l]
                            num += 1
                target[i][j] = total//num
        return target

答案解析：我这一题使用的方法效率并不高，但是胜在代码简单，就是每个元素的四周都算进来，只要对应坐标在范围内就加进去。（注：其中的条件，如果换成注释的话，时间就会增加很多）

665.非递减数列

Given an array nums with n integers, your task is to check if it could become non-decreasing by modifying at most 1 element.

We define an array is non-decreasing if nums[i] <= nums[i + 1] holds for every i (0-based) such that (0 <= i <= n - 2).

Example 1:

Input: nums = [4,2,3]
Output: true
Explanation: You could modify the first 4 to 1 to get a non-decreasing array.

Example 2:

Input: nums = [4,2,1]
Output: false
Explanation: You can't get a non-decreasing array by modify at most one element.

python解答：

if len(nums) == 1:
            return True
        count = 0
        for i in range(len(nums)-1):
            if nums[i] > nums[i+1]:
                count += 1
                if i != 0 and i != len(nums)-2:
                    if nums[i-1] > nums[i+1] and nums[i] > nums[i+2]:
                        return False
                if count >= 2:
                    return False
               
        return True

答案解析：本题思路本身不复杂，我在做题的时候主要是条件语句出现了问题。首先，就是看有多少个元素比后一个元素大，如果有两个及以上，则肯定不只需要一次元素修改，那么直接返回False。如果刚好有一个情况出现，那么检查出现的元素位置，如果是0或者len-2，那么肯定可以修改一个元素就能变成非递减，其余的情况则按代码中的条件判断即可。

674.最长连续递增序列

Given an unsorted array of integers, find the length of longest continuous increasing subsequence (subarray).

Example 1:

Input: [1,3,5,4,7]
Output: 3
Explanation: The longest continuous increasing subsequence is [1,3,5], its length is 3. 
Even though [1,3,5,7] is also an increasing subsequence, it's not a continuous one where 5 and 7 are separated by 4. 

Example 2:

Input: [2,2,2,2,2]
Output: 1
Explanation: The longest continuous increasing subsequence is [2], its length is 1. 

Note: Length of the array will not exceed 10,000.
python解答：

class Solution(object):
    def findLengthOfLCIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        list1 = []
        count = 1
        if len(nums) == 0:
            return 0
        for i in range(1, len(nums)):
            if nums[i] > nums[i - 1]:
                count += 1
            else:
                list1.append(count)
                count = 1
        list1.append(count)
        
        return max(list1)

答案解析：本题思路很简单，无非就是滑动元素直到递增趋势被打破，然后记录此时的序列长度，依次往下，最后返回最大的长度即可。

697.数组的度

Given a non-empty array of non-negative integers nums, the degree of this array is defined as the maximum frequency of any one of its elements.

Your task is to find the smallest possible length of a (contiguous) subarray of nums, that has the same degree as nums.

Example 1:

Input: nums = [1,2,2,3,1]
Output: 2
Explanation: 
The input array has a degree of 2 because both elements 1 and 2 appear twice.
Of the subarrays that have the same degree:
[1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]
The shortest length is 2. So return 2.

Example 2:

Input: nums = [1,2,2,3,1,4,2]
Output: 6
Explanation: 
The degree is 3 because the element 2 is repeated 3 times.
So [2,2,3,1,4,2] is the shortest subarray, therefore returning 6.

Constraints:
nums.length will be between 1 and 50,000.
nums[i] will be an integer between 0 and 49,999.
python解答：

class Solution(object):
    def findShortestSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        left, right, count = {}, {}, {}
        for i in range(len(nums)):
            if nums[i] not in left:
                left[nums[i]] = i
            right[nums[i]] = i
            count[nums[i]] = count.get(nums[i], 0) + 1  # get(key, 0)意思是如果没找到key,则返回0
        target = 50000
        max_length = max(count.values())
        for n in count:
            if count[n] == max_length:
                target = min(target, right[n]-left[n]+1)
        return target

答案解析：用三个字典分别记录对应元素的最小index、最大index以及出现的次数，最后比较出现次数都为某一最大值的元素最小间隔即可。

717.1比特与2比特字符

We have two special characters. The first character can be represented by one bit 0. The second character can be represented by two bits (10 or 11).

Now given a string represented by several bits. Return whether the last character must be a one-bit character or not. The given string will always end with a zero.

Example 1:

Input: 
bits = [1, 0, 0]
Output: True
Explanation: 
The only way to decode it is two-bit character and one-bit character. So the last character is one-bit character.

Example 2:

Input: 
bits = [1, 1, 1, 0]
Output: False
Explanation: 
The only way to decode it is two-bit character and two-bit character. So the last character is NOT one-bit character.

Note:
1 <= len(bits) <= 1000.
bits[i] is always 0 or 1.

python解答：

class Solution(object):
    def isOneBitCharacter(self, bits):
        """
        :type bits: List[int]
        :rtype: bool
        """
        # i = 0
        # while i < len(bits) - 1:
        #     i += bits[i] + 1
        # return i == len(bits)-1
        
        ret = 0
        i = len(bits) - 2
        while bits[i] == 1 and i >= 0:
            ret += 1
            i -= 1
        return ret % 2 == 0

答案解析：注释掉的部分使用的方法比较简单，就是依次比较，如果遇见1，肯定要直接跳两个元素，如果为0，则1，最后比较得到的index是否为最后一个元素即可；第二种方法就是从倒数第二个元素直到出现一个0（如果倒数第二个元素就是0，则直接返回），其中如果出现奇数个1，则为False，反之则为True。

724.寻找数组的中心索引

Given an array of integers nums, write a method that returns the “pivot” index of this array.

We define the pivot index as the index where the sum of all the numbers to the left of the index is equal to the sum of all the numbers to the right of the index.

If no such index exists, we should return -1. If there are multiple pivot indexes, you should return the left-most pivot index.

Example 1:

Input: nums = [1,7,3,6,5,6]
Output: 3
Explanation:
The sum of the numbers to the left of index 3 (nums[3] = 6) is equal to the sum of numbers to the right of index 3.
Also, 3 is the first index where this occurs.

Example 2:

Input: nums = [1,2,3]
Output: -1
Explanation:
There is no index that satisfies the conditions in the problem statement.

Constraints:
The length of nums will be in the range [0, 10000].
Each element nums[i] will be an integer in the range [-1000, 1000].

python解答：

class Solution(object):
    def pivotIndex(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        s = sum(nums)
        leftnum = 0
        for i in range(len(nums)):
            if leftnum == (s - leftnum - nums[i]):
                return i
            leftnum += nums[i]
        return -1

答案解析：本题一开始想使用从两边依次加起的方法，但是后来发现情况很多，很难完成。官方给出的答案比较简洁且有效，首选求数组的和，然后依次比较去掉某个元素左边及该元素后的和是否和左边元素的和相等。

746.使用最小花费爬楼梯

On a staircase, the i-th step has some non-negative cost cost[i] assigned (0 indexed).

Once you pay the cost, you can either climb one or two steps. You need to find minimum cost to reach the top of the floor, and you can either start from the step with index 0, or the step with index 1.

Example 1:

Input: cost = [10, 15, 20]
Output: 15
Explanation: Cheapest is start on cost[1], pay that cost and go to the top.

Example 2:

Input: cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]
Output: 6
Explanation: Cheapest is start on cost[0], and only step on 1s, skipping cost[3].

Note:
cost will have a length in the range [2, 1000].
Every cost[i] will be an integer in the range [0, 999].

python解答：

class Solution(object):
    def minCostClimbingStairs(self, cost):
        """
        :type cost: List[int]
        :rtype: int
        """
        if len(cost) == 2:
            return min(cost)
        for i in range(2, len(cost)):
            cost[i] += min(cost[i-1], cost[i-2])
        return min(cost[-1], cost[-2])

答案解析：本题评论很多人说题意难理解，但是其实我个人觉得题意还是很好理解的，反而是没想到动态规划的问题，其实就是不断地进行前两个对应的最小花费的最小值，不断地迭代更新，直到最后两个元素的最小值得到，再输出其中最小的值即可。或者逆序计算花费，也是相同的道理。

747.至少是其他数字的两倍

In a given integer array nums, there is always exactly one largest element.

Find whether the largest element in the array is at least twice as much as every other number in the array.

If it is, return the index of the largest element, otherwise return -1.

Example 1:

Input: nums = [3, 6, 1, 0]
Output: 1
Explanation: 6 is the largest integer, and for every other number in the array x,
6 is more than twice as big as x.  The index of value 6 is 1, so we return 1.

Example 2:

Input: nums = [1, 2, 3, 4]
Output: -1
Explanation: 4 isn't at least as big as twice the value of 3, so we return -1.

Note:
nums will have a length in the range [1, 50].
Every nums[i] will be an integer in the range [0, 99].

python解答：

class Solution(object):
    def dominantIndex(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 1:
            return 0
        if len(nums) == 2:
            if nums[1] >= 2*nums[0]:
                return 1
            if nums[0] >= 2*nums[1]:
                return 0
            return -1
        target = nums[:]
        nums.sort()
        if nums[-2] * 2 > nums[-1]:
            return -1
        else:
            return target.index(nums[-1])

答案解析：本题不复杂，其实只需要判断最大的数是否是第二大的数的二倍即可。

766.托普利茨矩阵

A matrix is Toeplitz if every diagonal from top-left to bottom-right has the same element.

Now given an M x N matrix, return True if and only if the matrix is Toeplitz.

Example 1:

Input:
matrix = [
  [1,2,3,4],
  [5,1,2,3],
  [9,5,1,2]
]
Output: True
Explanation:
In the above grid, the diagonals are:
"[9]", "[5, 5]", "[1, 1, 1]", "[2, 2, 2]", "[3, 3]", "[4]".
In each diagonal all elements are the same, so the answer is True.

Example 2:

Input:
matrix = [
  [1,2],
  [2,2]
]
Output: False
Explanation:
The diagonal "[1, 2]" has different elements.

Note:
matrix will be a 2D array of integers.
matrix will have a number of rows and columns in range [1, 20].
matrix[i][j] will be integers in range [0, 99].

Follow up:
What if the matrix is stored on disk, and the memory is limited such that you can only load at most one row of the matrix into the memory at once?
What if the matrix is so large that you can only load up a partial row into the memory at once?

python解答：

class Solution(object):
    def isToeplitzMatrix(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: bool
        """
        # if len(matrix) == 1 or len(matrix[0]) == 1:
        #     return True
        # i = 0
        # for j in range(0, len(matrix[0])):
        #     target = matrix[i][j]
        #     while(i <= len(matrix)-1 and j <= len(matrix[0])-1):
        #         if matrix[i][j] != target:
        #             return False
        #         else:
        #             j += 1
        #             i += 1
        #     i = 0
        # j = 0
        # for i in range(1, len(matrix)):
        #     target = matrix[i][j]
        #     while(i <= len(matrix)-1 and j <= len(matrix[0])-1):
        #         if matrix[i][j] != target:
        #             return False
        #         else:
        #             j += 1
        #             i += 1
        #     j = 0
        # return True
        if len(matrix) == 1 or len(matrix[0]) == 1:
            return True
        for i in range(0, len(matrix)-1):
            if matrix[i][:-1] != matrix[i+1][1:]:
                return False
        return True

答案解析：本题注释的部分思路很简单，其实就是分别对比对角线的元素，不相等就返回False。但是后来发现题目指出，如果每次只能调动这个矩阵的部分行该如何做，那就是每次比较每行矩阵除去最后一个元素之后和下一行除去第一个元素是否相等，不等则返回False。

830.较大分组的位置

In a string S of lowercase letters, these letters form consecutive groups of the same character.

For example, a string like S = “abbxxxxzyy” has the groups “a”, “bb”, “xxxx”, “z” and “yy”.

Call a group large if it has 3 or more characters. We would like the starting and ending positions of every large group.

The final answer should be in lexicographic order.

Example 1:

Input: "abbxxxxzzy"
Output: [[3,6]]
Explanation: "xxxx" is the single large group with starting  3 and ending positions 6.

Example 2:

Input: "abc"
Output: []
Explanation: We have "a","b" and "c" but no large group.

Example 3:

Input: "abcdddeeeeaabbbcd"
Output: [[3,5],[6,9],[12,14]]

Note:  1 <= S.length <= 1000

python解答：

class Solution(object):
    def largeGroupPositions(self, S):
        """
        :type S: str
        :rtype: List[List[int]]
        """
        if len(S) == 0 or len(S) == 1:
            return []
        target = S[0]
        count = 1
        list1 = []
        for i in range(1, len(S)):
            if S[i] == target:
                count += 1
            else:
                if count >= 3:
                    list1.append([i-count, i-1])
                count = 1
                target = S[i]
        if count >= 3:
            list1.append([len(S)-count, len(S)-1])
        return list1

答案解析：就是依次查数，大于三个的元素的index返回即可。

832.翻转图像

Given a binary matrix A, we want to flip the image horizontally, then invert it, and return the resulting image.

To flip an image horizontally means that each row of the image is reversed. For example, flipping [1, 1, 0] horizontally results in [0, 1, 1].

To invert an image means that each 0 is replaced by 1, and each 1 is replaced by 0. For example, inverting [0, 1, 1] results in [1, 0, 0].

Example 1:

Input: [[1,1,0],[1,0,1],[0,0,0]]
Output: [[1,0,0],[0,1,0],[1,1,1]]
Explanation: First reverse each row: [[0,1,1],[1,0,1],[0,0,0]].
Then, invert the image: [[1,0,0],[0,1,0],[1,1,1]]

Example 2:

Input: [[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]]
Output: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]
Explanation: First reverse each row: [[0,0,1,1],[1,0,0,1],[1,1,1,0],[0,1,0,1]].
Then invert the image: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]

Notes:
1 <= A.length = A[0].length <= 20
0 <= A[i][j] <= 1

python解答：

class Solution(object):
    def flipAndInvertImage(self, A):
        """
        :type A: List[List[int]]
        :rtype: List[List[int]]
        """
        # m = len(A)
        n = len(A[0])
        # if m == 0 or n == 0:
        #     return A
        # target = [[None for item in range(n)] for i in range(m)]
        # for i in range(m):
        #     for j in range(n):
        #         target[i][j] = 1 - A[i][n-j-1]
        # return target
        for row in A:
            for col in range(0, (n+1)/2):
                row[col], row[-col-1] = 1- row[-col-1], 1-row[col]
        return A

答案解析：本题比较简单，其实就是每一行的元素对称交换之后把各自都取反即可。

840.矩阵中的幻方

A 3 x 3 magic square is a 3 x 3 grid filled with distinct numbers from 1 to 9 such that each row, column, and both diagonals all have the same sum.

Given an grid of integers, how many 3 x 3 “magic square” subgrids are there? (Each subgrid is contiguous).

Example 1:

Input: [[4,3,8,4],
        [9,5,1,9],
        [2,7,6,2]]
Output: 1
Explanation: 
The following subgrid is a 3 x 3 magic square:
438
951
276

while this one is not:
384
519
762

In total, there is only one magic square inside the given grid.

Note:
1 <= grid.length <= 10
1 <= grid[0].length <= 10
0 <= grid[i][j] <= 15

python解答：

class Solution(object):
    def numMagicSquaresInside(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        """
        m = len(grid)
        n = len(grid[0])
        target = 0
        def count(a, b, c, d, e, f, g, h, i):
            if sorted([a, b, c, d, e, f, g, h, i]) != range(1, 10):
                return False
            else:
                if a+b+c == d+e+f == g+h+i == a+d+g == b+e+h == c+f+i == a+e+i == c+e+g == 15:
                    return True

        for r in range(m-2):
            for c in range(n-2):
                if grid[r+1][c+1] != 5:
                    continue
                if count(grid[r][c], grid[r][c+1], grid[r][c+2], grid[r+1][c], grid[r+1][c+1], grid[r+1][c+2], grid[r+2][c], grid[r+2][c+1], grid[r+2][c+2]):
                    target += 1
        return target

答案解析：这一题需要仔细阅读题目，其实不复杂，但是需要读出来本题里面的很多隐含条件：因为要求3*3的是1-9不同的数字，所以注定了这9个数字的和为45，而因为每一行都相等，所以每一行都是15，同样地每一列以及两个对角线也都是15。而且，我们把经过中心点的4条线加起来会是60，这里面刚好包含了9个数字以及额外的3个中心点，所以60-45就是中心点的三倍大小，那么这个中心点一定要是5.因此，有了这些条件，代码就比较简单去实现了。

849.到最近的人的最大距离

In a row of seats, 1 represents a person sitting in that seat, and 0 represents that the seat is empty.

There is at least one empty seat, and at least one person sitting.

Alex wants to sit in the seat such that the distance between him and the closest person to him is maximized.

Return that maximum distance to closest person.

Example 1:

Input: [1,0,0,0,1,0,1]
Output: 2
Explanation: 
If Alex sits in the second open seat (seats[2]), then the closest person has distance 2.
If Alex sits in any other open seat, the closest person has distance 1.
Thus, the maximum distance to the closest person is 2.

Example 2:

Input: [1,0,0,0]
Output: 3
Explanation: 
If Alex sits in the last seat, the closest person is 3 seats away.
This is the maximum distance possible, so the answer is 3.

Constraints:
2 <= seats.length <= 20000
seats contains only 0s or 1s, at least one 0, and at least one 1.

python解答：

class Solution(object):
    def maxDistToClosest(self, seats):
        """
        :type seats: List[int]
        :rtype: int
        """
        # list1 = []
        # target = -1
        # for i in range(len(seats)):
        #     if seats[i] == 1:
        #         list1.append(i)
        # if len(list1) == 1:
        #     return max(len(seats) - 1 - list1[0], list1[0])
        # for i in range(len(list1)-1):
        #     inter = (list1[i+1] + list1[i] + 1) // 2
        #     min_interval = min(list1[i+1]-inter, inter-list1[i])
        #     target = max(target, min_interval)
        # return max(target, list1[0], len(seats) - 1 - list1[-1])
        count = 0
        target = -1
        pre, back = -1, -1
        for i in range(len(seats)):
            if seats[i] != 1:
                count += 1
            else:
                if pre < 0:
                    pre = i
                back = i
                target = max(target, (count + 1) // 2)
                count = 0
        return max(target, pre, len(seats) - 1 - back)

答案解析：本题不是特别复杂，其实就是比较两个1之间的0的个数，取这些0个数的中间数，最后再和第一个1前面和最后一个1后面的0的个数比较一下，取最大值即可。

867.转置矩阵

Given a matrix A, return the transpose of A.

The transpose of a matrix is the matrix flipped over it’s main diagonal, switching the row and column indices of the matrix.

Example 1:

Input: [[1,2,3],[4,5,6],[7,8,9]]
Output: [[1,4,7],[2,5,8],[3,6,9]]

Example 2:

Input: [[1,2,3],[4,5,6]]
Output: [[1,4],[2,5],[3,6]]

Note:
1 <= A.length <= 1000
1 <= A[0].length <= 1000

python解答：

class Solution(object):
    def transpose(self, A):
        """
        :type A: List[List[int]]
        :rtype: List[List[int]]
        """
        # target = []
        # for j in range(len(A[0])):
        #     list1 = []
        #     for i in range(len(A)):
        #         list1.append(A[i][j])
        #     target.append(list1)
        # return target
        return [[A[i][j] for i in range(len(A))] for j in range(len(A[0]))]

答案解析：本题比较简单，尤其是评论给的这一种一行代码，十分简洁。

888.公平的糖果交换

Alice and Bob have candy bars of different sizes: A[i] is the size of the i-th bar of candy that Alice has, and B[j] is the size of the j-th bar of candy that Bob has.

Since they are friends, they would like to exchange one candy bar each so that after the exchange, they both have the same total amount of candy. (The total amount of candy a person has is the sum of the sizes of candy bars they have.)

Return an integer array ans where ans[0] is the size of the candy bar that Alice must exchange, and ans[1] is the size of the candy bar that Bob must exchange.

If there are multiple answers, you may return any one of them. It is guaranteed an answer exists.

Example 1:

Input: A = [1,1], B = [2,2]
Output: [1,2]

Example 2:

Input: A = [1,2], B = [2,3]
Output: [1,2]

Example 3:

Input: A = [2], B = [1,3]
Output: [2,3]

Example 4:

Input: A = [1,2,5], B = [2,4]
Output: [5,4]

Note:
1 <= A.length <= 10000
1 <= B.length <= 10000
1 <= A[i] <= 100000
1 <= B[i] <= 100000
It is guaranteed that Alice and Bob have different total amounts of candy.
It is guaranteed there exists an answer.

python解答：

class Solution(object):
    def fairCandySwap(self, A, B):
        """
        :type A: List[int]
        :type B: List[int]
        :rtype: List[int]
        """
        sum_A = sum(A)
        sum_B = sum(B)
        set_B = set(B)
        sum_mean = (sum_A + sum_B) // 2
        for item in A:
            if (item + sum_mean - sum_A) in set_B:
                return [item, item + sum_mean - sum_A]

答案解析：本题需要确定两个糖果之和平均值就是交换之后应有的值：(A+B)/2，那么只需要看A中的哪个元素加上A原元素之和和平均值的差值，在B中存在即可，最后返回这两个数。

896.单调数列

An array is monotonic if it is either monotone increasing or monotone decreasing.

An array A is monotone increasing if for all i <= j, A[i] <= A[j]. An array A is monotone decreasing if for all i <= j, A[i] >= A[j].

Return true if and only if the given array A is monotonic.

Example 1:

Input: [1,2,2,3]
Output: true

Example 2:

Input: [6,5,4,4]
Output: true

Example 3:

Input: [1,3,2]
Output: false

Example 4:

Input: [1,2,4,5]
Output: true

Example 5:

Input: [1,1,1]
Output: true

Note:
1 <= A.length <= 50000
-100000 <= A[i] <= 100000

python解答：

class Solution(object):
    def isMonotonic(self, A):
        """
        :type A: List[int]
        :rtype: bool
        """
        # B = deepcopy(A)
        # C = deepcopy(A)
        # A.sort()
        # B.sort(reverse=True)
        # if C == A or C == B:
        #     return True
        # else:
        #     return False
        if len(A) == 0 or len(A) == 1:
            return True
        if A[-1] >= A[0]:
            for i in range(0, len(A)-1):
                if A[i+1] < A[i]:
                    return False
        else:
            for i in range(0, len(A)-1):
                if A[i+1] > A[i]:
                    return False
        return True

答案解析：本题根据最后一个元素是否大于第一个元素来判断他是升序还是降序，接下来一个个比较即可。

905.按奇偶排序数组

Given an array A of non-negative integers, return an array consisting of all the even elements of A, followed by all the odd elements of A.

You may return any answer array that satisfies this condition.

Example 1:

Input: [3,1,2,4]
Output: [2,4,3,1]
The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.

Note:
1 <= A.length <= 5000
0 <= A[i] <= 5000

python解答：

class Solution(object):
    def sortArrayByParity(self, A):
        """
        :type A: List[int]
        :rtype: List[int]
        """
        a = len(A)
        target = [None for i in range(a)]
        odd_index = a-1
        even_index = 0
        for i in range(a):
            if A[i] % 2 == 0:
                target[even_index] = A[i]
                even_index += 1
            else:
                target[odd_index] = A[i]
                odd_index -= 1
        return target

答案解析：本题其实就是维护两个指针，分别指向奇数和偶数部分。

914.卡牌分组

In a deck of cards, each card has an integer written on it.

Return true if and only if you can choose X >= 2 such that it is possible to split the entire deck into 1 or more groups of cards, where:

Each group has exactly X cards.
All the cards in each group have the same integer.

Example 1:

Input: deck = [1,2,3,4,4,3,2,1]
Output: true
Explanation: Possible partition [1,1],[2,2],[3,3],[4,4].

Example 2:

Input: deck = [1,1,1,2,2,2,3,3]
Output: false´
Explanation: No possible partition.

Example 3:

Input: deck = [1]
Output: false
Explanation: No possible partition.

Example 4:

Input: deck = [1,1]
Output: true
Explanation: Possible partition [1,1].

Example 5:

Input: deck = [1,1,2,2,2,2]
Output: true
Explanation: Possible partition [1,1],[2,2],[2,2].

Constraints:
1 <= deck.length <= 10^4
0 <= deck[i] < 10^4

python解答：

class Solution(object):
    def hasGroupsSizeX(self, deck):
        """
        :type deck: List[int]
        :rtype: bool
        """
        if len(deck) == 1:
            return False
        dict1 = {}
        for item in deck:
            if item in dict1:
                dict1[item] += 1
            else:
                dict1[item] = 1
        list1 = []
        for item in dict1:
            list1.append(dict1[item])
        if len(list1) == 1:
            return True
        def gcd(x, y):
            if x%y == 0:
                return y
            else:
                return gcd(y, x%y)
        g = -1
        for i in range(len(list1)):
            if i == 0:
                g = list1[0]
            else:
                g = gcd(g, list1[i])
        if g <= 1:
            return False
        return True

答案解析：本题关键在于求最大公约数，在这里我简单推导了一下：
假如输入a,b，那么我们可以列方程式：$x_{1}b+m_1=a$， 如果$m_1=0$，那么我们可以说b是最大公约数，否则，我们将$b,m_1$输入，那么$x_2{m}_1+m_2=b$，如果$m_2=0$，那么$m_1$此时是最大公约数，因为原式可以化简为$x_1{x}_2{m}_1+m_1=a$，其中$x_1{x}_2$是整数。那么依次类推，直到第n次，最后$m_n$为0，那么$m_{n-1}$就是最大公约数。

922.按奇偶排序数组2

Given an array A of non-negative integers, half of the integers in A are odd, and half of the integers are even.

Sort the array so that whenever A[i] is odd, i is odd; and whenever A[i] is even, i is even.

You may return any answer array that satisfies this condition.

Example 1:

Input: [4,2,5,7]
Output: [4,5,2,7]
Explanation: [4,7,2,5], [2,5,4,7], [2,7,4,5] would also have been accepted.

Note:
2 <= A.length <= 20000
A.length % 2 == 0
0 <= A[i] <= 1000

python解答：

class Solution(object):
    def sortArrayByParityII(self, A):
        """
        :type A: List[int]
        :rtype: List[int]
        """
        # target = [None for i in range(len(A))]
        # even, odd = 0, 1
        # for item in A:
        #     if item % 2 == 0:
        #         target[even] = item
        #         even += 2
        #     else:
        #         target[odd] = item
        #         odd += 2
        # return target
        j = 1
        for i in range(0, len(A), 2):
            if A[i] % 2 == 1:
                while A[j] % 2 == 1:
                    j += 2
                # even = A[j]
                # A[j] = A[i]
                # A[i] = even
                A[i], A[j] = A[j], A[i]
        return A

答案解析：本题主要思路是：当偶数index处的元素没问题的时候，奇数处元素也没问题，那么只需要把偶数index中odd和附近在奇数index中的even交换一下即可。

941.有效的山脉数组

Given an array A of integers, return true if and only if it is a valid mountain array.

Recall that A is a mountain array if and only if:

A.length >= 3
There exists some i with 0 < i < A.length - 1 such that:
A[0] < A[1] < … A[i-1] < A[i]
A[i] > A[i+1] > … > A[A.length - 1]

Example 1:

Input: [2,1]
Output: false

Example 2:

Input: [3,5,5]
Output: false

Example 3:

Input: [0,3,2,1]
Output: true

Note:
0 <= A.length <= 10000
0 <= A[i] <= 10000 

python解答：

class Solution(object):
    def validMountainArray(self, A):
        """
        :type A: List[int]
        :rtype: bool
        """
        if len(A) < 3:
            return False
        # index = -1
        # count = 0 
        # target = max(A)
        # for i in range(len(A)):
        #     if A[i] == target:
        #         index = i
        #         count += 1
        #     if count > 1 or index == 0 or index == len(A)-1:
        #         return False
        # if index < 0:
        #     return False
        # for i in range(index):
        #     if A[i] >= A[i+1]:
        #         return False
        # for i in range(index+1, len(A)-1):
        #     if A[i] <= A[i+1]:
        #         return False
        # return True
        N = len(A)
        i = 0
        while i < N-1 and A[i] < A[i+1]:
            i += 1
        if i == 0 or i == N-1:
            return False
        while i < N-1 and A[i] > A[i+1]:
            i += 1
        if i != N -1:
            return False
        return True

答案解析：本题首先依次比较前后元素，直到前面的元素大于或等于后一个元素，则说明到最高峰了，然后再比较这个元素后面的是否依次下降，如果是的话，则返回True。

977.有序数组的平方

Given an array of integers A sorted in non-decreasing order, return an array of the squares of each number, also in sorted non-decreasing order.

Example 1:

Input: [-4,-1,0,3,10]
Output: [0,1,9,16,100]

Example 2:

Input: [-7,-3,2,3,11]
Output: [4,9,9,49,121]

Note:
1 <= A.length <= 10000
-10000 <= A[i] <= 10000
A is sorted in non-decreasing order.

python解答：

class Solution(object):
    def sortedSquares(self, A):
        """
        :type A: List[int]
        :rtype: List[int]
        """
        for i in range(len(A)):
            A[i] *= A[i]
        A.sort()
        return A

答案解析：本题比较简单，就是平方后排序。

985.查询后的偶数和

We have an array A of integers, and an array queries of queries.

For the i-th query val = queries[i][0], index = queries[i][1], we add val to A[index]. Then, the answer to the i-th query is the sum of the even values of A.

(Here, the given index = queries[i][1] is a 0-based index, and each query permanently modifies the array A.)

Return the answer to all queries. Your answer array should have answer[i] as the answer to the i-th query.

Example 1:

Input: A = [1,2,3,4], queries = [[1,0],[-3,1],[-4,0],[2,3]]
Output: [8,6,2,4]
Explanation: 
At the beginning, the array is [1,2,3,4].
After adding 1 to A[0], the array is [2,2,3,4], and the sum of even values is 2 + 2 + 4 = 8.
After adding -3 to A[1], the array is [2,-1,3,4], and the sum of even values is 2 + 4 = 6.
After adding -4 to A[0], the array is [-2,-1,3,4], and the sum of even values is -2 + 4 = 2.
After adding 2 to A[3], the array is [-2,-1,3,6], and the sum of even values is -2 + 6 = 4.

Note:
1 <= A.length <= 10000
-10000 <= A[i] <= 10000
1 <= queries.length <= 10000
-10000 <= queries[i][0] <= 10000
0 <= queries[i][1] < A.length

python解答：

class Solution(object):
    def sumEvenAfterQueries(self, A, queries):
        """
        :type A: List[int]
        :type queries: List[List[int]]
        :rtype: List[int]
        """
        even_sum = 0
        for item in A:
            if item % 2 == 0:
                even_sum += item
        target = []
        for i, j in queries:
            if A[j] % 2 == 0:
                even_sum -= A[j]
            A[j] += i
            if A[j] % 2 == 0:
                even_sum += A[j]
            target.append(even_sum)
        return target

答案解析：本题主要是首先判别，查询的数字是否为偶数，如果是，则先在总和里减去原数字，然后判断变化后的数字是否为偶数，如果为偶数，则加上去。

989.数组形式的整数加法

For a non-negative integer X, the array-form of X is an array of its digits in left to right order. For example, if X = 1231, then the array form is [1,2,3,1].

Given the array-form A of a non-negative integer X, return the array-form of the integer X+K.

Example 1:

Input: A = [1,2,0,0], K = 34
Output: [1,2,3,4]
Explanation: 1200 + 34 = 1234

Example 2:

Input: A = [2,7,4], K = 181
Output: [4,5,5]
Explanation: 274 + 181 = 455

Example 3:

Input: A = [2,1,5], K = 806
Output: [1,0,2,1]
Explanation: 215 + 806 = 1021

Example 4:

Input: A = [9,9,9,9,9,9,9,9,9,9], K = 1
Output: [1,0,0,0,0,0,0,0,0,0,0]
Explanation: 9999999999 + 1 = 10000000000

Note：
1 <= A.length <= 10000
0 <= A[i] <= 9
0 <= K <= 10000
If A.length > 1, then A[0] != 0

python解答：

class Solution(object):
    def addToArrayForm(self, A, K):
        """
        :type A: List[int]
        :type K: int
        :rtype: List[int]
        """
        A[-1] += K
        for i in xrange(len(A) - 1, -1, -1):
            carry, A[i] = divmod(A[i], 10)
            if i: 
                A[i-1] += carry
        if carry:
            A = list(map(int, str(carry))) + A
        return A

答案解析：本题采用的先把数字加到最后一个元素，然后依次把%10的数留下，并将剩余的数加到前一位数中，最后直到第一位数，并且如果第一位数大于10，则直接转化为list，和原list合并。

999.可以被一步捕获的棋子数

On an 8 x 8 chessboard, there is one white rook. There also may be empty squares, white bishops, and black pawns. These are given as characters ‘R’, ‘.’, ‘B’, and ‘p’ respectively. Uppercase characters represent white pieces, and lowercase characters represent black pieces.

The rook moves as in the rules of Chess: it chooses one of four cardinal directions (north, east, west, and south), then moves in that direction until it chooses to stop, reaches the edge of the board, or captures an opposite colored pawn by moving to the same square it occupies. Also, rooks cannot move into the same square as other friendly bishops.

Return the number of pawns the rook can capture in one move.

Example 1:

Input: [[".",".",".",".",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".","R",".",".",".","p"],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."]]
Output: 3
Explanation: 
In this example the rook is able to capture all the pawns.

Example 2:

Input: [[".",".",".",".",".",".",".","."],[".","p","p","p","p","p",".","."],[".","p","p","B","p","p",".","."],[".","p","B","R","B","p",".","."],[".","p","p","B","p","p",".","."],[".","p","p","p","p","p",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."]]
Output: 0
Explanation: 
Bishops are blocking the rook to capture any pawn.

Example 3:

Input: [[".",".",".",".",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".","p",".",".",".","."],["p","p",".","R",".","p","B","."],[".",".",".",".",".",".",".","."],[".",".",".","B",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".",".",".",".",".","."]]
Output: 3
Explanation: 
The rook can capture the pawns at positions b5, d6 and f5.

Note:
board.length == board[i].length == 8
board[i][j] is either 'R', '.', 'B', or 'p'
There is exactly one cell with board[i][j] == 'R'

python解答：

class Solution(object):
    def numRookCaptures(self, board):
        """
        :type board: List[List[str]]
        :rtype: int
        """
        rx, ry = 0, 0
        for i in range(8):
            for j in range(8):
                if board[i][j] == 'R':
                    rx = i
                    ry = j
        dx = [1, 0, -1, 0]
        dy = [0, 1, 0, -1]
        count = 0
        for i in range(4):
            step = 1
            while True:
                nx = rx + step*dx[i]
                ny = ry + step*dy[i]
                if nx < 0 or nx > 7 or ny < 0 or ny > 7 or board[nx][ny] == 'B':
                    break
                if board[nx][ny] == 'p':
                    count += 1
                    break
                step += 1
        return count

答案解析：本题就是按照四个方向，依次遍历。但是，官方给出了方向数组，就提供了极大的便利，否则可能需要使用四个for循环，依次来走完四个方向，主要好处是代码简洁。

1002.查找常用字符

Given an array A of strings made only from lowercase letters, return a list of all characters that show up in all strings within the list (including duplicates). For example, if a character occurs 3 times in all strings but not 4 times, you need to include that character three times in the final answer.

You may return the answer in any order.

Example 1:

Input: ["bella","label","roller"]
Output: ["e","l","l"]

Example 2:

Input: ["cool","lock","cook"]
Output: ["c","o"]

Note:
1 <= A.length <= 100
1 <= A[i].length <= 100
A[i][j] is a lowercase letter

python解答：

class Solution(object):
    def commonChars(self, A):
        """
        :type A: List[str]
        :rtype: List[str]
        """
        list1 = []
        for item in set(A[0]):
            count = min([a.count(item) for a in A])
            ele = count * item
            for i in ele:
                list1.append(i)
        return list1

答案解析：本题的思想是直接利用A中的第一个字符串中的字母，来分别计算每个字符串中出现这些字母的次数，最小会是0，也就是没有出现这些字母，最后存入list1中并返回即可。

1010.总持续时间可被60整除的歌曲

In a list of songs, the i-th song has a duration of time[i] seconds.

Return the number of pairs of songs for which their total duration in seconds is divisible by 60. Formally, we want the number of indices i, j such that i < j with (time[i] + time[j]) % 60 == 0.

Example 1:

Input: [30,20,150,100,40]
Output: 3
Explanation: Three pairs have a total duration divisible by 60:
(time[0] = 30, time[2] = 150): total duration 180
(time[1] = 20, time[3] = 100): total duration 120
(time[1] = 20, time[4] = 40): total duration 60

Example 2:

Input: [60,60,60]
Output: 3
Explanation: All three pairs have a total duration of 120, which is divisible by 60.

Note:
1 <= time.length <= 60000
1 <= time[i] <= 500

python解答：

class Solution(object):
    def numPairsDivisibleBy60(self, time):
        """
        :type time: List[int]
        :rtype: int
        """
        count = 0
        if len(time) == 1:
            return 0
        dict1 = {}
        for i in range(len(time)):
            time[i] %= 60
            if time[i] in dict1:
                dict1[time[i]] += 1
            else:
                dict1[time[i]] = 1
        for i in range(31):
            if i in [0, 30]:
                if i in dict1 and dict1[i] > 1:
                    count += dict1[i] * (dict1[i] - 1) / 2
            else:
                if i in dict1 and (60-i) in dict1:
                    count += dict1[i] * dict1[60-i]
        return count

答案解析：本题如果遍历的话，会超时。实际上，每个数除以60的余数可以被用来判断，如果两个数的余数相加刚好为0或者60，那么可以凑成一对，本题的思路也是基于此来做的。

1013.将数组分成和相等的三个部分

Given an array A of integers, return true if and only if we can partition the array into three non-empty parts with equal sums.

Formally, we can partition the array if we can find indexes i+1 < j with (A[0] + A[1] + … + A[i] == A[i+1] + A[i+2] + … + A[j-1] == A[j] + A[j-1] + … + A[A.length - 1])

Example 1:

Input: A = [0,2,1,-6,6,-7,9,1,2,0,1]
Output: true
Explanation: 0 + 2 + 1 = -6 + 6 - 7 + 9 + 1 = 2 + 0 + 1

Example 2:

Input: A = [0,2,1,-6,6,7,9,-1,2,0,1]
Output: false

Example 3:

Input: A = [3,3,6,5,-2,2,5,1,-9,4]
Output: true
Explanation: 3 + 3 = 6 = 5 - 2 + 2 + 5 + 1 - 9 + 4

Constraints:
3 <= A.length <= 50000
-10^4 <= A[i] <= 10^4

python解答：

class Solution(object):
    def canThreePartsEqualSum(self, A):
        """
        :type A: List[int]
        :rtype: bool
        """
        if sum(A) % 3 != 0:
            return False
        each = sum(A)/3
        total = 0
        first = False
        for item in A[:-1]:
            total += item
            if not first and total == each:
                first = True
                total = 0
            elif first and total == each:
                return True
        return False

答案解析：本题思路较为简单，只需要求出数组和，之后除以3，就对应三部分的和，如果存在第一个部分和第二部分的和是总和/3，那么剩下那一部分的和一定也是总和/3。

1018.可被5整除的二进制前缀

Given an array A of 0s and 1s, consider N_i: the i-th subarray from A[0] to A[i] interpreted as a binary number (from most-significant-bit to least-significant-bit.)

Return a list of booleans answer, where answer[i] is true if and only if N_i is divisible by 5.

Example 1:

Input: [0,1,1]
Output: [true,false,false]
Explanation: 
The input numbers in binary are 0, 01, 011; which are 0, 1, and 3 in base-10.  Only the first number is divisible by 5, so answer[0] is true.

Example 2:

Input: [1,1,1]
Output: [false,false,false]

Example 3:

Input: [0,1,1,1,1,1]
Output: [true,false,false,false,true,false]

Example 4:

Input: [1,1,1,0,1]
Output: [false,false,false,false,false]

Note:
1 <= A.length <= 30000
A[i] is 0 or 1

python解答：

class Solution(object):
    def prefixesDivBy5(self, A):
        """
        :type A: List[int]
        :rtype: List[bool]
        """
        list1 = []
        for i in range(len(A)):
            if i:
                A[i] = (A[i] + A[i-1]*2) % 5
            if A[i] == 0:
                list1.append(True)
            else:
                list1.append(False)
        return list1

答案解析：本题使用动态规划，依次把前面的元素求和，之后乘2，相当于全部左移一位，最后加上当前位置的元素。并且，为了防止溢出，将元素对5求余，如果余数为0，那么说明可以整除，返回一个True。

1051.高度检查器

Students are asked to stand in non-decreasing order of heights for an annual photo.

Return the minimum number of students that must move in order for all students to be standing in non-decreasing order of height.

Notice that when a group of students is selected they can reorder in any possible way between themselves and the non selected students remain on their seats.

Example 1:

Input: heights = [1,1,4,2,1,3]
Output: 3
Explanation: 
Current array : [1,1,4,2,1,3]
Target array  : [1,1,1,2,3,4]
On index 2 (0-based) we have 4 vs 1 so we have to move this student.
On index 4 (0-based) we have 1 vs 3 so we have to move this student.
On index 5 (0-based) we have 3 vs 4 so we have to move this student.

Example 2:

Input: heights = [5,1,2,3,4]
Output: 5

Example 3:

Input: heights = [1,2,3,4,5]
Output: 0

Constraints:
1 <= heights.length <= 100
1 <= heights[i] <= 100

python解答：

class Solution(object):
    def heightChecker(self, heights):
        """
        :type heights: List[int]
        :rtype: int
        """
        # target = heights[:]
        # heights.sort()
        # count = 0
        # for i in range(len(heights)):
        #     if heights[i] != target[i]:
        #         count += 1
        # return count
        count = 0
        list1 = [0] * 101
        for i in heights:
            list1[i] += 1
        i = 1
        j = 0
        for i in range(1, 101):
            while list1[i] > 0:
                if heights[j] != i:
                    count += 1
                j += 1
                list1[i] -= 1
        return count

答案解析：本题比较简单的思路就是直接排序，然后比较排序后的数组和原数组的元素变化。但是实际上，没有必要去排序，可以记录每个元素出现的次数，然后在它该出现的位置，如果不是这个元素，说明这里的元素需要调动，那么计算器加一。

1089.复写零

Given a fixed length array arr of integers, duplicate each occurrence of zero, shifting the remaining elements to the right.

Note that elements beyond the length of the original array are not written.

Do the above modifications to the input array in place, do not return anything from your function.

Example 1:

Input: [1,0,2,3,0,4,5,0]
Output: null
Explanation: After calling your function, the input array is modified to: [1,0,0,2,3,0,0,4]

Example 2:

Input: [1,2,3]
Output: null
Explanation: After calling your function, the input array is modified to: [1,2,3]

Note:
1 <= arr.length <= 10000
0 <= arr[i] <= 9

python解答：

class Solution(object):
    def duplicateZeros(self, arr):
        """
        :type arr: List[int]
        :rtype: None Do not return anything, modify arr in-place instead.
        """
        target = arr[:]
        i = 0
        j = 0
        while i < len(arr):
            if target[j] != 0:
                arr[i] = target[j]
                i += 1
            else:
                if i != len(arr)-1:
                    arr[i+1] = 0
                arr[i] = 0
                # arr[i+1] = 0
                i += 2
            j += 1

答案解析：本题我采用了一个额外的数组，而官方则是没有借用额外的空间，首先看有几个0会被复制，然后倒序编写数组的元素。

1122.数组的相对排序

Given two arrays arr1 and arr2, the elements of arr2 are distinct, and all elements in arr2 are also in arr1.

Sort the elements of arr1 such that the relative ordering of items in arr1 are the same as in arr2. Elements that don’t appear in arr2 should be placed at the end of arr1 in ascending order.

Example 1:

Input: arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
Output: [2,2,2,1,4,3,3,9,6,7,19]

Constraints:
arr1.length, arr2.length <= 1000
0 <= arr1[i], arr2[i] <= 1000
Each arr2[i] is distinct.
Each arr2[i] is in arr1.

python解答：

class Solution(object):
    def relativeSortArray(self, arr1, arr2):
        """
        :type arr1: List[int]
        :type arr2: List[int]
        :rtype: List[int]
        """
        target = []
        list1 = []
        dict1 = {}
        for item in arr1:
            if item in arr2 and item in dict1:
                dict1[item] += 1
            elif item in arr2 and item not in dict1:
                dict1[item] = 1
            elif item not in arr2:
                list1.append(item)
        list1.sort()
        for item in arr2:
            for i in range(dict1[item]):
                target.append(item)
        target += list1
        return target

答案解析：本题就是使用一个计数排序，思路比较简单。

1128.等价多米诺骨牌对的数量

Given a list of dominoes, dominoes[i] = [a, b] is equivalent to dominoes[j] = [c, d] if and only if either (ac and bd), or (ad and bc) - that is, one domino can be rotated to be equal to another domino.

Return the number of pairs (i, j) for which 0 <= i < j < dominoes.length, and dominoes[i] is equivalent to dominoes[j].

Example 1:

Input: dominoes = [[1,2],[2,1],[3,4],[5,6]]
Output: 1

Constraints:

1 <= dominoes.length <= 40000
1 <= dominoes[i][j] <= 9

python解答：

class Solution(object):
    def numEquivDominoPairs(self, dominoes):
        """
        :type dominoes: List[List[int]]
        :rtype: int
        """
        for i in range(len(dominoes)):
            dominoes[i].sort()
        count = 0
        dict1 = {}
        for item in dominoes:
            m = str(item[0]) + str(item[1])
            if m in dict1:
                dict1[m] += 1
            else:
                dict1[m] = 1
        for item in dict1.values():
            count += item*(item-1)/2
        return count

答案解析：本题采用计数的方法，例如[1,2]和[2,1]都看作为12，只需要记录出现的次数，然后使用x*(x-1)/2求各个元素对出现的次数，最后相加即可。

1160.拼写单词

You are given an array of strings words and a string chars.

A string is good if it can be formed by characters from chars (each character can only be used once).

Return the sum of lengths of all good strings in words.

Example 1:

Input: words = ["cat","bt","hat","tree"], chars = "atach"
Output: 6
Explanation: 
The strings that can be formed are "cat" and "hat" so the answer is 3 + 3 = 6.

Example 2:

Input: words = ["hello","world","leetcode"], chars = "welldonehoneyr"
Output: 10
Explanation: 
The strings that can be formed are "hello" and "world" so the answer is 5 + 5 = 10.

Note:

1 <= words.length <= 1000
1 <= words[i].length, chars.length <= 100
All strings contain lowercase English letters only.

python解答：

class Solution(object):
    def countCharacters(self, words, chars):
        """
        :type words: List[str]
        :type chars: str
        :rtype: int
        """
        chars_ct =Counter(chars)
        count = 0 
        for item in words:
            symbol = True
            words_ct = Counter(item)
            for i in item:
                if chars_ct[i] < words_ct[i]:
                    symbol = False
            if symbol:
                count += len(item)
        return count

答案解析：本题题意其实是只要chars满足某个单词即可，所以只需要看每个单词出现的次数和chars单词的数量相比结果即可。

1170.比较字符串最小字母出现频次

Let’s define a function f(s) over a non-empty string s, which calculates the frequency of the smallest character in s. For example, if s = “dcce” then f(s) = 2 because the smallest character is “c” and its frequency is 2.

Now, given string arrays queries and words, return an integer array answer, where each answer[i] is the number of words such that f(queries[i]) < f(W), where W is a word in words.

Example 1:

Input: queries = ["cbd"], words = ["zaaaz"]
Output: [1]
Explanation: On the first query we have f("cbd") = 1, f("zaaaz") = 3 so f("cbd") < f("zaaaz").

Example 2:

Input: queries = ["bbb","cc"], words = ["a","aa","aaa","aaaa"]
Output: [1,2]
Explanation: On the first query only f("bbb") < f("aaaa"). On the second query both f("aaa") and f("aaaa") are both > f("cc").

Constraints:
1 <= queries.length <= 2000
1 <= words.length <= 2000
1 <= queries[i].length, words[i].length <= 10
queries[i][j], words[i][j] are English lowercase letters.

python解答：

class Solution(object):
    def numSmallerByFrequency(self, queries, words):
        """
        :type queries: List[str]
        :type words: List[str]
        :rtype: L
        """
        for i in range(len(queries)):
            count = 0
            target = min(queries[i])
            for item in queries[i]:
                if item == target:
                    count += 1
            queries[i] = count
        for i in range(len(words)):
            count = 0
            target = min(words[i])
            for item in words[i]:
                if item == target:
                    count += 1
            words[i] = count
        target = []
        count = 0
        for item1 in queries:
            for item2 in words:
                if item1 < item2:
                    count += 1
            target.append(count)
            count = 0
        return target

答案解析：本题是首选计算最小单词出现的次数，然后比较queries中每个元素比words中小的次数即可。

1184.公交站间的距离

A bus has n stops numbered from 0 to n - 1 that form a circle. We know the distance between all pairs of neighboring stops where distance[i] is the distance between the stops number i and (i + 1) % n.

The bus goes along both directions i.e. clockwise and counterclockwise.

Return the shortest distance between the given start and destination stops.

Example 1:

Input: distance = [1,2,3,4], start = 0, destination = 1
Output: 1
Explanation: Distance between 0 and 1 is 1 or 9, minimum is 1.

Example 2:

Input: distance = [1,2,3,4], start = 0, destination = 2
Output: 3
Explanation: Distance between 0 and 2 is 3 or 7, minimum is 3.

Example 3:

Input: distance = [1,2,3,4], start = 0, destination = 3
Output: 4
Explanation: Distance between 0 and 3 is 6 or 4, minimum is 4.

Constraints:
1 <= n <= 10^4
distance.length == n
0 <= start, destination < n
0 <= distance[i] <= 10^4

python解答：

class Solution(object):
    def distanceBetweenBusStops(self, distance, start, destination):
        """
        :type distance: List[int]
        :type start: int
        :type destination: int
        :rtype: int
        """
        if start < destination:
            sum1 = sum(distance[start:destination])
            sum2 = sum(distance[destination:]) + sum(distance[:start])
        else:
            sum1 = sum(distance[destination:start])
            sum2 = sum(distance[start:]) + sum(distance[:destination])
        return min(sum1,sum2)

答案解析：本题其实只需要判断des-start之间的距离，以及反向环形距离，返回最小值即可。

1200.最小绝对差

Given an array of distinct integers arr, find all pairs of elements with the minimum absolute difference of any two elements.

Return a list of pairs in ascending order(with respect to pairs), each pair [a, b] follows

a, b are from arr
a < b
b - a equals to the minimum absolute difference of any two elements in arr

Example 1:

Input: arr = [4,2,1,3]
Output: [[1,2],[2,3],[3,4]]
Explanation: The minimum absolute difference is 1. List all pairs with difference equal to 1 in ascending order.

Example 2:

Input: arr = [1,3,6,10,15]
Output: [[1,3]]

Example 3:

Input: arr = [3,8,-10,23,19,-4,-14,27]
Output: [[-14,-10],[19,23],[23,27]]

Constraints:

2 <= arr.length <= 10^6
-10^6 <= arr[i] <= 10^6

python解答：

class Solution(object):
    def minimumAbsDifference(self, arr):
        """
        :type arr: List[int]
        :rtype: List[List[int]]
        """
        # arr.sort()
        # target = 10^6
        # for i in range(0, len(arr)-1):
        #     target = min(target, arr[i+1]-arr[i])
        # list1 = []
        # for i in range(len(arr)-1):
        #     if arr[i]+target == arr[i+1]:
        #         list1.append([arr[i], arr[i+1]])
        # return list1
        arr.sort()
        target = {}
        min_target = arr[1] - arr[0]
        for i in range(len(arr)-1):
            diff = arr[i+1] - arr[i]
            if diff <= min_target:
                if diff in target:
                    target[diff].append([arr[i], arr[i+1]])
                else:
                    target[diff] = [[arr[i], arr[i+1]]]
                min_target = diff
        return target[min_target]

答案解析：本题首选还是先排序，那么最小绝对差就一定在i+1和i之间，只需要找到最小绝对差，并且相邻两个元素绝对差等于最小绝对差，返回对应的集合即可。

1217.玩筹码

We have n chips, where the position of the ith chip is position[i].

We need to move all the chips to the same position, In one step, we can change the position of the ith chip from position[i] to:

position[i] + 2 or position[i] - 2 with cost = 0.
position[i] + 1 or position[i] - 1 with cost = 1.
Return the minimum cost needed to move all the chips to the same position.

Example 1:

Input: position = [1,2,3]
Output: 1
Explanation: First step: Move the chip at position 3 to position 1 with cost = 0.
Second step: Move the chip at position 2 to position 1 with cost = 1.
Total cost is 1.

Example 2:

Input: position = [2,2,2,3,3]
Output: 2
Explanation: We can move the two chips at poistion 3 to position 2. Each move has cost = 1. The total cost = 2.

Example 3:

Input: position = [1,1000000000]
Output: 1

Constraints:

1 <= position.length <= 100
1 <= position[i] <= 10^9

python解答：

class Solution(object):
    def minCostToMoveChips(self, position):
        """
        :type position: List[int]
        :rtype: int
        """
        odd = 0
        even = 0
        for item in position:
            if item % 2 == 0:
                even += 1
            else:
                odd += 1
        return min(odd, even)

答案解析：本题主要是思路不是很容易想，首先既然跳两格就消耗0，也就是奇数位的都跳到一个奇数位总消耗为0，偶数位的都跳到一个偶数位总消耗为0，最后要么把奇数位的元素都挪到偶数位，或者把偶数位的元素都挪到奇数位，其实最后只需要比较奇数和偶数最小值返回即可。

1232.缀点成线

You are given an array coordinates, coordinates[i] = [x, y], where [x, y] represents the coordinate of a point. Check if these points make a straight line in the XY plane.

Example 1:

Input: coordinates = [[1,2],[2,3],[3,4],[4,5],[5,6],[6,7]]
Output: true

Example 2:

Input: coordinates = [[1,1],[2,2],[3,4],[4,5],[5,6],[7,7]]
Output: false

Constraints:
2 <= coordinates.length <= 1000
coordinates[i].length == 2
-10^4 <= coordinates[i][0], coordinates[i][1] <= 10^4
coordinates contains no duplicate point.

python解答：

class Solution(object):
    def checkStraightLine(self, coordinates):
        """
        :type coordinates: List[List[int]]
        :rtype: bool
        """
        # if len(coordinates) == 1:
        #     return True
        # if (coordinates[1][0] - coordinates[0][0]) == 0:
        #     for item in coordinates:
        #         if item[0] != coordinates[0][0]:
        #             return False
        # elif (coordinates[1][1] - coordinates[0][1]) == 0:
        #     for item in coordinates:
        #         if item[1] != coordinates[0][1]:
        #             return False
        # else:
        #     slope = (coordinates[1][1] - coordinates[0][1])/(coordinates[1][0] - coordinates[0][0])
        #     for i in range(1, len(coordinates)-1):
        #         if (coordinates[i+1][0] - coordinates[i][0]) == 0:
        #             return False
        #         if (coordinates[i+1][1] - coordinates[i][1])/(coordinates[i+1][0] - coordinates[i][0]) != slope:
        #             return False
        # return True
        if len(coordinates) == 2:
             return True
        x1, y1 = coordinates[0][0], coordinates[0][1]
        x2, y2 = coordinates[1][0], coordinates[1][1]
        for i in range(2, len(coordinates)):
            x3, y3 = coordinates[i][0], coordinates[i][1]
            if (y3 - y2)*(x2 - x1) != (y2 - y1)*(x3 - x2):
                return False
        return True

答案解析：本题没什么难点，唯一注意的就是能用乘法就不用除法，因为会有很多分母为0的情况需要考虑。

1252.奇数值单元格的数目

Given n and m which are the dimensions of a matrix initialized by zeros and given an array indices where indices[i] = [ri, ci]. For each pair of [ri, ci] you have to increment all cells in row ri and column ci by 1.

Return the number of cells with odd values in the matrix after applying the increment to all indices.

Example 1:

Input: n = 2, m = 3, indices = [[0,1],[1,1]]
Output: 6
Explanation: Initial matrix = [[0,0,0],[0,0,0]].
After applying first increment it becomes [[1,2,1],[0,1,0]].
The final matrix will be [[1,3,1],[1,3,1]] which contains 6 odd numbers.

Example 2:

Input: n = 2, m = 2, indices = [[1,1],[0,0]]
Output: 0
Explanation: Final matrix = [[2,2],[2,2]]. There is no odd number in the final matrix.

Constraints:

1 <= n <= 50
1 <= m <= 50
1 <= indices.length <= 100
0 <= indices[i][0] < n
0 <= indices[i][1] < m

python解答：

class Solution(object):
    def oddCells(self, n, m, indices):
        """
        :type n: int
        :type m: int
        :type indices: List[List[int]]
        :rtype: int
        """
        # list1 = [[0] * m for i in range(n)]
        # for i in range(len(indices)):
        #     for j in range(len(list1[0])):
        #         row = indices[i][0]
        #         list1[row][j] += 1
        #     for k in range(len(list1)):
        #         col = indices[i][1]
        #         list1[k][col] += 1
        # count = 0
        # for item in list1:
        #     for ele in item:
        #         if ele % 2 != 0:
        #             count += 1
        # return count
        rows = [False] * n
        cols = [False] * m
        for r,c in indices:
            rows[r] = not rows[r]
            cols[c] = not cols[c]
        count = 0
        for r in range(n):
            for c in range(m):
                if rows[r] != cols[c]:
                    count += 1
        return count