Python算法练习 10.8

news2024/11/28 6:26:17

leetcode 2352 相等行列对

给你一个下标从 0 开始、大小为 n x n 的整数矩阵 grid ，返回满足 Ri 行和 Cj 列相等的行列对 (Ri, Cj) 的数目。

如果行和列以相同的顺序包含相同的元素（即相等的数组），则认为二者是相等的。

输入：grid = [[3,2,1],[1,7,6],[2,7,7]]
输出：1
解释：存在一对相等行列对：
- (第 2 行，第 1 列)：[2,7,7]

输入：grid = [[3,1,2,2],[1,4,4,5],[2,4,2,2],[2,4,2,2]]
输出：3
解释：存在三对相等行列对：
- (第 0 行，第 0 列)：[3,1,2,2]
- (第 2 行, 第 2 列)：[2,4,2,2]
- (第 3 行, 第 2 列)：[2,4,2,2]

好吧，我就是无脑暴力专业户

class Solution(object):
    def equalPairs(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        """
        num = 0
        for i in range(len(grid)):
            row_vector = grid[i]
            for j in range(len(grid)):
                col_vector = []
                for k in range(len(grid)):
                    col_vector.append(grid[k][j])
                if row_vector == col_vector:
                    num += 1
        return num

来自题解区大神，学习一下怎么用哈希表：

class Solution:
    def equalPairs(self, grid: List[List[int]]) -> int:
        cnt = Counter(tuple(row) for row in grid)
        return sum(cnt[col] for col in zip(*grid))

tuple(row) for row in grid是生成器表达式用法，将二维矩阵的每一行转换成元组，配合Counter()函数，统计每个元组出现的次数。

zip(*grid)是二维矩阵转置的固定用法

cnt[col] for col in zip(*grid)将每一列作为键在cnt中查找该键对应出现的次数(值)

随后sum()求和

leetcode 2390 从字符串中移除星号

给你一个包含若干星号 * 的字符串 s 。

在一步操作中，你可以：

选中 s 中的一个星号。
移除星号左侧最近的那个 非星号 字符，并移除该星号自身。

返回移除所有星号之后的字符串。

注意：

生成的输入保证总是可以执行题面中描述的操作。
可以证明结果字符串是唯一的。

输入：s = "leet**cod*e"
输出："lecoe"
解释：从左到右执行移除操作：
- 距离第 1 个星号最近的字符是 "leet**cod*e" 中的 't' ，s 变为 "lee*cod*e" 。
- 距离第 2 个星号最近的字符是 "lee*cod*e" 中的 'e' ，s 变为 "lecod*e" 。
- 距离第 3 个星号最近的字符是 "lecod*e" 中的 'd' ，s 变为 "lecoe" 。
不存在其他星号，返回 "lecoe" 。

属是有点过于简单了。。

class Solution(object):
    def removeStars(self, s):
        """
        :type s: str
        :rtype: str
        """
        stack = []
        for i in range(len(s)):
            if s[i] == '*':
                stack.pop()
            else:
                stack.append(s[i])
        return ''.join(stack)

leetcode 735 小行星碰撞

给定一个整数数组 asteroids，表示在同一行的小行星。

对于数组中的每一个元素，其绝对值表示小行星的大小，正负表示小行星的移动方向（正表示向右移动，负表示向左移动）。每一颗小行星以相同的速度移动。

找出碰撞后剩下的所有小行星。碰撞规则：两个小行星相互碰撞，较小的小行星会爆炸。如果两颗小行星大小相同，则两颗小行星都会爆炸。两颗移动方向相同的小行星，永远不会发生碰撞。

示例 1：

输入：asteroids = [5,10,-5]
输出：[5,10]
解释：10 和 -5 碰撞后只剩下 10 。 5 和 10 永远不会发生碰撞。

示例 2：

输入：asteroids = [8,-8]
输出：[]
解释：8 和 -8 碰撞后，两者都发生爆炸。

示例 3：

输入：asteroids = [10,2,-5]
输出：[10]
解释：2 和 -5 发生碰撞后剩下 -5 。10 和 -5 发生碰撞后剩下 10 。

鬼知道我提交了多少次。。第一次忘记考虑碰撞方向

总感觉range()函数有坑，人为给迭代对象+1之后下次就不自增了（是真的，range循环中迭代对象的值改变不会影响循环次数）

class Solution(object):
    def asteroidCollision(self, asteroids):
        """
        :type asteroids: List[int]
        :rtype: List[int]
        """
        # 碰撞完的数组要么全正 要么全负
        stack = []
        # for i in range(len(asteroids)):
        i = 0
        while i < len(asteroids):
            if not stack:
                stack.append(asteroids[i])
                i += 1
                continue
            while stack and i < len(asteroids) and stack[-1] * asteroids[i] < 0 and stack[-1] > asteroids[i]:
                if abs(stack[-1]) < abs(asteroids[i]):
                    stack.pop()
                elif abs(stack[-1]) == abs(asteroids[i]):
                    stack.pop()
                    i += 1
                else:
                    i += 1
            if i < len(asteroids):
                stack.append(asteroids[i])
            i += 1
        return stack