LeetCode笔记：Biweekly Contest 59（补发）

Posted 2021-10-09 墨客无言

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

1. 题目一

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

• 1974. Minimum Time to Type Word Using Special Typewriter

1. 解题思路

这一题没啥好说的，只要考虑每一个位置所需的移动距离以及按键即可。

初始位置为a，然后移动可以顺时针和逆时针两方向，我们将其进行一下代码语言翻译即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def minTimeToType(self, word: str) -> int:
        def get_movement(src, tgt):
            src, tgt = ord(src), ord(tgt)
            return min((tgt-src+26) % 26, (src-tgt+26) % 26)
        
        n = len(word)
        s = 'a' + word
        return n + sum(get_movement(s[i], s[i+1]) for i in range(n))

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

2. 题目二

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

• 1975. Maximum Matrix Sum

1. 解题思路

显然，对于任意两个位置，我们可以通过一系列的swap操作，使得他们的符号一同发生反转。

因此，我们总可以使得一系列的操作之后，使得至多存在一个数字为负，其余数字均为正数。

此外，我们总可以使得这个唯一可能的负数为绝对值最小的数字。

然后，我们进行求和即可得到最大值。

2. 代码实现

给出python代码实现如下：

class Solution:
    def maxMatrixSum(self, matrix: List[List[int]]) -> int:
        n = len(matrix)
        neg = len([matrix[i][j] for i in range(n) for j in range(n) if matrix[i][j] < 0])
        s = [abs(matrix[i][j]) for i in range(n) for j in range(n)]
        return sum(s) if neg % 2 == 0 else sum(s) - 2*min(s)

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

3. 题目三

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

• 1976. Number of Ways to Arrive at Destination

1. 解题思路

这一题我这边的思路还是使用DijkStra算法进行计算，每次选择对目标域的最近邻点进行考察，然后用两个数组dist和cnt分别来维护从0到第i个节点的最短耗时以及在最短耗时下能够到达的路线种类。

如此一来，对于某一条路线(t, u, v)，其中，u和v表示当前线段的起点和终点，而t表示从走当前路径所需要消耗的总时间t，我们就可以有如下推导关系：

1. 根据Dijkstra算法的定义，那么t总是有序的，因此后续加入的路线中的t必然大于之前所有访问过的节点的时间t，因此，我们可以快速的求取任意一个节点的最短访问时间t；
2. 如果t大于dist[v]，即已经存在到达v的更短路径，那么这条路线将被忽略；
3. 如果t等于dist[v]，那么达到v的最短路径总数将加上到达u的最短路径总数；

如此一来，我们就能够得到最终的答案了。

2. 代码实现

给出python代码实现如下：

class Solution:
    def countPaths(self, n: int, roads: List[List[int]]) -> int:
        MOD = 10**9+7
        
        graph = defaultdict(list)
        for u, v, t in roads:
            graph[u].append((v, t))
            graph[v].append((u, t))
        
        dist = [-1 for i in range(n)]
        cnt = [0 for i in range(n)]
        dist[0] = 0
        cnt[0] = 1
        
        s = []
        seen = set()
        for v, t in graph[0]:
            heapq.heappush(s, (t, 0, v))
            
        while s:
            t, u, v = heapq.heappop(s)
            if dist[-1] != -1 and dist[-1] < t:
                break
            if dist[v] != -1 and dist[v] < t:
                continue
            dist[v] = t
            cnt[v] = (cnt[v] + cnt[u]) % MOD
            if v in seen:
                continue
            seen.add(v)
            for w, dt in graph[v]:
                if dist[w] == -1:
                    heapq.heappush(s, (t+dt, v, w))
        
        return cnt[-1]

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

4. 题目四

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

• 1977. Number of Ways to Separate Numbers

这一题倒是有思路，不过就是暴力地动态规划，然后就爆炸了，超时问题，最后一个测试样例通不过，见鬼，想了好久都没有想到优化方案，所以就不放在这里多说了，唉……