leetcode第181周赛

1.按既定顺序创建数组

给你两个整数数组nums和index。你需要按照以下规则创建目标数组：

• 目标数组target最初为空
• 按从左到右的顺序依次读取nums[i]和index[i]，在target数组中的下标index[I]处插入值nums[I]。
• 重复上一步，直到在nums和index中都没有要读取的元素。

请你返回目标数组。

思路：直接用切片，找到插入位置，切割，插入；

class Solution(object):
    def createTargetArray(self, nums, index):
        """
        :type nums: List[int]
        :type index: List[int]
        :rtype: List[int]
        """
        tar = []
        for i in range(len(nums)):
            t = index[i]
            if t > len(tar):
                tar.append(nums[i])
            else:
                tar = tar[:t] + [nums[i]] + tar[t:]
        return tar

2.四因数

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

思路：直接按题意求解

class Solution(object):
    def sumFourDivisors(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        def help(n):
            cnt = 0
            lis = []
            fl = 1
            i = 1
            while i**2 <= n:
                if n % i == 0:
                    cnt += 2
                    lis.append(i)
                    if n/i != i:
                        lis.append(n/i)
                if cnt > 4:
                    fl = 0
                    break
                i += 1
            if fl and len(lis) == 4:
                return sum(lis)
            else:
                return 0
        res = 0
        for i in nums:
            t = help(i)
            res += t
        return res

3.检查网格中是否存在有效路径

给你一个m*n的网格grid。网格里的每个单元都代表一条街道。gridi][j]的街道可以是：

• 1表示连接左单元格和右单元格的街道。
• 2表示连接上单元格和下单元格的街道。
• 3表示链接左单元格和下单元格的街道。
• 4表示链接右单元格和下单元格的街道。
• 5表示链接左单元格和上单元格的街道。
• 6表示链接右单元格和上单元格的街道。

你最开始从左上角的单元格（0，0）开始出发，网格中的[有效路径]是指从左上方的单元格（0，0）开始、一直到右下方的（m-1，n-1）结束的路径。该路径必须只沿着街道走。
注意：你不能变更街道。
如果网格中存在有效的路径，则返回true，否则返回false。

思路：深度优先搜索或广度优先搜索

1. 从单元格（0，0）开始搜索；对于每一个点，它的每一个状态都对应着它的下一个状态是什么。例如1状态，那么它下一个位置一定在[1,3,5]中。
2. 那么对于每一个单元格，根据它当前状态，看是否有满足条件的单元格存在，若有则讲那个单元格加入搜索列表，反之则跳过。
3. 每一次添加新单元格都检查是否到了右下方的（m-1，n-1）。
4. 为了避免重复，使用一个set来存储已经到达过的单元格。

…其实不难，写起来细心就能过。

4.最长快乐前缀

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

思路1：

• i指针指向第2个字符
• 判断s[i:] == s[:len(s)-i]
• 当满足条件时，此时为最长快乐前缀，返回s[:i]；否则，i+=1

这个方法现在是能过，但是比赛的时候是过不了的。所以需要一个更好的方法。

class Solution(object):
    def longestPrefix(self, s):
        """
        :type s: str
        :rtype: str
        """
        for i in range(1, len(s)):
            j = len(s) - i
            if s[:j] == s[i:]:
                return s[i:]
        return ''

思路2:
字符串 Hash

• 取一固定值P，把字符串看作P进制数，并分配一个大于0的数值，代表每种字符。
• 取一固定值M，求出该P进制数对M的余数，作为该字符串的Hash值。

例如：

     S="abc"
     S表示为P进制数：1 2 3
     H(S)= 1 * p^2 + 2 * p^1 + 3

class Solution(object):
    def longestPrefix(self, s):
        """
        :type s: str
        :rtype: str
        """
        if len(s) == 1:
            return ''
        iHash, jHash ,ind = 0, 0, 1
        res = ''
        for i in range(len(s)-1):
            iHash = iHash * 31 + (ord(s[i]) - 97)
            jHash += (ord(s[len(s)-1-i]) - 97) * ind
            ind *= 31
            if iHash == jHash:
                res = i
        if res != '':
            return s[:res+1]
        return res