CSU-2037 Mars（字符串hash + dfs）

最新推荐文章于 2020-05-02 22:04:39 发布

破晓③

最新推荐文章于 2020-05-02 22:04:39 发布

阅读量271

点赞数

CC 4.0 BY-SA版权

分类专栏： ACM 字符串文章标签： ACM 字符串

本文链接：https://blog.youkuaiyun.com/Lee_w_j__/article/details/79871962

ACM 同时被 2 个专栏收录

102 篇文章

订阅专栏

字符串

5 篇文章

订阅专栏

本文介绍了一道字符串处理题目（CSUOJ 2037）的解题思路，利用字符串哈希和后缀自动机解决如何通过最少操作改变子串，避免其成为原串的子串。提供了AC代码及优化技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接：http://acm.csu.edu.cn/csuoj/problemset/problem?pid=2037

题目大意：给你一个长度为n的01串，进行q次询问，每次询问给出一个区间[l,r]，表示原串中起点为l，终点为r的子串，你每次操作可以将子串中的某一位上的0变为1或者将1变为0，现在要你求出最少需要进行几次操作才能使操作后的子串不再是原串的子串。

题目思路：在现场做这题的时候，第一反应就觉得这个题是字符串hash的题，但由于字符串能力太鶸了，没能想出好的处理方法，赛后问全场唯一过的队伍，他们是用后缀自动机+dfs（~~后缀自动机完全不会，瞬间放弃了补题的念头，orz~~）。后来在回学校的路上和学长讨论了下，发现用字符串hash也是可以做的。

最主要就是将查询离线的话，可以大大优化复杂度，将q次查询按区间长度进行排序，如果有连续的查询是相同区间长度的话，那么就不用更新那么多次hash表了，这样就可以降低时间复杂度，在每次查询的时候，我们可以枚举修改的次数，然后用dfs来实现枚举，再与原hash表进行比对，当找到一个新的串不是原串的时候也就找到答案了。

时间复杂度的话应该是O（qn）（这个时间复杂度是学长说的，具体咋算我还是没咋搞懂，但均摊下来应该是差不多的）。

在这里安利一个STL里的黑科技unordered_map，这是在某一场牛客里一个dalao的代码里发现的，用这个来存hash值的话，查询的效率是map的两倍以上。（本题用map的运行时间是2148ms，用unordered_map的运行时间是1036ms，当然习惯手写hash表的dalao也可以选择性忽视这段，orz）

具体操作看代码吧，AC代码如下：

#include <map>
#include <cstdio>
#include <cstring>
#include <unordered_map>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const int maxn=1e4+5;
const ULL has=23333;

int n,m,ans[maxn];
char str[maxn];
ULL H[maxn],P[maxn];
struct node{
    int l,r,len,id;
    bool operator<(const node &node1)const{
        return len<node1.len;
    }
}q[maxn];
unordered_map<ULL,bool>check;
void Hash(){
    //预处理出原串的hash值，方便后面求各个子串的hash值；
    H[0]=P[0]=1;
    for(int i=1;i<=n;i++){
        H[i]=H[i-1]*has+str[i]-'0'+1;
        //这里记得加1，因为原串只有0,1，当str[i]=0时，如果直接用0去hash会使值不那么乱（hash还是要越乱越好嘛-，-）
        P[i]=P[i-1]*has;
    }
}
ULL get_hash(int l,int r){
    //求出[l,r]子串的hash值；
    return H[r]-H[l-1]*P[r-l+1];
}
void update(int len){
    //处理出原串中长度为len的子串的hash值
    check.clear();
    for(int i=1;i+len-1<=n;i++){
        check[get_hash(i,i+len-1)]=1;
    }
}
bool dfs(int L,int R,int cnt,ULL c){
    //L，R代表可变换的区间，cnt表示接下来还需要变换的字符个数，c代表当前串的hash值
    if(!cnt) return check[c];
    for(int i=L;i<=R;i++){
        int nw=str[i]-'0';
        ULL t=c-P[R-i]*(nw+1)+P[R-i]*(2-nw);
        if(!dfs(i+1,R,cnt-1,t)) return 0;
    }
    return 1;
}
int main(){
    while(~scanf("%d%d",&n,&m)){
        if(n==0&&m==0) break;
        scanf("%s",str+1);
        int len=strlen(str+1);
        Hash();
        for(int i=1;i<=m;i++){
            scanf("%d%d",&q[i].l,&q[i].r);
            q[i].len=q[i].r-q[i].l+1;
            q[i].id=i;
            ans[i]=-1;
        }
        sort(q+1,q+m+1);
        for(int i=1;i<=m;i++){
            if(q[i].len!=q[i-1].len) update(q[i].len);
            for(int l=1;l<=q[i].len;l++){
                if(!dfs(q[i].l,q[i].r,l,get_hash(q[i].l,q[i].r))){
                    //当找到第一个修改后的串不是原串的子串的时候就是答案了，直接弹出即可。
                    ans[q[i].id]=l;
                    break;
                }
            }
        }
        for(int i=1;i<=m;i++){
            if(ans[i]==-1)
                puts("Impossible");
            else
                printf("%d\n",ans[i]);
        }
    }
    return 0;
}