记录了初步解题思路 以及本地实现代码；并不一定为最优 也希望大家能一起探讨 一起进步

---

2/17 1287. 有序数组中出现次数超过25%的元素

存在这个元素至少出现num次 那么这个元素必定会出现在位置0，num,2*num…处
找到这些位置 寻找该位置的值出现次数

def findSpecialInteger(arr):
    """
    :type arr: List[int]
    :rtype: int
    """
    import bisect
    n=len(arr)
    num=n//4+1
    for i in range(0,n,num):
        if bisect.bisect_right(arr, arr[i])-bisect.bisect_left(arr, arr[i])>=num:
            return arr[i]
    return -1
    

---

2/18 2080. 区间内查询数字的频率

使用一个map m[value]存放数值x出现的位置
求取m[value]中有多少个位置在[left,right]内
分别求0_left,0right内位置个数 相减即可

from collections import defaultdict
class RangeFreqQuery(object):

    def __init__(self, arr):
        """
        :type arr: List[int]
        """
        self.m = defaultdict(list)
        for i,v in enumerate(arr):
            self.m[v].append(i)


    def query(self, left, right, value):
        """
        :type left: int
        :type right: int
        :type value: int
        :rtype: int
        """
        li = self.m[value]
        if len(li)==0:
            return 0
        if li[0]>right or li[-1]<left:
            return 0
        ansl,ansr=0,0
        if left<=li[0]:
            ansl = 0
        else:
            l,r = 0,len(li)
            while l<=r:
                mid = l+(r-l)//2
                if li[mid]==left:
                    l = mid
                    break
                elif li[mid]>left:
                    r = mid-1
                else:
                    l = mid+1
            ansl = l
            
        if right>=li[-1]:
            ansr = len(li)-1
        else:
            l,r = 0,len(li)
            while l<=r:
                mid = l+(r-l)//2
                if li[mid]==right:
                    r = mid
                    break
                elif li[mid]>right:
                    r = mid-1
                else:
                    l = mid+1
            ansr = r
        if ansr<ansl:
            return 0
        return ansr-ansl+1

---

2/19 624. 数组列表中的最大距离

遍历每个数组 记录最小值 最大值

def maxDistance(arrays):
    """
    :type arrays: List[List[int]]
    :rtype: int
    """
    mi,ma=arrays[0][0],arrays[0][-1]
    ans = 0
    for i in range(1,len(arrays)):
        curmi,curma=arrays[i][0],arrays[i][-1]
        ans=max(ans,abs(ma-curmi),abs(curma-mi))
        mi=min(mi,curmi)
        ma=max(ma,curma)
    return ans
        

---

2/20 2595. 奇偶位数

依次判断当前最低位是否为一 判断好后每次除以2

def evenOddBit(n):
    """
    :type n: int
    :rtype: List[int]
    """
    cur = 0
    even,odd=0,0
    while n:
        if n%2==1:
            if cur%2:
                odd+=1
            else:
                even+=1
        cur+=1
        n//=2
    return [even,odd]

---

2/21 2209. 用地毯覆盖后的最少白色砖块

dp[i][j]表示前i个砖用了j个地毯后最少的白色砖块

def minimumWhiteTiles(floor, numCarpets, carpetLen):
    """
    :type floor: str
    :type numCarpets: int
    :type carpetLen: int
    :rtype: int
    """
    n=len(floor)
    dp = [[float("inf")] * (numCarpets+1) for _ in range(n+1)]
    for j in range(numCarpets+1):
        dp[0][j]=0
    for i in range(1,n+1):
        dp[i][0] = dp[i-1][0]+(1 if floor[i-1]=='1' else 0)
    for i in range(1,n+1):
        for j in range(1,numCarpets+1):
            dp[i][j]=dp[i-1][j]+(1 if floor[i-1]=='1' else 0)
            dp[i][j]=min(dp[i][j],dp[max(0,i-carpetLen)][j-1])
    return dp[n][numCarpets]
        

---

2/22 2506. 统计相似字符串对的数目

使用26位0，1 记录组成字符串的字母出现情况
计算相同字母的字符串个数能够组成的对数

def similarPairs(words):
    """
    :type words: List[str]
    :rtype: int
    """
    tag={}
    for w in words:
        cur = 0
        for c in w:
            cur |= (1<<(ord(c)-ord('a')))
        tag[cur] = tag.get(cur,0)+1
        
    ans = 0
    for v in tag.values():
        ans += v*(v-1)//2
    return ans

---

2/23 1206. 设计跳表

参考 https://leetcode.cn/problems/design-skiplist/solution/she-ji-tiao-biao-by-leetcode-solution-e8yh/
将每个数字看作一个节点 节点最多有MAX_LEVAL层
如果对于某一层 该节点存在 则该位置指向下一个存在的节点
random_level 随机决定该节点层数

import random
MAX_LEVAL = 32
PRO = 0.25
def random_level():
    lv = 1
    while lv<MAX_LEVAL and random.random()<PRO:
        lv+=1
    return lv

class Node:
    __slots__ = ['val','forward']
    def __init__(self,val,maxlev=MAX_LEVAL):
        self.val = val
        self.forward = [None]*maxlev
        
class Skiplist(object):

    def __init__(self):
        self.head = Node(-1)
        self.level = 0


    def search(self, target):
        """
        :type target: int
        :rtype: bool
        """
        cur = self.head
        for i in range(self.level-1,-1,-1):
            while cur.forward[i] and cur.forward[i].val<target:
                cur = cur.forward[i]
        cur = cur.forward[0]
        if cur and cur.val==target:
            return True
        return False


    def add(self, num):
        """
        :type num: int
        :rtype: None
        """
        new = [self.head]*MAX_LEVAL
        cur = self.head
        for i in range(self.level-1,-1,-1):
            while cur.forward[i] and cur.forward[i].val<num:
                cur = cur.forward[i]
            new[i] = cur
        lv = random_level()
        self.level = max(self.level,lv)
        newnode = Node(num,lv)
        for i in range(lv):
            newnode.forward[i] = new[i].forward[i]
            new[i].forward[i] = newnode
            


    def erase(self, num):
        """
        :type num: int
        :rtype: bool
        """
        new = [self.head]*MAX_LEVAL
        cur = self.head
        for i in range(self.level-1,-1,-1):
            while cur.forward[i] and cur.forward[i].val<num:
                cur = cur.forward[i]
            new[i] = cur
        cur = cur.forward[0]
        if not cur or cur.val!=num:
            return False
        for i in range(self.level):
            if new[i].forward[i]!=cur:
                break
            new[i].forward[i] = cur.forward[i]
        while self.level>1 and not self.head.forward[self.level-1]:
            self.level-=1
        return True
        

---