【算法训练营】最大间隙，基数排序，字符串匹配（完整代码实现）

最新推荐文章于 2024-10-02 07:55:04 发布

X.AI666

最新推荐文章于 2024-10-02 07:55:04 发布

阅读量925

点赞数 19

分类专栏：算法训练营文章标签：算法数据结构

本文链接：https://blog.csdn.net/chen695969/article/details/136620648

版权

算法训练营专栏收录该内容

17 篇文章 5 订阅

订阅专栏

最大间隙

时间限制：10 sec

空间限制：2 GB

问题描述

给定长度为 n 的数组 a，其中每个元素都为 [0,2^k) 之间的整数，请求出它们在实数轴上相邻两个数之间的最大值（即maxGap）。

由于 n 可能很大，为了避免过大的输入、输出规模，我们会在程序内部生成数据，并要求你输出排序后序列的哈希值。具体方法如下（用c++代码展示）：

typedef unsigned int u32;

u32 nextInt(u32 x){
	x^=x<<13;
	x^=x>>17;
	x^=x<<5;
	return x;
}

void initData(u32 *a,int n,int k,u32 seed){
	for (int i=0;i<n;++i){
		seed=nextInt(seed);
		a[i]=seed>>(32-k);
	}
}

输入将会给定 n,k,seed。

你可以调用 initData(a,n,k,seed) 来获得需要排序的 a 数组。

输入格式

一行 3 个用空格隔开的整数 n,k,seed，意义见题目描述。

输出格式

一行一个整数，表示最大间隙（即maxGap）。

样例输入

5 4 233333

样例输出

样例解释

生成的序列应为 4 10 13 9 4，最大间隙为 9-4=5。

数据范围

本题共设置 4 组数据。

对于第 1 组数据，保证 n=1000，k=16。

对于第 2 组数据，保证 n=5*10^6，k=32。

对于第 3 组数据，保证 n=2^26=67,108,864，k=16。

对于第 4 组数据，保证 n=2^26=67,108,864，k=32。

保证给定的 seed 在 32 位无符号整数的范围内。

提示

[对于 k=16 的数据，使用桶排序即可。]

[对于 k=32 的数据，可以用邓老师上课讲的算法哦！]

[进一步地，如何设置桶的大小来避免较慢的除法运算呢？（提示：可以考虑位运算！）]

代码实现

#include <bits/stdc++.h>
using namespace std;
typedef unsigned int u32;

u32 nextInt(u32 x) {
    x ^= x << 13;
    x ^= x >> 17;
    x ^= x << 5;
    return x;
}

void initData(u32* a, int n, int k, u32 seed) {
    for (int i = 0; i < n; ++i) {
        seed = nextInt(seed);
        a[i] = seed >> (32 - k);
    }
}

const int N = 67108864;
u32 a[N+1];
u32 l[N+1],r[N+1];

u32 maxGap(int n, int k) {
    const int m = 1 << 26;
    memset(l,-1,sizeof(int)*m);
    memset(r,-1,sizeof(int)*m);
    const int _k = max(k-26,0);
    for(int i=0;i<n;++i){
        u32 bl = a[i] >> _k;
        if(l[bl] == -1)
            l[bl] = r[bl] = a[i];
        else if (a[i]<l[bl])
            l[bl] = a[i];
        else if(a[i]>r[bl])
            r[bl] = a[i];
    }
    u32 last = a[0];
    u32 ans = 0;
    for (int i=0;i<m;++i){
        if(l[i] != -1){
            if(last > l[i])
                last = l[i];
            if(l[i] - last > ans)
                ans = l[i] - last;
            last = r[i];
        }
    }
    return ans;
}

int main() {
    int n, k;
    u32 seed;
    scanf("%d%d%u", &n, &k, &seed);
    initData(a, n, k, seed);
    u32 ans = maxGap(n, k);
    printf("%u\n", ans);
    return 0;
}

基数排序

时间限制：10 sec

空间限制：1 GB

问题描述

给定 n 个 [0,2^k) 之间的整数，请你将它们升序排序。

typedef unsigned int u32;

u32 nextInt(u32 x){
	x^=x<<13;
	x^=x>>17;
	x^=x<<5;
	return x;
}

void initData(u32 *a,int n,int k,u32 seed){
	for (int i=0;i<n;++i){
		seed=nextInt(seed);
		a[i]=seed>>(32-k);
	}
}

u32 hashArr(u32 *a,int n){
	u32 x=998244353,ret=0;
	for (int i=0;i<n;++i){
		ret^=(a[i]+x);
		x=nextInt(x);
	}
	return ret;
}

输入将会给定 n,k,seed。

你可以调用 initData(a,n,k,seed) 来获得需要排序的 a 数组。

排序后，你可以调用函数 hashArr(a,n) 来获得我们希望你输出的哈希值。

