leetcode日常总结九

674、697，717，724，746，747，766
674：最长连续递增序列
题目描述：
给定一个未经排序的整数数组，找到最长且连续的的递增序列。
思路：
遍历并比较长度。
代码：

class Solution(object):

    def findLengthOfLCIS(self, nums):

        """

        :type nums: List[int]

        :rtype: int

        """

        if len(nums)<2:

            return len(nums)

        else:

            count=1

            max1=1

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

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

                    count+=1

                else:

                    max1=max(max1,count)

                    count=1

        return max(max1,count)

697：数组的度
题目描述：
给定一个非空且只包含非负数的整数数组 nums, 数组的度的定义是指数组里任一元素出现频数的最大值。你的任务是找到与 nums 拥有相同大小的度的最短连续子数组，返回其长度。
思路：
1、用字典记录每个数的频数，每个数对应的索引范围 ， a[nums[i]]=[1,i,i]
2、遍历字典找出频数最大的数，并记录索引范围，若出现频数相同，比较索引范围，得出较小的索引范围即可。
代码：

class Solution(object):

    def findShortestSubArray(self, nums):

        """

        :type nums: List[int]

        :rtype: int

        """

        a=dict()

        for i in range(len(nums)):

            if nums[i] not in a:

                a[nums[i]]=[1,i,i]

            else:

                a[nums[i]][0]+=1

                a[nums[i]][2]=i

        max1=0

        for i in a.keys():

            if a[i][0]>max1:

                max1=a[i][0]

                minlen=a[i][2]-a[i][1]+1

            elif a[i][0]==max1:

                if a[i][2]-a[i][1]+1<minlen:

                    minlen=a[i][2]-a[i][1]+1

        return minlen

717：1比特与2比特字符
题目描述：
有两种特殊字符。第一种字符可以用一比特0来表示。第二种字符可以用两比特(10 或 11)来表示。现给一个由若干比特组成的字符串。问最后一个字符是否必定为一个一比特字符。给定的字符串总是由0结束。
思路：
如果数组长度是1，直接看0位是不是0.
如果数组长度大于1，从倒数第二位开始往前数连续多少个1.偶数个1，说明可以凑成11，奇数个1说明最后2位必然是10。
代码：

class Solution(object):
    def isOneBitCharacter(self, bits):
        """
        :type bits: List[int]
        :rtype: bool
        """
        a=0
        for i in range(len(bits)-2,-1,-1):
            if bits[i]==0:
                break
            else:
                a+=1
        result=a%2
        if result==0:
            return True
        else:
            return False

724：寻找数组的中心索引
题目描述：
给定一个整数类型的数组 nums，请编写一个能够返回数组“中心索引”的方法。我们是这样定义数组中心索引的：数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。如果数组不存在中心索引，那么我们应该返回 -1。如果数组有多个中心索引，那么我们应该返回最靠近左边的那一个。
思路：
先遍历一次求出总和，作为b。然后再遍历一次数组，每次b减当前元素，此时如果b和a,相等，就找到了中心索引，中断遍历。如果不等，则a加上当前元素后，继续遍历。
代码：

def pivotIndex(self, nums):

        """

        :type nums: List[int]

        :rtype: int

        """

        a=0

        b=sum(nums)

        for i in range(len(nums)):

            c=b-a-nums[i]

            if c==a:

                return i

            else:

                a=a+nums[i]

        return -1

746:使用最小化费爬楼梯
题目描述：
数组的每个索引做为一个阶梯，第 i个阶梯对应着一个非负数的体力花费值 costi。每当你爬上一个阶梯你都要花费对应的体力花费值，然后你可以选择继续爬一个阶梯或者爬两个阶梯。您需要找到达到楼层顶部的最低花费。在开始时，你可以选择从索引为 0 或 1 的元素作为初始阶梯。
思路：

代码：

class Solution(object):

    def minCostClimbingStairs(self, cost):

        """

        :type cost: List[int]

        :rtype: int

        """

        cost.insert(0,0)

        cost.append(0)

        for i in range(2,len(cost)):

            cost[i]+=min(cost[i-1],cost[i-2])

        return cost[-1]

747：至少是其他数字两倍的最大数
题目描述：
在一个给定的数组nums中，总是存在一个最大元素。查找数组中的最大元素是否至少是数组中每个其他数字的两倍，如果是，则返回最大元素的索引，否则返回-1
思路：
1：找到最大值，与各个元素比较不符合返回-1
2：找到最大值与次大值，不符合返回-1

代码:

class Solution(object):

    def dominantIndex(self, nums):

        """

        :type nums: List[int]

        :rtype: int

        """

        a=max(nums)

        b=nums.index(a)

        if b==0:

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

                if a>=nums[i]*2:

                    continue

                else:

                    return -1

        elif b==len(nums)-1:

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

                if a>=nums[i]*2:

                    continue

                else:

                    return -1

        else:

            for i in range(0,b):

                if a>=nums[i]*2:

                    continue

                else:

                    return -1

        

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

                if a>=nums[i]*2:

                    continue

                else:

                    return -1

        return b

766：托普利茨矩阵
题目描述：
如果一个矩阵的每一方向由左上到右下的对角线上具有相同元素，那么这个矩阵是托普利茨矩阵。给定一个 M x N 的矩阵，当且仅当它是托普利茨矩阵时返回 True。
思路：
每一行的除最后一个元素外与下一行除第一个元素外的所有元素对应相等。
代码：

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

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

            if matrix[i][:-1]!=matrix[i+1][1:]:

                return False

        return True