2024.3.12力扣(＜=1200)刷题记录

一、2455. 可被三整除的偶数的平均值

可被3整除的偶数即能被6整除的数，遍历即可。注意个数为0时不能作分母，需要单独判断。

class Solution:
    def averageValue(self, nums: List[int]) -> int:
        # 遍历
        sum = 0
        count = 0
        for x in nums:
            if x % 6 == 0:
                count += 1
                sum += x
        if count == 0:
            return 0                
        return sum // count

二、 1290. 二进制链表转整数

1.位运算：

 需要新加一位时，就先左移一位。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def getDecimalValue(self, head: ListNode) -> int:
        # 二进制位运算
        p = head
        ans = 0
        while p != None:
            ans <<= 1
            ans += p.val
            p = p.next
        return ans

2.数学运算

方法参考官方题解（. - 力扣（LeetCode））。位运算的本质：每向左移动一位，即变为原来的两倍（*2）。代码如下：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def getDecimalValue(self, head: ListNode) -> int:
        # 数学运算
        p = head
        ans = 0
        while p != None:
            ans = ans*2 + p.val
            p = p.next
        return ans

三、1460. 通过翻转子数组使两个数组相等

因为翻转次数没有限制，只要知道数组内容是否相同，即可知道是否能通过翻转得到。

1.排序后比较，时复O(nlogn)。

class Solution:
    def canBeEqual(self, target: List[int], arr: List[int]) -> bool:
        # 排序
        target.sort()
        arr.sort()
        if target == arr:
            return True
        return False

2.遍历后比较，时复O(n)。

遍历结果存入字典。

class Solution:
    def canBeEqual(self, target: List[int], arr: List[int]) -> bool:
        # 遍历 字典存
        target_ = {}
        arr_ = {}
        for x in target:
            target_[x] = target_.get(x,0) + 1
        for x in arr:
            arr_[x] = arr_.get(x,0) + 1
        if target_ == arr_:
            return True
        return False

或者用列表存。因为这道题数据最大为1000，所以开辟一个1001长的列表即可。运行速度比用字典存快（且比排序稍稍快一点），空间换时间了。

class Solution:
    def canBeEqual(self, target: List[int], arr: List[int]) -> bool:
        # 遍历 列表存
        target_ = [0] * 1001
        arr_ = [0] * 1001
        for x in target:
            target_[x] += 1
        for x in arr:
            arr_[x] += 1
        if target_ == arr_:
            return True
        return False

另外发现在统计词频时，可以只使用一个列表存储来减少内存。解法参考（. - 力扣（LeetCode））方法二。代码如下：

class Solution:
    def canBeEqual(self, target: List[int], arr: List[int]) -> bool:
        # 遍历 一个列表
        count = [0]*1001
        for x in target:
            count[x] += 1
        for x in arr:
            count[x] -= 1
            if count[x] < 0:
                return False
        return True

上述代码中：

if count[x] < 0:
    return False

为什么只判断小于0，而不考虑大于0呢？因为利用了两数组长度相等的性质。一旦有频次相减大于0的则必有频次相减小于0的，因为所有元素总频次相等，即数组长度。（受评论. - 力扣（LeetCode）启发） 

3.Counter()函数

另外python还可以使用Counter（）函数统计词频（函数时间复杂度O(n)），是在看官方题解时看到的（. - 力扣（LeetCode））。代码如下：

class Solution:
    def canBeEqual(self, target: List[int], arr: List[int]) -> bool:
        # Counter函数
        return Counter(target) == Counter(arr)

关于Counter（）函数的相关用法，学习自文章：http://t.csdnimg.cn/E3gaq 

四、2778. 特殊元素平方和

题目分析：

该题要求下标能整除数组长度，本质上是找长度n的公因数。而找公因数并不需要从1遍历到n，只需要遍历到根号n，能被整除时，除数和商均为公因数。另外注意下标从1开始，所以做索引时要-1。时间复杂度：O(根号n)

另外要注意的一个点是，如果n是平方数，则会多加一次（商和除数均为根号n），所以需要判断一下。

代码如下：

class Solution:
    def sumOfSquares(self, nums: List[int]) -> int:
        n = len(nums)
        ans = 0
        for i in range(1,int(n**0.5)+1):    #最后一位取不到，所以+1
            if n % i == 0:
                ans += nums[i-1]**2
                if i != n//i:
                    ans += nums[n//i-1]**2
        return ans

还有一种方法是遍历从1到n，这里就不过多描述。

感谢的你看到这里！一起加油吧！