输入格式

一行 3 个用空格隔开的整数 n,k,seed，意义见题目描述。

输出格式

一行一个整数，表示我们希望你输出的哈希值。

样例输入

5 4 233333

样例输出

740640512

样例解释

生成的序列应为 4 10 13 9 4，排序后的结果应为 4 4 9 10 13。

数据范围

本题共设置 4 组数据。

对于第 1 组数据，保证 n=1000，k=16。

对于第 2 组数据，保证 n=5*10^6，k=32。

对于第 3 组数据，保证 n=10^8，k=16。

对于第 4 组数据，保证 n=10^8，k=32。

保证给定的 seed 在 32 位无符号整数的范围内。

提示

[对于 k=16 的数据，使用基数排序即可。]

[对于 k=32 的数据，不妨考虑两次基数排序哦！（即先排二进制下后 16 位，再排二进制下前 16 位）]

代码实现

#include <bits/stdc++.h>
using namespace std;
typedef unsigned int u32;

u32 nextInt(u32 x) {
    x ^= x << 13;
    x ^= x >> 17;
    x ^= x << 5;
    return x;
}

void initData(vector<u32> &a, int n, int k, u32 seed) {
    for (int i = 0; i < n; ++i) {
        seed = nextInt(seed);
        a[i] = seed >> (32 - k);
    }
}

u32 hashArr(vector<u32> &a, int n) {
    u32 x = 998244353, ret = 0;
    for (int i = 0; i < n; ++i) {
        ret ^= (a[i] + x);
        x = nextInt(x);
    }
    return ret;
}

const int m = 16;
const int B = 1 << m;
const int b = B - 1;
vector<int> sum(B);

void sorting(vector<u32> &a, int n, int k) {
    vector<u32> _a(n);

    // 对32位中的两段分别进行基数排序
    for(int shift = 0; shift < 32; shift += m) {
        fill(sum.begin(), sum.end(), 0);

        for(int i = 0; i < n; ++i)
            ++sum[(a[i] >> shift) & b];

        for(int i = 1; i < B; ++i)
            sum[i] += sum[i-1];

        for(int i = n - 1; i >= 0; --i)
            _a[--sum[(a[i] >> shift) & b]] = a[i];

        a.swap(_a);
    }
}

int main() {
    int n, k;
    u32 seed;
    scanf("%d%d%u", &n, &k, &seed);

    vector<u32> a(n);
    initData(a, n, k, seed);
    sorting(a, n, k);
    u32 ans = hashArr(a, n);

    printf("%u\n", ans);
    return 0;
}

字符串匹配

时间限制：1 sec

空间限制：256 MB

问题描述

给定一个大串 A 和一个模式串 B，求 B 在 A 的哪些位置出现（输出这些出现位置的起始位置，下标从 0 开始）。

输入格式

第一行一个正整数 n，表示串 A 的长度。

第二行包含一个长度为 n 的串 A。

第三行一个正整数 m，表示串 B 的长度。

第四行包含一个长度为 m 的串 B。

保证串 A,B 只包含小写字母。

输出格式

对于每个 B 在 A 中出现的位置，输出单独一行一个整数表示该次出现的起始位置。

对于所有的这些位置，请升序（从小到大）输出。

样例输入

7
abcabca
4
abca

样例输出

0
3

数据范围

对于 60% 的数据，保证 m<=10。

对于另外 20% 的数据，保证 A 的每一位在所有小写字母中等概率随机，且 B 为 A 中截取的一段。

对于 100% 的数据，保证 n<=500,000，m<=100,000。

提示

[此题是单模匹配算法的练习题。]

[可以尝试暴力匹配、KMP算法、Boyer-Moore算法、Rabin-Karp算法，并比较它们的效果。]

代码实现

def kmp_next(pattern):
    length = len(pattern)
    next_list = [-1] * length
    j = -1
    for i in range(1, length):
        while j >= 0 and pattern[i] != pattern[j + 1]:
            j = next_list[j]
        if pattern[i] == pattern[j + 1]:
            j += 1
        next_list[i] = j
    return next_list


def kmp_match(text, pattern):
    n, m = len(text), len(pattern)
    matched_positions = []
    next_list = kmp_next(pattern)
    j = -1
    for i in range(n):
        while j >= 0 and text[i] != pattern[j + 1]:
            j = next_list[j]
        if text[i] == pattern[j + 1]:
            j += 1
        if j == m - 1:
            matched_positions.append(i - j)
            j = next_list[j]
    return matched_positions


def main():
    n = int(input())
    text = input().strip()
    m = int(input())
    pattern = input().strip()
    matched_positions = kmp_match(text, pattern)
    for pos in matched_positions:
        print(pos)


if __name__ == "__main__":
    main()