P4587 [FJOI2016]神秘数 题解

思路

用到了一个比较神奇的方法，迭代法。

首先考虑对于暴力怎么做。

可以有一个非常显而易见的结论。

如果一个数比此时可以表示的最大的数加一要小。

那么就一定能表示这个数并且可以表示的最大的数变成此时最大的数加上这个数。

稍微想一想就可以发现这个结论是比较好像的。

由此，我们可以利用迭代的思路来优化这个算法。

迭代指的是多次运行算法，来不断逼近正确答案，常用于随机算法当中。

对于每一次迭代，我们直接从左到右扫。

考虑到此题累积答案的特性，可以发现，我们每统计一次答案，此时的答案对于上一次的答案必然会翻倍。

所以我们迭代的次数就为 \(O(log n)\) 级别的。

考虑将询问全部离线。

每一扫过去的时候，若某个询问的前一次答案为 \(\text{lastans}\)，此时答案为 \(\text{ans}\)。

那么若 \(\text{lastans}\) 等于 \(\text{ans}\) ，那么代表我们就不需要继续统计这一个询问的答案了，就将他给删掉。

至于每一次统计答案，就是左端点前面比 \(\text{lastans}\) 小的和右端点前面比 \(\text{lastans}\) 小的和之差。

具体实现可以考虑使用树状数组和链表来实现。

Code

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

const int N = 100010;

int n , m , a[N] , b[N] , del[N * 2] , vis[N] , head[N];
int top , t[N] , ans[N] , pre[N] , stk[N * 2] , ton[N][2];

struct List
{
    int pre , nxt;
}l[N * 2];

inline int read()
{
    int asd = 0 , qwe = 1; char zxc;
    while(!isdigit(zxc = getchar())) if(zxc == '-') qwe = -1;
    while(isdigit(zxc)) asd = asd * 10 + zxc - '0' , zxc = getchar();
    return asd * qwe;
}

inline void add(int x , int y)
{
    l[x].pre = head[y];
    l[head[y]].nxt = x;
    head[y] = x;
}

inline void delet(int x , int y)
{
    if(x == head[y]) head[y] = l[x].pre;
    l[l[x].pre].nxt = l[x].nxt;
    l[l[x].nxt].pre = l[x].pre;
}

inline int lowbit(int x)
{
    return x & (-x);
}

inline void update(int x)
{
    int sum = b[x];
    while(x <= n)
        t[x] += sum , x += lowbit(x);
}

inline int ask(int x)
{
    int res = 0;
    while(x) res += t[x] , x -= lowbit(x);
    return res;
}

signed main()
{
    n = read();
    for(int i = 1;i <= n;i++)
        a[i] = b[i] = read();
    m = read();
    sort(b + 1 , b + n + 1);
    int q = unique(b + 1 , b + n + 1) - b - 1;
    for(int i = 1;i <= n;i++)
        a[i] = lower_bound(b + 1 , b + q + 1 , a[i]) - b;
    for(int i = 1;i <= m;i++)
    {
        int l = read() , r = read();
        if(l > r) swap(l , r);
        add(i , l) , add(i + m , r);
        del[i] = l , del[i + m] = r;
        vis[i] = 1 , pre[i] = -1;
    }
    while(1)
    {
        bool flag = 0; top = 0;
        for(int i = 1;i <= n;i++)
            t[i] = 0;
        for(int i = 1;i <= n;i++)
        {
            for(int j = head[i];j;j = l[j].pre)
            {
                int kj = (j > m ? j - m : j);
                int x = ans[kj] + 1;
                int y = upper_bound(b + 1 , b + q + 1 , x) - b - 1;
                vis[kj] ^= 1;
                ton[kj][vis[kj]] = ask(y);
                if(vis[kj] == 1)
                {
                    if(a[i] <= y) ton[kj][1] += b[a[i]];
                    ans[kj] = ton[kj][1] - ton[kj][0];
                    if(ans[kj] != pre[kj]) pre[kj] = ans[kj] , flag = 1;
                    else  stk[++top] = kj + m , stk[++top] = kj;
                }
            }
            update(a[i]);
        }
        for(int i = 1;i <= top;i++)
            delet(stk[i] , del[stk[i]]);
        if(!flag) break;
    }
    for(int i = 1;i <= m;i++) cout << ans[i] + 1 << endl;
    return 0;
}