ペンギンの巣

diss_quack and Array Game (CF 2246 D)

Sat, 18 Jul 2026 00:00:00 GMT

Problem Summary

You are given an array $a$ of length $n$ with $0 \leq a_i \leq 10^5$. Before the game starts, Alice may increment any single element any number of times, each increment counted as one step. Then Alice and Bob alternate turns, with Bob moving first. On Bob's turn he picks two positions and swaps them (possibly the same position). On Alice's turn: if $a_1$ is even, she picks the largest $j$ such that $a_i \bmod 2 = 0$ for all $i \leq j$, then divides every $a_i$ ($i \le j$) by $2$ — this counts as one step; otherwise she decreases $a_1$ by $1$, again one step. When any value becomes zero it is removed from the array. Bob wants to maximise Alice's total number of steps, Alice wants to minimise it. Output the minimum number of steps Alice performs.

Approach

First consider the version without the pre-game +1 operations. If there is any odd number, Alice cannot perform the global halving move, so the answer is $\sum_{i=1}^{n} \bigl(\text{popcnt}(a_i) + \lfloor \log_2 a_i \rfloor + 1 - 1\bigr) = \sum_{i=1}^{n} \text{popcnt}(a_i) + |a_i| - 1$, where $|a_i|$ denotes the bit-length of $a_i$. If every number is even, Alice can keep halving globally until some value becomes odd, and after that the cost above still applies.

This suggests fixing the number of global halvings we perform as $j$, then computing the minimum number of +1 operations required to make every $a_i$ a multiple of $2^j$. A naive choice is $\text{step} = 2^j - (a_i \bmod 2^j)$, but that isn't always optimal — sometimes a few extra +1s can eliminate more $1$-bits from the binary representation. So we need to search a small window around $a_i$.

How wide should the window be? Notice that $\text{popcnt}(a_i) + |a_i| - 1$ is bounded by $17 + 17 - 1 = 33$ for $a_i \le 10^5$. That means increasing $a_i$ by more than $33$ is never worthwhile — the extra +1s would already exceed the entire remaining cost. So for every element we only need to try the $33$ values immediately above $a_i$, keep those divisible by $2^j$, and pick the minimum. Total complexity: $O(n \log^2)$.

Code

#include<bits/stdc++.h>
using namespace std;

#define endl '\n'
#define fi first
#define se second
#define ll long long
#define lowbit(x) (x&(-x))
const int mod=998244353;
const double eps=1e-12;
const int inf=0x3f3f3f3f;
const ll INF=0x3f3f3f3f3f3f3f3f;
#define popcnt __builtin_popcount
int dcmp(double x){if(fabs(x)<eps)return 0;return x>0?1:-1;}

#define int ll

// mt19937 rnd(random_device{}());
// uniform_int_distribution<int>dist(0,1000000);

int a[100005];
int b[100005];
int jie[21];

int len(int x)
{
    int cnt=0;
    while(x)
    {
        cnt++;
        x>>=1;
    }
    return cnt;
}

void solve()
{
    int n;
    cin>>n;
    int ans=inf;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
    }
    for(int j=0;j<=20;j++)
    {
        int res=j;
        for(int i=1;i<=n;i++)
        {
            int tmp=inf;
            for(int k=a[i];k<=a[i]+33;k++)
            {
                if(k%jie[j]==0)
                {
                    b[i]=k/jie[j];
                    tmp=min(tmp,k-a[i]+popcnt(b[i])+len(b[i])-1);
                }
            }
            b[i]=a[i]+jie[j]-a[i]%jie[j];
            tmp=min(tmp,b[i]-a[i]+popcnt(b[i]/jie[j])+len(b[i]/jie[j])-1);
            res+=tmp;
        }
        ans=min(ans,res);
    }
    cout<<ans<<'\n';
}

/*
 110
1000
  10
 100
   1
*/

#undef int

int main()
{
    ios::sync_with_stdio(false);cin.tie(nullptr);
    // cout<<fixed<<setprecision(10);

    jie[0]=1;
    for(int i=1;i<=20;i++)
    {
        jie[i]=jie[i-1]*2;
    }

    int _;cin>>_;while(_--)
    {
        solve();
    }
    return 0;
}

