LeetCode笔记：Weekly Contest 260

• LeetCode笔记：Weekly Contest 260
  • 1. 题目一
    • 1. 解题思路
    • 2. 代码实现
  • 2. 题目二
    • 1. 解题思路
    • 2. 代码实现
  • 3. 题目三
    • 1. 解题思路
    • 2. 代码实现
  • 4. 题目四
    • 1. 解题思路
    • 2. 代码实现

1. 题目一

给出题目一的试题链接如下：

• 2016. Maximum Difference Between Increasing Elements

1. 解题思路

第一题其实没啥好说的，只要考察每一个元素左侧的最小元素，如果最小元素都比该元素大，那么必然无法成立，反之就是这个元素作为较大值时能够取到的最大差值。

2. 代码实现

给出python代码实现如下：

class Solution:
    def maximumDifference(self, nums: List[int]) -> int:
        _min, res = math.inf, -1
        for x in nums:
            if x > _min:
                res = max(res, x - _min)
            _min = min(x, _min)
        return res

提交代码评测得到：耗时44ms，占用内存14.3MB。

2. 题目二

给出题目二的试题链接如下：

• 2017. Grid Game

1. 解题思路

这一题本身还是挺难的，不过由于限制了维度只有2，且只允许向下或者向右走，这就大大简化了这道题目。

显然，无论前者选择在第几个位置向下行走（假设为i），后手位想要获得最大的分数，能够走的路线必然是直接下行或者是最后一步下行，然后两者线路不重合的部分就是其能够取得的最大分数。

而这部分的内容，我们可以通过实现计算好累积数列的方式进行求解，这样可以使得计算复杂度限制在$O(N)$。

2. 代码实现

给出python代码实现如下：

class Solution:
    def gridGame(self, grid: List[List[int]]) -> int:
        n = len(grid[0])
        l2r = [0] + list(accumulate(grid[1]))
        r2l = [0 for _ in range(n+1)]
        for i in range(n-1, -1, -1):
            r2l[i] = r2l[i+1] + grid[0][i]
        res = min(max(l2r[i], r2l[i+1]) for i in range(n))
        return res

提交代码评测得到：耗时1140ms，占用内存31MB。

3. 题目三

给出题目三的试题链接如下：

• 2018. Check if Word Can Be Placed In Crossword

1. 解题思路

这一题的思路也相对简单，就是分别从横向、纵向、正向、反向进行考察，只要有一个匹配上，那么就是可行的，否则就是不可匹配的。

需要注意的是，由于题目限制了匹配的方式必须是不留空的完美匹配，因此就把题目给简化了，我们只需要从空格的开始位置直接开始匹配就行了，虽然算法复杂度还是KaTeX parse error: Undefined control sequence: \cdotN at position 4: O(4\̲c̲d̲o̲t̲N̲^2)，但整体上终究还是可以接受的。

2. 代码实现

给出python代码实现如下：

class Solution:
    def placeWordInCrossword(self, board: List[List[str]], word: str) -> bool:
        n, m, l = len(board), len(board[0]), len(word)
        
        def check_horizon(idx):
            # check forward
            j, match = 0, True # init
            for i in range(m):
                if board[idx][i] == "#":
                    if j == l and match:
                        return True
                    j, match = 0, True # init
                    if m-i-1 < l:
                        break
                    continue
                if j >= l:
                    match = False
                elif board[idx][i] != " " and board[idx][i] != word[j]:
                    match = False
                j += 1
            if j == l and match:
                return True
            
            # check backward
            j, match = 0, True # initj = 0
            for i in range(m-1, -1, -1):
                if board[idx][i] == "#":
                    if j == l and match:
                        return True
                    j, match = 0, True # init
                    if i < l:
                        break
                    continue
                if j >= l:
                    match = False
                elif board[idx][i] != " " and board[idx][i] != word[j]:
                    match = False
                j += 1
            return j == l and match
        
        def check_vertical(idx):
            # check forward
            j, match = 0, True # init
            for i in range(n):
                if board[i][idx] == "#":
                    if j == l and match:
                        return True
                    j = 0
                    match = True
                    if n-i-1 < l:
                        break
                    continue
                if j >= l:
                    match = False
                elif board[i][idx] != " " and board[i][idx] != word[j]:
                    match = False
                j += 1
            if j == l and match:
                return True
            
            # check backward
            j, match = 0, True # init
            for i in range(n-1, -1, -1):
                if board[i][idx] == "#":
                    if j == l and match:
                        return True
                    j, match = 0, True # init
                    if i < l:
                        break
                    continue
                if j >= l:
                    match = False
                elif board[i][idx] != " " and board[i][idx] != word[j]:
                    match = False
                j += 1
            return j == l and match
        
        if l <= m:
            if any(check_horizon(i) for i in range(n)):
                return True
        if l <= n:
            if any(check_vertical(i) for i in range(m)):
                return True
        return False  

提交代码评测得到：耗时1272ms，占用内存26.1MB。

4. 题目四

给出题目四的试题链接如下：

• 2019. The Score of Students Solving Math Expression

1. 解题思路

这一题思路也非常简单，就是计算出正解以及所有的可行解，然后对解集当中的所有答案进行评分，即可得到最终的答案。

唯一需要注意的是，这样的暴力解法其实是很耗时的，这里得亏限制了解不能大于1000且数字必须为一位数，才减少了一定的算法复杂度，使之可以通过测试……

2. 代码实现

给出python代码实现如下：

class Solution:
    def scoreOfStudents(self, s: str, answers: List[int]) -> int:
        
        @lru_cache(None)
        def dfs(i, j):
            if j-i <= 3:
                return {eval(s[i:j])}
            res = set()
            for k in range(i+1, j, 2):
                p1 = dfs(i, k)
                p2 = dfs(k+1, j)
                if s[k] == "+":
                    res = res | {x+y for x in p1 for y in p2 if x+y <= 1000}
                else:
                    res = res | {x*y for x in p1 for y in p2 if x+y <= 1000}
            return res
        
        true_answer = eval(s)
        all_answers = dfs(0, len(s))
        
        def get_score(ans):
            if ans == true_answer:
                return 5
            return 2 if ans in all_answers else 0
        
        cnt = Counter(answers)
        # print(cnt)
        return sum([get_score(k) * v for k, v in cnt.items()])

提交代码评测得到：耗时4172ms，占用内存51.6MB。