[DP][bitset][线段树]练习赛53 A C E

A

超越学姐爱字符串

A： 超越学姐非常喜欢自己的名字，以至于英文字母她只喜欢“c”和“y”。因此超越学姐喜欢只含有“c”和“y”的字符串，且字符串中不能出现两个连续的“c”。请你求出有多少种长度为n的字符串是超越学姐喜欢的字符串。答案对1e9+7取模。

解题思路：设dp[MAXN][2] 代表第i个位置是c 或 y的情况数

有dp[1][0] = dp[1][1] = 1 则每个位置的y可以由上一个y c转移而来，而c只能从上一个y转移而来 取模即可

/*
    Zeolim - An AC a day keeps the bug away
*/
   
const int MAXN = 4e5 + 10;
ll dp[MAXN][2] = {0};
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    //freopen("d:out.txt","w",stdout);
    //freopen("d:in.txt","r",stdin);
     
    dp[1][1] = 1;
    dp[1][0] = 1;
     
    for(int i = 2; i <= 110000; ++i)
    {
        dp[i][0] += dp[i - 1][0];
        dp[i][0] += dp[i - 1][1];
        dp[i][0] %= MOD;
        dp[i][1] += dp[i - 1][0];
        dp[i][1] %= MOD;
    }
     
    int n;
     
    cin >> n;
     
    ll ans = (dp[n][0] + dp[n][1]) % MOD;

    cout << ans << '
';
         
    return 0;
}

---

 

C

富豪凯匹配串

有n个长度为m的文本串，每个串只含有'0'和'1'。接下来有Q次询问，每次给出一个长度为m的字符串，且只含有'0','1'和'_'。如10_1_1。下划线可以匹配'0'或'1'。即10_1_1可以匹配101111,101101,100111,100101四种串。每次询问求出n个文本串中有多少个可以与当前询问的串匹配。

解题思路 ： 暴力匹配

用bitset 把总复杂度优化为 1000 * 1000 * 3000 / 64 大概5e7

对于每个模式串

首先把模式串的1全扣出来赋值为1 设为s

用s和匹配串或操作 如果结果等于s 则这两个串的1位都对上了

再把匹配串的0全扣出来 和匹配串或操作， 如果或出1 那就有0没对上

/*
    Zeolim - An AC a day keeps the bug away
*/

const int MAXN = 1010;
 
bitset <MAXN> arr[1010], ept;
 
int main()
{
    int n, m;
    char x;
    cin >> n >> m;
     
    for(int i = 0; i < n; ++i)
    {
        for(int j = 0; j < m; ++j)
        {
            cin >> x;
            arr[i][j] = x == '1';  
        }
    }
     
    int q;
    cin >> q;
     
    while(q--)
    {
        bitset <MAXN> st, rb, rc, rd;
         
        for(int i = 0; i < m; ++i)
        {
            cin >> x;
            st[i] = x == '1';
            rc[i] = x == '0';
        }
         
        int ans = 0;
         
        for(int i = 0; i < n; ++i)
        {
            rb = st & arr[i];
            rd = rc & arr[i];
            if(rb != st || rd.count()) //1没匹配上 或 0没匹配上
                continue;
            ++ans;
        }
        cout << ans << '
';
    }
     
    return 0;
}

---

E	老瞎眼 pk 小鲜肉

老瞎眼有一个长度为 n 的数组 a,为了为难小鲜肉，他准备了 Q 次询问，每次给出 一个区间[L,R],他让小鲜肉寻 找一对 l,r 使L<=l<=r<=R 且 a[l]^a[l+1]^a[l+2]...^a[r]=0,老瞎眼只让他回答r-l+1 最小是多少，若没有符合条件的 l,r 输出”-1”。 

解题思路：

考虑将询问排序，维护一颗线段树代表更新到a[i]时的1-i的每个位置上的答案的状态 相似于hh的项链 这样就可以卡两个边界查询