diss_quack and Array Game (CF 2246 D)

Sat, 18 Jul 2026 00:00:00 GMT

Codeforces Round 1108 (Div. 2) D

题目大意

有一串长度为 $n$ 的数列 $a\ (0\leq a_i\leq 10^5)$，Alice 在游戏前可以对任意一个位置上的数进行任意次的操作，每操作一次记为一步。游戏开始后 Alice 和 Bob 轮流操作，Bob 先手：选择两个位置并交换（可以选同一个位置）。Alice 后手：若 $a_1$ 为偶数，则选择最大的 $j$，使得 $a_i\pmod 2=0,\forall i\leq j$，并将 $a_i:=a_i/2,\forall i\le j$，记为一步；否则，将 $a_1:=a_1-1$，记为一步。如果有数变为零，则将该数从数组中移除。Bob 想让 Alice 的步数越多越好，Alice 想让自己的步数越少越好，问 Alice 最少步数是多少。

思路

先考虑没有 +1 操作的情形，若当前有奇数，则 Alice 无法进行 /2 的操作，因此答案为 $\sum_{i=1}^npopcnt(a_i)+|a_i|-1$。若当前没有偶数，则 Alice 可以一直进行全体 /2 的操作，一直到出现奇数，接下来所需要的操作数同上。因此，我们可以钦定需要做几次全体 /2 操作为 $j$，则需要计算将 $a_i$ 加成 $2^j$ 的倍数所需要的步数。一个想当然的做法是 $step=2^j-(a_i \pmod {2^j})$，这个当然没问题，但不一定是最优的，有时候多进行几次 +1 的操作可以使二进制里少去更多的 $1$，所以我们还需要遍历一个范围，而这个范围怎么求呢？我们再来看 $popcnt(a_i)+|a_i|-1$ 这个式子，对于每一个位置的最多操作数也就是 $17+17-1=33$。所以对于上述情况，我们只需要额外遍历 $33$ 个数，找到其中的 $2^j$ 的倍数，并在里面求最小步数即可，复杂度为 $O(n\log^2)$。

代码

#include<bits/stdc++.h>
using namespace std;

#define endl '\n'
#define fi first
#define se second
#define ll long long
#define lowbit(x) (x&(-x))
const int mod=998244353;
const double eps=1e-12;
const int inf=0x3f3f3f3f;
const ll INF=0x3f3f3f3f3f3f3f3f;
#define popcnt __builtin_popcount
int dcmp(double x){if(fabs(x)<eps)return 0;return x>0?1:-1;}

#define int ll

// mt19937 rnd(random_device{}());
// uniform_int_distribution<int>dist(0,1000000);

int a[100005];
int b[100005];
int jie[21];

int len(int x)
{
    int cnt=0;
    while(x)
    {
        cnt++;
        x>>=1;
    }
    return cnt;
}

void solve()
{
    int n;
    cin>>n;
    int ans=inf;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
    }
    for(int j=0;j<=20;j++)
    {
        int res=j;
        for(int i=1;i<=n;i++)
        {
            int tmp=inf;
            for(int k=a[i];k<=a[i]+33;k++)
            {
                if(k%jie[j]==0)
                {
                    b[i]=k/jie[j];
                    tmp=min(tmp,k-a[i]+popcnt(b[i])+len(b[i])-1);
                }
            }
            b[i]=a[i]+jie[j]-a[i]%jie[j];
            tmp=min(tmp,b[i]-a[i]+popcnt(b[i]/jie[j])+len(b[i]/jie[j])-1);
            res+=tmp;
        }
        ans=min(ans,res);
    }
    cout<<ans<<'\n';
}

/*
 110
1000
  10
 100
   1
*/

#undef int

int main()
{
    ios::sync_with_stdio(false);cin.tie(nullptr);
    // cout<<fixed<<setprecision(10);

    jie[0]=1;
    for(int i=1;i<=20;i++)
    {
        jie[i]=jie[i-1]*2;
    }

    int _;cin>>_;while(_--)
    {
        solve();
    }
    return 0;
}

