LeetCode 182th competition

1、给你两个整数数组 nums 和 index。你需要按照以下规则创建目标数组：
1）目标数组 target 最初为空。
2）按从左到右的顺序依次读取 nums[i] 和 index[i]，在 target 数组中的下标 index[i] 处插入值 nums[i] 。
请你返回目标数组。

示例 1：
输入：nums = [0,1,2,3,4], index = [0,1,2,2,1]
输出：[0,4,1,3,2]
链接: lhttps://leetcode-cn.com/problems/create-target-array-in-the-given-order/

class Solution:
    def createTargetArray(self, nums: List[int], index: List[int]) -> List[int]:
        # insert 函数也可
        ans = []
        for i in range(len(nums)):
            if index[i] == len(ans):
                ans.append(nums[i])
            else:
                ans = ans[0:index[i]] + [nums[i]] + ans[index[i]:]
        return ans

2、你一个整数数组 nums，请你返回该数组中恰有四个因数的这些整数的各因数之和。如果数组中不存在满足题意的整数，则返回 0 。

示例：
输入：nums = [21,4,7]
输出：32
解释：
21 有 4 个因数：1, 3, 7, 21
4 有 3 个因数：1, 2, 4
7 有 2 个因数：1, 7
答案仅为 21 的所有因数的和。

class Solution:
    def sumFourDivisors(self, nums: List[int]) -> int:
        ans = 0
        def f(n):
            # 防重复
            res = set()
            # 复杂化
            for i in range(1,int(n**0.5+1)):
                if n % i == 0:
                    res.add(i)
                    res.add(n//i)
                    if len(res) > 4:break
            return sum(res) if len(res) == 4 else 0
        
        for j in nums:
            ans += f(j)

        return ans

3、你一个 m x n 的网格 grid。网格里的每个单元都代表一条街道。grid[i][j] 的街道可以是：

从左上角的单元格 (0,0) 开始出发，网格中的「有效路径」是指从左上方的单元格 (0,0) 开始、一直到右下方的 (m-1,n-1) 结束的路径。该路径必须只沿着街道走。如果网格中存在有效的路径，则返回 true，否则返回 false 。
示例 1：

输入：grid = [[2,4,3],[6,5,2]]
输出：true

class Solution:
    def hasValidPath(self, grid: List[List[int]]) -> bool:
        m, n = len(grid), len(grid[0])
        q = [(0, 0)]
        used = {(0, 0)}

        while q:
            x, y = q.pop(0)
            if x == m - 1 and y == n - 1:
                return True
            z = grid[x][y]
            if z in (1, 3, 5) and y > 0 and grid[x][y-1] in (1, 4, 6) and (x, y-1) not in used:
                q.append((x, y - 1))
                used.add((x, y-1))
            if z in (1, 4, 6) and y < n - 1 and grid[x][y + 1] in (1, 3, 5) and (x, y+1) not in used:
                q.append((x, y + 1))
                used.add((x, y + 1))
            if z in (2, 5, 6) and x > 0 and grid[x - 1][y] in (2, 3, 4) and (x-1, y) not in used:
                q.append((x - 1, y))
                used.add((x - 1, y))
            if z in (2, 3, 4) and x < m - 1 and grid[x + 1][y] in (2, 5, 6) and (x+1, y) not in used:
                q.append((x + 1, y))
                used.add((x+1, y))

        return False

4、「快乐前缀」是在原字符串中既是 非空 前缀也是后缀（不包括原字符串自身）的字符串。给你一个字符串 s，请你返回它的 最长快乐前缀。如果不存在满足题意的前缀，则返回一个空字符串。

示例 1：
输入：s = “level”
输出：“l”
解释：不包括 s 自己，一共有 4 个前缀（“l”, “le”, “lev”, “leve”）和 4 个后缀（“l”, “el”, “vel”, “evel”）。最长的既是前缀也是后缀的字符串是 “l” 。

# kmp
class Solution:
    def longestPrefix(self, s: str) -> str:
        n = len(s)
        fail = [-1] * n
        for i in range(1, n):
        	# j记录前 i 个字符串最长前缀后缀个数（比实际少1）
            j = fail[i - 1]
            # 当有最长前缀后缀时，对比不等时回溯，结束条件为回溯后字符相等或此时s[:j+1]已没有最长前缀后缀
            while j != -1 and s[j + 1] != s[i]:
                # 针对此最长前缀后缀中的最长前缀后缀进行移动
                j = fail[j]

            if s[j + 1] == s[i]:
                fail[i] = j + 1

        return s[:fail[-1] + 1]