静态Hash表实现

静态Hash表实现

---

在前面的博客中写过如何以接近线性的复杂度实现 “取余hash表” 的存储实现
链接：https://blog.csdn.net/qq_41418281/article/details/100045759

---

引入

  在C++ STL中可以使用map来做离散化处理，预处理一组数，是nlog(n)，但是每次查询都是Log(n)，设查询次数为q，则复杂度为 O(min(nlog(n),qlog(n))) ，一般需要离散化的题目n不会很大 1e6 冲顶，所以只要当查询次数比较大或者多组输入的时候，就有可能超时。
  当然STL还有unorder_map可以用

思路

  用取余实现hash表，在O(1)访问某一个元素的hash值。如何快速访问？假设需要访问的数为x，是不是他的hash值就是x%n（n为数组的长度），其实不然，因为需要考虑同余的数，出现同余时，我们是将他存在下一个空位，所以就会出现偏移的现象。第一大难点在于如何解决偏移的问题，从而达到快速访问的目的。用一个数组exc记录原数组中对应数字在hash值的偏移量，所以最终的hash值为exc[i]+x%n，hash表的实现是用并查集实现的，令nt=x%n，nnt=find(nt)找到对应下一个空位，则Hash[nnt]=x，找到就填上，逆过程则exc[i]=nnt-nt；第二大难点是出现重复数字怎么处理，不同数字不同hash值，同一个数字是一个hash值，这个可以直接用map记录去重，出现过不再增加新的hash值，即不再占位，但是当访问该数的时候，偏移量也是需要使用上一个重复的偏移量才对，所以map里面顺便也存一下上一次的偏移量。这样做感觉还是nlog(n)，其实没有关系，预处理只需要一次，后面的查找都是O(1)，有关离散化的题，关键还是如何优化查找。

代码

int exc[maxn];//记录原数组每个数偏移量
int fa[maxn];//快速寻找下一个空位
int find(int x)
{
    return fa[x]==x?x:fa[x]=find(fa[x]);
}
int Hash[maxn];

void init()
{
    memset(exc,0,sizeof(exc));
    memset(Hash,-1,sizeof(Hash));
    for(int i=1; i<=n; i++)
        fa[i]=i;
}
int build_hash(int n,int ff[])
{
    map<int,pair<int,int> >mm;
    for(int i=1; i<=n; i++)
    {
        int t=ff[i];
        if(mm[t].first>=1)
        {
            exc[i]=mm[t].second;
            continue;
        }
        mm[t].first++;
        int nt=t%n;
        int nnt=find(nt);
        Hash[nnt]=t;
        exc[i]=nnt-nt;
        mm[t].second=nnt-nt;
        int nxt=nnt+1;
        if(nxt==n)
            nxt=0;
        fa[nnt]=find(nxt);
    }
}

int hash_find(int i,int x,int n)
{
    int nx=x%n;
    int len=exc[i];
    int now=nx+len;
    return now;
}

codeforces1208B

题目连接：https://codeforc.es/problemset/problem/1208/D

题解

二分暴力，离散化用了如上实现，用Map会超时
n为2000
二分区间长度 log(n)
需要记录数组中每个数的次数，减去区间中数的次数，判断是否满足其他数唯一
区间暴力搜索，但是需要离散化，如果用map，因为是区间查询一遍复杂度是nlog(n)
需要枚举区间所以nnlog(n) 加上二分，总复杂度为O(n*n*log(n)*log(n))
2000*2000*log(2000)*log(2000) 大约为484000000，肯定会超时，如果使用静态hash表，复杂度会少一个log(N)，1e7能过

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define maxn 2005
#define maxm 2000005
#define INF 2147483647
#define mod  998244353
#define IOS ios::sync_with_stdio(false)

int ff[maxn];
int n;

int exc[maxn];//记录原数组每个数偏移量
int fa[maxn];//快速寻找下一个空位
int find(int x)
{
    return fa[x]==x?x:fa[x]=find(fa[x]);
}
int Hash[maxn];

void init()
{
    memset(exc,0,sizeof(exc));
    memset(Hash,-1,sizeof(Hash));
    for(int i=1; i<=n; i++)
        fa[i]=i;
}
int build_hash(int n,int ff[])
{
    map<int,pair<int,int> >mm;
    for(int i=1; i<=n; i++)
    {
        int t=ff[i];
        if(mm[t].first>=1)
        {
            exc[i]=mm[t].second;
            continue;
        }
        mm[t].first++;
        int nt=t%n;
        int nnt=find(nt);
        Hash[nnt]=t;
        exc[i]=nnt-nt;
        mm[t].second=nnt-nt;
        int nxt=nnt+1;
        if(nxt==n)
            nxt=0;
        fa[nnt]=find(nxt);
    }
}

int hash_find(int i,int x,int n)
{
    int nx=x%n;
    int len=exc[i];
    int now=nx+len;
    return now;
}

bool check(int k)
{
    int cc[maxn];
    memset(cc,0,sizeof(cc));
    for(int i=1; i<=n; i++)
        cc[hash_find(i,ff[i],n)]++;
    for(int i=1; i<=n-k+1; i++)
    {
        bool flag=true;
        int ct[maxn];
        for(int i=0; i<n; i++)
            ct[i]=cc[i];

        for(int j=i; j<=i+k-1; j++)
            ct[hash_find(j,ff[j],n)]--;

        for(int j=0; j<n; j++)
            if(ct[j]>=2)
            {
                flag=false;
                break;
            }
        if(flag)
            return true;
    }
    return false;
}

int main()
{
    IOS;
    cin>>n;
    for(int i=1; i<=n; i++)
        cin>>ff[i];

    init();
    build_hash(n,ff);
    /*for(int i=0; i<n; i++)
        cout<<Hash[i]<<" ";
    cout<<endl;
    for(int i=1; i<=n; i++)
    {
        cout<<hash_find(i,ff[i],n)<<" ";
    }
    cout<<endl;*/

    int L=0,R=n;
    while(L<R)
    {
        int mid=(L+R)/2;
        if(check(mid))R=mid;
        else
            L=mid+1;
        //cout<<"mid="<<mid<<" "<<L<<" "<<R<<" "<<endl;
    }
    cout<<L;
    return 0;
}