Interval (2020 Nowcoder Multi-School #5)

Thu, 04 May 2023 00:00:00 GMT

Problem link

Problem

You are given an array $A$ of length $N$ with $0 \le A_i < 2^{30}$ and $1 \le N \le 10^5$.

Define $F(l, r) := A_l ,&, A_{l+1} ,&, \cdots ,&, A_r$ (bitwise AND over the range).

Define $S(l, r) := {, F(a, b) \mid \min(l, r) \le a \le b \le \max(l, r) ,}$.

There are $Q$ queries with $1 \le Q \le 10^5$. For each query $(L, R)$ with $1 \le L, R \le N$, output $|S(L, R)|$ — the number of distinct values that appear as an AND of any subarray inside $[L, R]$. Queries are forced-online.

Approach

Fix the right endpoint and slide the left endpoint leftward. Because a bitwise AND only ever loses bits, $F(l, r)$ takes at most $O(\log V)$ distinct values, and each transition can be found via binary search on a segment tree that supports range AND.

Since queries are online, we need every historical state, so we maintain a persistent segment tree: version $i$'s tree records, at position $j$, whether $F(j, i)$ contributes to the answer. Deduplication uses a classic trick — for each value only keep the latest position that produces it, deleting the previous occurrence. This ensures each distinct AND value is counted exactly once.

The problem then reduces to: point update, range sum query on the persistent segment tree.

Code

#include<bits/stdc++.h>
using namespace std;

#define ll long long
#define fi first
#define se second
const double eps=1e-12;
const int inf=0x3f3f3f3f;
const ll INF=0x3f3f3f3f3f3f3f3f;
const double pi=acos(-1.0);
int dcmp(double x){if(fabs(x)<eps)return 0;return x>0?1:-1;}

#define int ll

struct president_segment_tree
{
    int cnt=0;
    int root[100005];
    struct node
    {
        int l,r,sum;
    }z[100005*600];
    int clone(int x)
    {
        cnt++;z[cnt]=z[x];
        return cnt;
    }
    void update(int id1,int &id2,int l,int r,int x,int w)
    {
        id2=clone(id1);
        z[id2].sum+=w;
        if(l==r)return;
        else
        {
            int mid=(l+r)>>1;
            if(x<=mid)update(z[id1].l,z[id2].l,l,mid,x,w);
            else update(z[id1].r,z[id2].r,mid+1,r,x,w);
        }
    }
    int query(int id,int l,int r,int x,int y)
    {
        if(x<=l&&r<=y)return z[id].sum;
        else
        {
            int mid=(l+r)>>1;
            int ans=0;
            if(x<=mid)ans+=query(z[id].l,l,mid,x,y);
            if(mid<y)ans+=query(z[id].r,mid+1,r,x,y);
            return ans;
        }
    }
}pst;
int a[100005];
struct segment_tree
{
    int tree[100005<<2];
    void build(int p,int l,int r)
    {
        if(l==r)tree[p]=a[l];
        else
        {
            int mid=(l+r)>>1;
            build(p<<1,l,mid);
            build(p<<1|1,mid+1,r);
            tree[p]=tree[p<<1]&tree[p<<1|1];
        }
    }
    int query(int p,int l,int r,int x,int y)
    {
        if(x<=l&&r<=y)return tree[p];
        else
        {
            int mid=(l+r)>>1;
            int ans=(1<<30)-1;
            if(x<=mid)ans&=query(p<<1,l,mid,x,y);
            if(mid<y)ans&=query(p<<1|1,mid+1,r,x,y);
            return ans;
        }
    }
}st;
map<int,int>last;

void solve()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)cin>>a[i];
    st.build(1,1,n);
    for(int i=1;i<=n;i++)
    {
        pst.root[i]=pst.root[i-1];
        if(last.count(a[i]))
            pst.update(pst.root[i],pst.root[i],1,n,last[a[i]],-1);
        last[a[i]]=i;
        pst.update(pst.root[i],pst.root[i],1,n,last[a[i]],1);
        int cur=a[i];
        while(true)
        {
            int l=0,r=i,res=0;
            while(l<r)
            {
                int mid=(l+r+1)>>1;
                int now=st.query(1,1,n,mid,i);
                if(now<cur)l=mid,res=mid;
                else r=mid-1;
            }
            if(!res)break;
            cur=st.query(1,1,n,res,i);
            if(last.count(cur))
                pst.update(pst.root[i],pst.root[i],1,n,last[cur],-1);
            last[cur]=res;
            pst.update(pst.root[i],pst.root[i],1,n,last[cur],1);
        }
    }
    int q;
    cin>>q;
    int lastans=0;
    while(q--)
    {
        int l,r;
        cin>>l>>r;
        l=(l^lastans)%n+1;
        r=(r^lastans)%n+1;
        if(l>r)swap(l,r);
        cout<<(lastans=pst.query(pst.root[r],1,n,l,n))<<'\n';
    }
}

