《算法竞赛进阶指南》1.4Hash

137. 雪花雪花雪花

有N片雪花，每片雪花由六个角组成，每个角都有长度。

第i片雪花六个角的长度从某个角开始顺时针依次记为ai,1,ai,2,…,ai,6。

因为雪花的形状是封闭的环形，所以从任何一个角开始顺时针或逆时针往后记录长度，得到的六元组都代表形状相同的雪花。

例如ai,1,ai,2,…,ai,6和ai,2,ai,3,…,ai,6，ai,1

就是形状相同的雪花。

ai,1,ai,2,…,ai,6和ai,6,ai,5,…,ai,1

也是形状相同的雪花。

我们称两片雪花形状相同，当且仅当它们各自从某一角开始顺时针或逆时针记录长度，能得到两个相同的六元组。

求这N片雪花中是否存在两片形状相同的雪花。

输入格式

第一行输入一个整数N，代表雪花的数量。

接下来N行，每行描述一片雪花。

每行包含6个整数，分别代表雪花的六个角的长度（这六个数即为从雪花的随机一个角顺时针或逆时针记录长度得到）。

同行数值之间，用空格隔开。

输出格式

如果不存在两片形状相同的雪花，则输出：

No two snowflakes are alike.

如果存在两片形状相同的雪花，则输出：

Twin snowflakes found.

数据范围

1≤n≤100000,

0≤ai,j<10000000

输入样例：

2

1 2 3 4 5 6

4 3 2 1 6 5

输出样例：

Twin snowflakes found.

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 100010;

int n;
int snows[N][6], idx[N]; 

bool cmp_array(int a[], int b[]) //判断两个数大小 a是不是小于b
{
    for(int i = 0; i < 6; i++)
        if(a[i] > b[i])
            return false;
        else if(a[i] < b[i])
            return true;
    return false;
}

bool cmp(int a, int b)
{
    return cmp_array(snows[a], snows[b]);
}

void get_min(int a[]) //最小表示法
{
    static int b[12];
    for(int i = 0; i < 12; i++) b[i] = a[i % 6]; //首先把a[i]复制2遍

    int i = 0, j = 1, k; //最开始比较第0个和第一个 k表示序列长度
    while(i < 6 && j < 6)
    {
        for(k = 0; k < 6 && b[i + k] == b[j + k]; k ++);
        if(k == 6) break; //说明i和j每一位都相同
        if(b[i + k] > b [j + k]) //大于 可以跳过一段
        {
            i += k + 1;
            if(i == j) i++;
        }
        else
        {
            j += k + 1;
            if(i == j) j++;
        }
    }
    k = min(i, j); //i和j比较小的那个是最小表示的起点
    for(i = 0; i < 6; i++) a[i] = b[i + k];
}

int main()
{
    scanf("%d", &n);
    int snow[6], isnow[6];

    for(int i = 0; i < n; i++)
    {
        for(int j = 0, k = 5; j < 6; j ++, k--)
        {
            scanf("%d",&snow[j]);
            isnow[k] = snow[j]; //逆序
        }
        get_min(snow); //把snow变成最小表示
        get_min(isnow);

        if(cmp_array(snow, isnow)) memcpy(snows[i], snow, sizeof snow);
        else memcpy(snows[i], isnow, sizeof isnow);

        idx[i] = i;
    }
    sort(idx, idx + n, cmp); //排序索引

    bool flag = false; //判断两个序列是否相等
    for(int i = 1; i < n; i++)
        if(!cmp(idx[i - 1], idx[i]) && !cmp(idx[i], idx[i - 1]) ) //cmp判断idx[i-1]是不是小于idx[i] 加个非就是 大于等于 && i >= i-1
        {
            //相等
            flag = true;
            break;
        }
    if(flag) puts("Twin snowflakes found.");
    else puts("No two snowflakes are alike.");
    return 0;
}

138. 兔子与兔子