对于每次更新 记录 前缀异或和 pre[i] 到上一个pre[i] 的距离为c 并将c更新在上一个pre[i]上

这样对于结束点为i的询问只要查询 x y区间极小值即为答案 总复杂度O(n*log(n))

/*
    Zeolim - An AC a day keeps the bug away
*/
    
//#pragma GCC optimize(2)
//#pragma GCC ("-W1,--stack=128000000")
#include <bits/stdc++.h>
using namespace std;
#define mp(x, y) make_pair(x, y)
#define fr(x, y, z) for(int x = y; x < z; ++x)
#define pb(x) push_back(x)
#define mem(x, y) memset(x, y, sizeof(x))
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef std::pair <int, int> pii;
typedef std::vector <int> vi;
//typedef __int128 ill;
const ld PI = acos(-1.0);
const ld E = exp(1.0);
const ll INF = 0x3f3f3f3f;
const ll MOD = 1e9 + 7;
const int MAXN = 2e6 + 10;
  
int pre[MAXN] = {0};
int arr[MAXN] = {0};
int MP[MAXN] = {0};
int used[MAXN] = {0};
  
struct node
{
    int fst, lst, id;
    bool operator < (const node &b) const
    { return lst < b.lst; }
}qst[MAXN];
  
int val[MAXN];
  
int ans[MAXN] = {0};
  
struct rnode {int l, r, val;}t[MAXN << 2];
void build(int now, int l, int r)
{
    t[now].l = l, t[now].r = r;
    if(l == r) { t[now].val = INF; return ; }
    int mid = (l + r) >> 1;
    build(now * 2, l, mid);
    build(now * 2 + 1, mid + 1, r);
    t[now].val = min(t[now * 2].val, t[now * 2 + 1].val);
}
void upd(int now, int p, int val)
{
    if(t[now].l == t[now].r)
    {
        t[now].val = val;
        return ;
    }
    int mid = (t[now].l + t[now].r) >> 1;
    if(p <= mid) upd(now * 2, p, val);
    else upd(now * 2 + 1, p, val);
    t[now].val = min(t[now * 2].val, t[now * 2 + 1].val);
}
int rt = INF;
void ask(int now, int p)
{
    if(t[now].l == t[now].r)
    {
        rt = min(rt, t[now].val);
        return ;
    }
    int mid = (t[now].l + t[now].r) >> 1;
    if(p <= mid)
    {
        rt = min(rt, t[now * 2 + 1].val);
        ask(now * 2, p);
    }
    else
        ask(now * 2 + 1, p);
}
  
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    //freopen("1.txt", "r", stdin);
  
    int n, q;
      
    cin >> n >> q;
      
    for(int i = 1; i <= n; ++i)
    {
        cin >> arr[i];
        pre[i] = arr[i] ^ pre[i - 1];
    }
  
    for(int i = 0; i < q; ++i)
    {
        cin >> qst[i].fst >> qst[i].lst;
        qst[i].id = i;
    }
      
    sort(qst, qst + q);
          
    build(1, 0, n);
      
    fill(MP, MP + MAXN, -1);
      
    int pq = 0;
      
    MP[0] = 0;
      
    for(int i = 1; i <= n && pq < q; ++i)
    {
        if(arr[i] = 0)
        {
            upd(1, i, 1);
            used[i] = 1;
        }
          
        if(MP[pre[i]] != -1)
        {
            if(used[MP[pre[i]]])
                continue;
            int c = i - MP[pre[i]];
            upd(1, MP[pre[i]], c);
        }
          
        while(qst[pq].lst == i && pq < q)
        {
            rt = INF;
            ask(1, qst[pq].fst - 1);
            ans[qst[pq].id] = rt;
            ++pq;
        }
        MP[pre[i]] = i;
    }
      
    for(int i = 0; i < q; ++i)
        ans[i] == INF ? cout << "-1
" : cout << ans[i] << '
';
      
    return 0;
}