#undef int

int main()
{
    ios::sync_with_stdio(false);cin.tie(nullptr);
    {
        solve();
    }
    return 0;
}

Interval（20年牛客多校5）

Thu, 04 May 2023 00:00:00 GMT

传送门

题意

有一个数列 $A(0\leqslant A_i\lt2^{30})$ 长度为 $N(1\leqslant N\leqslant10^5)$，

$F(l,r):=A_l&A_{l+1}&\cdots&A_r$，

$S(l,r):=\left{F(a,b)|\min(l,r)\leqslant a\leqslant b\leqslant\max(l,r)\right}$，

有 $Q(1\leqslant Q\leqslant10^5)$ 组询问，对于给定的 $L,R(1\leqslant L',R'\leqslant N)$，求 $S(L,R)$ 的大小，强制在线。

思路

考虑到固定一个右端点，左端点向左拓展的时候，$F(l,r)$ 的个数不会很多，最多只有 $\log$ 个，于是我们就可以用二分预处理出所有的值。由于需要保留上一个版本的答案，所以我们需要拿一颗主席树来维护，第 $i$ 个版本的线段树中第 $j$ 个位置记录的是 $F(j,i)$ 是否对答案有贡献，这样就涉及了去重的这个问题。一个常见的技巧是对于一个值，只记录离第 $i$ 个位置最近的那个位置，并将之前的位置删去，这样就可以保证一个值只被算一次了，所以这道题就被转换成了主席树上单点修改，区间查询。

代码

#include<bits/stdc++.h>
using namespace std;

#define ll long long
#define fi first
#define se second
const double eps=1e-12;
const int inf=0x3f3f3f3f;
const ll INF=0x3f3f3f3f3f3f3f3f;
const double pi=acos(-1.0);
int dcmp(double x){if(fabs(x)<eps)return 0;return x>0?1:-1;}

#define int ll

struct president_segment_tree
{
    int cnt=0;
    int root[100005];
    struct node
    {
        int l,r,sum;
    }z[100005*600];
    int clone(int x)
    {
        cnt++;z[cnt]=z[x];
        return cnt;
    }
    void update(int id1,int &id2,int l,int r,int x,int w)
    {
        id2=clone(id1);
        z[id2].sum+=w;
        if(l==r)return;
        else
        {
            int mid=(l+r)>>1;
            if(x<=mid)update(z[id1].l,z[id2].l,l,mid,x,w);
            else update(z[id1].r,z[id2].r,mid+1,r,x,w);
        }
    }
    int query(int id,int l,int r,int x,int y)
    {
        if(x<=l&&r<=y)return z[id].sum;
        else
        {
            int mid=(l+r)>>1;
            int ans=0;
            if(x<=mid)ans+=query(z[id].l,l,mid,x,y);
            if(mid<y)ans+=query(z[id].r,mid+1,r,x,y);
            return ans;
        }
    }
}pst;
int a[100005];
struct segment_tree
{
    int tree[100005<<2];
    void build(int p,int l,int r)
    {
        if(l==r)tree[p]=a[l];
        else
        {
            int mid=(l+r)>>1;
            build(p<<1,l,mid);
            build(p<<1|1,mid+1,r);
            tree[p]=tree[p<<1]&tree[p<<1|1];
        }
    }
    int query(int p,int l,int r,int x,int y)
    {
        if(x<=l&&r<=y)return tree[p];
        else
        {
            int mid=(l+r)>>1;
            int ans=(1<<30)-1;
            if(x<=mid)ans&=query(p<<1,l,mid,x,y);
            if(mid<y)ans&=query(p<<1|1,mid+1,r,x,y);
            return ans;
        }
    }
}st;
map<int,int>last;