很久很久以前，森林里住着一群兔子。

有一天，兔子们想要研究自己的 DNA 序列。

我们首先选取一个好长好长的 DNA 序列（小兔子是外星生物，DNA 序列可能包含 26 个小写英文字母）。

然后我们每次选择两个区间，询问如果用两个区间里的 DNA 序列分别生产出来两只兔子，这两个兔子是否一模一样。

注意两个兔子一模一样只可能是他们的 DNA 序列一模一样。

输入格式

第一行输入一个 DNA 字符串 S。

第二行一个数字 m，表示 m 次询问。

接下来 m 行，每行四个数字 l1,r1,l2,r2，分别表示此次询问的两个区间，注意字符串的位置从1开始编号。

输出格式

对于每次询问，输出一行表示结果。

如果两只兔子完全相同输出 Yes，否则输出 No（注意大小写）。

数据范围

1≤length(S),m≤1000000

输入样例：

aabbaabb

3

1 3 5 7

1 3 6 8

1 2 1 2

输出样例：

Yes

No

Yes

#include <iostream>
#include <string.h>

using namespace std;

typedef unsigned long long ULL;
const int N = 1000010, base = 131;

char str[N];
ULL h[N], p[N];

ULL get(int l, int r)
{
    return h[r] - h[l - 1] * p[r - l + 1]; //O(1)的时间求任何字符串的hash值
}

int main()
{
    scanf("%s", str + 1);
    int n = strlen(str + 1);

    p[0] = 1; //表示131的0次方 = 1
    for(int i = 1; i <= n; i++)
    {
        h[i] = h[i - 1] * base + str[i] - 'a' + 1;
        p[i] = p[i - 1] * base;
    }

    int m;
    cin >> m;
    while(m --)
    {
        int l1, r1, l2, r2;
        scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
        if(get(l1, r1) == get(l2, r2)) puts("Yes"); //判断前后两段的hash是不是一样
        else puts("No");
    }
    return 0;
}

139. 回文子串的最大长度

如果一个字符串正着读和倒着读是一样的，则称它是回文的。

给定一个长度为N的字符串S，求他的最长回文子串的长度是多少。

输入格式

输入将包含最多30个测试用例，每个测试用例占一行，以最多1000000个小写字符的形式给出。

输入以一个以字符串“END”（不包括引号）开头的行表示输入终止。

输出格式

对于输入中的每个测试用例，输出测试用例编号和最大回文子串的长度（参考样例格式）。

每个输出占一行。

输入样例：

abcbabcbabcba

abacacbaaaab

END

输出样例：

Case 1: 13

Case 2: 6

#include <iostream>
#include <string.h>
#include <algorithm>

using namespace std;

typedef unsigned long long ULL;
const int N = 2000010, base = 131; //因为要将偶数转为奇数 在每两个之间加# 所以长度要乘二 二百万 

char str[N];
ULL hl[N], hr[N], p[N]; // hl是正序hash值，hr是逆序hash值 p[N]存的是base的多少次方

int get(ULL h[], int l, int r) //求某个子串的hash值
{
    return h[r] - h[l - 1] * p[r - l + 1];
}

