【LeetCode】力扣刷题之路 (20240603~20240607)

题目(20240603~20240607)

771.宝石与石头

给你一个字符串 jewels 代表石头中宝石的类型，另有一个字符串 stones 代表你拥有的石头。 stones 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。
字母区分大小写，因此 “a” 和 “A” 是不同类型的石头。

示例 1：

输入：jewels = “aA”, stones = “aAAbbbb”
输出：3

示例 2：

输入：jewels = “z”, stones = “ZZ”
输出：0

提示：

• 1 <= jewels.length, stones.length <= 50
• jewels 和 stones 仅由英文字母组成
• jewels 中的所有字符都是唯一的

方法1：暴力

class Solution:
    def numJewelsInStones(self, jewels: str, stones: str) -> int:
        cnt = 0
        for s in stones:
            if s in jewels:
                cnt += 1
            else:
                continue
        return cnt


if __name__ == '__main__':
    s = Solution()
    # 771.宝石与石头 - 示例1
    jewels = "aA"
    stones = "aAAbbbb"
    res = s.numJewelsInStones(jewels, stones)
    print(res)  # 输出：3
    # 示例2
    jewels = "z"
    stones = "ZZ"
    res = s.numJewelsInStones(jewels, stones)
    print(res)  # 输出：0

方法2：哈希集合

class Solution:
    def numJewelsInStones(self, jewels: str, stones: str) -> int:
        cnt = 0
        jewels_set = set(jewels)
        for s in stones:
            if s in jewels_set:
                cnt += 1
            else:
                continue
        return cnt


if __name__ == '__main__':
    s = Solution()
    # 771.宝石与石头 - 示例1
    jewels = "aA"
    stones = "aAAbbbb"
    res = s.numJewelsInStones(jewels, stones)
    print(res)  # 输出：3
    # 示例2
    jewels = "z"
    stones = "ZZ"
    res = s.numJewelsInStones(jewels, stones)
    print(res)  # 输出：0

方法3：位运算

知识点回顾

位运算：程序中的所有数在计算机内存中都是以二进制的形式储存的。位运算就是直接对整数在内存中的二进制位进行操作。
位或：符号 | ，规则：两个位都为0时，结果才为0。会保留两个操作数中的任何一位的1，只要其中一个是1，结果就是1。
左移：符号 << ，规则：各二进位全部左移若干位，高位丢弃，低位补0。左移操作相当于将数字乘以2的某个幂次。
右移：符号 >> ，规则：各二进位全部右移若干位，对无符号数，高位补0，有符号数，右移补1。
位与：符号 & ，规则：两个位都为1时，结果才为1。
ord()：这个函数获取某个字符的Unicode码点（一个整数）。
注意：只接受一个字符作为参数，如果传入多个字符或者空字符串，将会报错。
应用：例如判断字符的顺序或者对字符进行排序等。
63的二进制：0011 1111

class Solution:
    def numJewelsInStones(self, jewels: str, stones: str) -> int:
        js = 0
        cnt = 0
        for j in jewels:
            js |= 1 << (ord(j) & 63)
        for s in stones:
            cnt += js >> (ord(s) & 63) & 1
        return cnt


if __name__ == '__main__':
    s = Solution()
    # 771.宝石与石头 - 示例1
    jewels = "aA"
    stones = "aAAbbbb"
    res = s.numJewelsInStones(jewels, stones)
    print(res)  # 输出：3
    # 示例2
    jewels = "z"
    stones = "ZZ"
    res = s.numJewelsInStones(jewels, stones)
    print(res)  # 输出：0
    

997.找到小镇的法官

小镇里有 n 个人，按从 1 到 n 的顺序编号。传言称，这些人中有一个暗地里是小镇法官。
如果小镇法官真的存在，那么：
1.小镇法官不会信任任何人。
2.每个人（除了小镇法官）都信任这位小镇法官。
3.只有一个人同时满足属性 1 和属性 2 。
给你一个数组 trust ，其中 trust[i] = [ai, bi] 表示编号为 ai 的人信任编号为 bi 的人。
如果小镇法官存在并且可以确定他的身份，请返回该法官的编号；否则，返回 -1 。

示例 1：

输入：n = 2, trust = [[1,2]]
输出：2

示例 2：

输入：n = 3, trust = [[1,3],[2,3]]
输出：3

示例 3：

输入：n = 3, trust = [[1,3],[2,3],[3,1]]
输出：-1

提示：

• 1 <= n <= 1000
• 0 <= trust.length <= 10⁴
• trust[i].length == 2
• trust 中的所有trust[i] = [ai, bi] 互不相同
• ai != bi
• 1 <= ai, bi <= n

方法1：计算各节点的入度和出度

知识点回顾

有向图 (Directed graphs)：是图论中的一种重要概念，它描述了各种事物之间的有向关系，由一组节点（或顶点）以及连接这些节点的有向边组成，每条有方向的边都连接着一组顶点。在计算机科学、社交网络分析、交通规划等领域都有着广泛的应用，比如社交网络中的关注关系、交通网络中的路线规划等都可以使用有向图来表示。
入度 (Indegree)：通常指有向图中某点作为图中边的终点的次数之和。当入度为 0 时，指有向图中的点不作为任何边的终点，也就是说，这一点所连接的边都把这一点作为起点。
出度 (Out-degree)：对于有向图来说，顶点的出边条数称为该顶点的出度。

from typing import List
from collections import Counter


class Solution:
    def findJudge(self, n: int, trust: List[List[int]]) -> int:
        inDeg = Counter(b for _, b in trust)
        outDeg = Counter(a for a, _ in trust)
        for i in range(1, n + 1):
            if inDeg[i] == n - 1 and outDeg[i] == 0:
                return i
        return -1


if __name__ == "__main__":
    s = Solution()
    # 997.找到小镇的法官 - 示例1
    n = 2
    trust = [[1, 2]]
    res = s.findJudge(n, trust)
    print(res)  # 输出：2
    # 示例2
    n = 3
    trust = [[1, 3], [2, 3]]
    res = s.findJudge(n, trust)
    print(res)  # 输出：3
    # 示例3
    n = 3
    trust = [[1, 3], [2, 3], [3, 1]]
    res = s.findJudge(n, trust)
    print(res)  # 输出：-1

方法2：数组+集合

from typing import List


class Solution:
    def findJudge(self, n: int, trust: List[List[int]]) -> int:
            lista = []
            listb = []
            for a, b in trust:
                lista.append(a)
                listb.append(b)
            j = list(set(range(1, n + 1)) - set(lista))
            if len(j) == 1 and listb.count(j[0]) == n -1:
                return j[0]
            return -1


if __name__ == "__main__":
    s = Solution()
    # 997.找到小镇的法官 - 示例1
    n = 2
    trust = [[1, 2]]
    res = s.findJudge(n, trust)
    print(res)  # 输出：2
    # 示例2
    n = 3
    trust = [[1, 3], [2, 3]]
    res = s.findJudge(n, trust)
    print(res)  # 输出：3
    # 示例3
    n = 3
    trust = [[1, 3], [2, 3], [3, 1]]
    res = s.findJudge(n, trust)
    print(res)  # 输出：-1