1460 我在哪？（二分、字符串哈希）

yuzhang_zy

已于 2022-02-27 16:21:34 修改

阅读量263

点赞数

分类专栏： acwing-提高文章标签：算法

于 2022-02-27 16:18:49 首次发布

本文链接：https://blog.csdn.net/qq_39445165/article/details/123165363

版权

acwing-提高专栏收录该内容

456 篇文章 15 订阅

订阅专栏

1. 问题描述：

农夫约翰出门沿着马路散步，但是他现在发现自己可能迷路了！沿路有一排共 N 个农场。不幸的是农场并没有编号，这使得约翰难以分辨他在这条路上所处的位置。然而，每个农场都沿路设有一个彩色的邮箱，所以约翰希望能够通过查看最近的几个邮箱的颜色来唯一确定他所在的位置。每个邮箱的颜色用 A..Z 之间的一个字母来指定，所以沿着道路的 N 个邮箱的序列可以用一个长为 N 的由字母 A..Z 组成的字符串来表示。某些邮箱可能会有相同的颜色。约翰想要知道最小的 K 的值，使得他查看任意连续 K 个邮箱序列，他都可以唯一确定这一序列在道路上的位置。例如，假设沿路的邮箱序列为 ABCDABC 。约翰不能令 K=3，因为如果他看到了 ABC，则沿路有两个这一连续颜色序列可能所在的位置。最小可行的 K 的值为 K=4，因为如果他查看任意连续 4 个邮箱，那么可得到的连续颜色序列可以唯一确定他在道路上的位置。

输入格式

输入的第一行包含 N，第二行包含一个由 N 个字符组成的字符串，每个字符均在 A..Z 之内。

输出格式

输出一行，包含一个整数，为可以解决农夫约翰的问题的最小 K 值。

数据范围

1 ≤ N ≤ 100

输入样例：

7
ABCDABC

输出样例：

4
来源：https://www.acwing.com/problem/content/description/1462/

2. 思路分析：

分析题目可以知道已知一个字符串，我们需要找到最小的k使得所有长度为k的子串两两不同，因为涉及到"最小"的问题，所以我们考虑能否使用二分来解决，能否使用二分来解决的一个充分必要条件是：是否具有二段性，也即当前答案为res，res左右两边的子串是否是确定的，可以发现是具有两段性的，因为如果所有长度为ans的子串都是两两不同的，那么长度大于ans的子串也一定两两不同，因为前缀长度为ans的字符串一定不同，而长度小于ans的子串则不满足两两不同所以具有两段性，那么我们就可以使用二分来解决了，所以问题就转化为了如何快速判断两个字符串是否相同呢？可以使用哈希表进行判断，我们可以枚举所有长度为mid的子串，如果发现之前存在当前枚举的字符串说明就重复了不满足要求，除了使用哈希表判断的方法之外我们还可以使用字符串哈希进行判断，字符串哈希使用O(n)的时间预处理出从第一个字符到后面字符的哈希值，然后我们就可以使用O(1)的时间查询出区间[l，r]的哈希值，这样每一个字符串就可以看成是一个整数（字符串哈希类似于前缀和的思想）。

如果使用python语言可以发现其实字符串哈希比直接字典来解决的做法要慢很多，但是对于像c++，c语言会明显快很多，c++可以使用unordered_set来表示一个哈希表。

3. 代码如下：

二分 + 哈希表：

class Solution:
    def check(self, s: str, mid: int):
        # 使用哈希表进行判断这样代码比较短一点
        mp = dict()
        for i in range(len(s) - mid + 1):
            if s[i: i + mid] in mp: return False
            mp[s[i: i + mid]] = 1
        return True

    def process(self):
        n = int(input())
        s = input()
        l, r = 1, n
        while l < r:
            mid = l + r >> 1
            if self.check(s, mid):
                r = mid
            else:
                l = mid + 1
        return r


if __name__ == '__main__':
    print(Solution().process())

二分 + 字符串哈希：

from typing import List


class Solution:
    # 预处理字符串的哈希值, 字符串哈希中字符的下标是从1开始的
    def hash(self, s: str, P: int, h: List[int], Q: List[int]):
        for i in range(1, len(s) + 1):
            c = ord(s[i - 1])
            h[i] = h[i - 1] * P + c
            Q[i] = Q[i - 1] * P

    # 查询子串[l, r]的哈希值, 这里的l, r下标是从1开始的, 查询的时候直接使用公式即可
    def query(self, l: int, r: int, h: List[int], Q: List[int]):
        return h[r] - h[l - 1] * Q[r - l + 1]

    def check(self, mid: int, s: str, h: List[int], Q: List[int]):
        mp = dict()
        for i in range(len(s) - mid + 1):
            # 这里需要注意一下是从i + 1开始的长度为mid的子串(下标是从1开始的)
            x = self.query(i + 1, i + mid, h, Q)
            if x in mp: return False
            mp[x] = 1
        return True

    def process(self):
        n = int(input())
        s = input()
        # P是一个质数, 为131或者是13331这样发生的冲突会比较小
        P = 13331
        # Q存储P的i次幂
        Q = [0] * (n + 10)
        Q[0] = 1
        # h存储从第一个字符到后面字符的哈希值, 相当于存储的是一个前缀和
        h = [0] * (n + 10)
        # 预处理
        self.hash(s, P, h, Q)
        # 二分
        l, r = 1, n
        while l < r:
            mid = l + r >> 1
            if self.check(mid, s, h, Q):
                r = mid
            else:
                l = mid + 1
        return r


if __name__ == "__main__":
    print(Solution().process())