int main()
{
    int T = 1;
    while(scanf("%s", str + 1), strcmp(str + 1, "END")) //到END 结束
    {
        int n = strlen(str + 1); //长度

        for(int i = n * 2; i > 0; i -= 2) //在每两个之间加#
        {
            str[i] = str[i / 2]; //拉伸
            str[i - 1] = 'z' + 1; //a-z是26 赋值成27
        }

        n *= 2; //长度乘二
        // puts(str + 1);

        p[0] = 1; //131的0次方
        for(int i = 1, j = n; i <= n; i++, j--) //计算正序逆序hash值
        {
            hl[i] = hl[i - 1] * base + str[i] - 'a' + 1;
            hr[i] = hr[i - 1] * base + str[j] - 'a' + 1;
            p[i] = p[i - 1] * base;
        }

        int res = 0;
        for(int i = 1; i <= n; i++) //枚举中点 二分半径
        {
            int l = 0, r = min(i - 1, n -i); //半径的最小长度是0， 最大半径是min(i - 1, n - i)
            while(l < r)
            {
                int mid = l + r + 1 >> 1;
                if(get(hl, i - mid, i - 1) != get(hr, n - (i + mid) + 1, n - (i + 1) + 1)) r = mid - 1;//左右两边的hash值不一样 说明太大 r = mid - 1
                else l = mid; // l = mid 上面求mid 要 + 1 防止出现死循环
            }

            if(str[i - l] <= 'z') res = max(res, l + 1); //字母多一个  a...b
            else res = max(res, l); // # 多一个  #...#
        }
        printf("Case %d: %d\n", T ++, res);
    }
    return 0;
}

140. 后缀数组

后缀数组 (SA) 是一种重要的数据结构，通常使用倍增或者DC3算法实现，这超出了我们的讨论范围。

在本题中，我们希望使用快排、Hash与二分实现一个简单的O(nlog2n)的后缀数组求法。

详细地说，给定一个长度为 n 的字符串S（下标 0~n-1），我们可以用整数 k(0≤k<n) 表示字符串S的后缀 S(k~n-1)。

把字符串S的所有后缀按照字典序排列，排名为 i 的后缀记为 SA[i]。

额外地，我们考虑排名为 i 的后缀与排名为 i-1 的后缀，把二者的最长公共前缀的长度记为 Height[i]。

我们的任务就是求出SA与Height这两个数组。

输入格式

输入一个字符串，其长度不超过30万。

输出格式

第一行为数组SA，相邻两个整数用1个空格隔开。

第二行为数组Height，相邻两个整数用1个空格隔开，我们规定Height[1]=0。

输入样例：

ponoiiipoi

输出样例：

9 4 5 6 2 8 3 1 7 0

0 1 2 1 0 0 2 1 0 2

#include <iostream>
#include <algorithm>
#include <string.h>
#include <limits.h>

using namespace std;

typedef unsigned long long ULL;
const int N = 300010, base = 131;
int sa[N]; //后缀下标数组

int n;
char str[N];
ULL h[N], p[N]; //前缀hash值数组 

int get(int l, int r)
{
    return h[r] - h[l - 1] * p[r - l + 1];
}

int get_max_common_prefix(int a, int b) //某两个后缀最长公共长度
{
    int l = 0, r = min(n - a + 1, n - b + 1);
    while(l < r)
    {
        int mid = l + r + 1 >> 1;
        if(get(a, a + mid - 1) != get(b, b + mid - 1)) r = mid - 1;// 判断前缀后缀是否相同
        else l = mid;
    }
    return l;
}

bool cmp(int a, int b)
{
    int l = get_max_common_prefix(a, b); //前缀长度
    int av = a + l > n ? INT_MIN : str[a + l]; //字符空 赋值一个很小的数
    int bv = b + l > n ? INT_MIN : str[b + l]; //***这里 是 加上L
    return av < bv;
}

int main()
{
    scanf("%s", str + 1);
    n = strlen(str + 1); //***上面定义了 int n 

    p[0] = 1;
    for(int i = 1; i <= n; i++)
    {
        h[i] = h[i - 1] * base + str[i] - 'a' + 1;
        p[i] = p[i - 1] * base;
        sa[i] = i;
    }

    sort(sa + 1, sa + 1 + n, cmp);

    for(int i = 1; i <= n; i++) printf("%d ", sa[i] - 1);
    puts("");
    for(int i= 1; i <= n; i++) //每两个串之间的公共长度
        if(i == 1) printf("0 ");
        else printf("%d ", get_max_common_prefix(sa[i - 1], sa[i]));
    puts("");
    return 0;

}