void solve()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)cin>>a[i];
    st.build(1,1,n);
    for(int i=1;i<=n;i++)
    {
        pst.root[i]=pst.root[i-1];
        if(last.count(a[i]))
            pst.update(pst.root[i],pst.root[i],1,n,last[a[i]],-1);
        last[a[i]]=i;
        pst.update(pst.root[i],pst.root[i],1,n,last[a[i]],1);
        int cur=a[i];
        while(true)
        {
            int l=0,r=i,res=0;
            while(l<r)
            {
                int mid=(l+r+1)>>1;
                int now=st.query(1,1,n,mid,i);
                if(now<cur)l=mid,res=mid;
                else r=mid-1;
            }
            if(!res)break;
            cur=st.query(1,1,n,res,i);
            if(last.count(cur))
                pst.update(pst.root[i],pst.root[i],1,n,last[cur],-1);
            last[cur]=res;
            pst.update(pst.root[i],pst.root[i],1,n,last[cur],1);
        }
    }
    int q;
    cin>>q;
    int lastans=0;
    while(q--)
    {
        int l,r;
        cin>>l>>r;
        l=(l^lastans)%n+1;
        r=(r^lastans)%n+1;
        if(l>r)swap(l,r);
        cout<<(lastans=pst.query(pst.root[r],1,n,l,n))<<'\n';
    }
}

#undef int

int main()
{
    ios::sync_with_stdio(false);cin.tie(nullptr);
    {
        solve();
    }
    return 0;
}

Classic Problems on Suffix Arrays

Tue, 23 Aug 2022 00:00:00 GMT

It's been a while since I last wrote a post. I recently spent some time on suffix arrays and learned a lot, so I wanted to write this up as a keepsake. Credit where it's due — the template used below is YZH's SAIS implementation, and the section titles and example problems come from Luo Suiqian's 2009 IOI national team paper. Respect.

Problems on a Single String

Longest Non-Overlapping Repeated Substring

Sort all suffixes, then binary-search the answer. For a candidate length $l$, group the sorted suffixes so that every group has lcp(height) at least $l$. Within each group, track the maximum and minimum of rl(sa); if their difference exceeds $l$, a non-overlapping repeated substring of length $l$ exists. This is $O(n \log n)$. You can also do it in $O(n)$ by using two pointers together with a monotonic deque to maintain the max/min of rl(sa); the answer is the largest lcp(height) seen across valid groups.

ペンギンの巣

diss_quack and Array Game (CF 2246 D)

Problem Summary

Approach

Code

diss_quack and Array Game (CF 2246 D)

题目大意

思路

代码

Interval (2020 Nowcoder Multi-School #5)

Problem

Approach

Code

Interval（20年牛客多校5）

题意

思路

代码

Classic Problems on Suffix Arrays

Problems on a Single String

Longest Non-Overlapping Repeated Substring

Longest Repeated Substring Occurring at Least $k$ Times (Overlapping Allowed)

Number of Distinct Substrings

Longest Palindromic Substring

Continuous Repetition Detection

Substring with Maximum Number of Continuous Repetitions

Problems on Two Strings

Longest Common Substring

Count of Common Substrings of Length at Least $k$

Problems on Multiple Strings

Longest Substring Appearing in at Least $k$ Strings

Longest Substring Appearing at Least Twice Non-Overlapping in Every String

Longest Substring Appearing (or Reverse-Appearing) in Every String

后缀数组基础题套路赏析

单个字符串的相关问题

不可重叠最长重复子串

可重叠的k次最长重复子串

子串的个数

最长回文子串

连续重复子串

重复次数最多的连续重复子串

两个字符串的相关问题

最长公共子串

长度不小于k的公共子串的个数

多个字符串的相关问题

出现在不小于k个字符串中的最长子串

在每个串中都至少出现两次且不重叠的最长子串

出现或反转后出现在每个字符串中的最长子串

Cards (ABC 247 F)

Problem Summary

Approach

Code

Cards (ABC 247 F)

题目大意

思路

代码

810975 (2021 CCPC Weihai M)

Problem Summary

Approach

Code

810975 (2021 CCPC 威海 M)

题目大意

思路

代码