bzoj 4358 Permu - 莫队算法 - 链表

题目传送门

　　需要高级权限的传送门

题目大意

　　给定一个全排列，询问一个区间内的值域连续的一段的长度的最大值。

　　考虑使用莫队算法。

　　每次插入一个数$x$，对值域的影响可以分成4种情况：

• $x - 1$, $x + 1$都不存在。
• 只有$x - 1$存在，等价于在一段后面添加一个数
• 只有$x + 1$存在，等价于在一段前面添加一个数
• $x - 1$和$x + 1$都存在，等价于把两段拼起来

　　所以只有端点处的信息有用。我们考虑维护端点处的信息。

　　为了方便区分存在和不存在，我们维护开区间。

　　每个端点的$pre$指向这一段开头的前一个位置，每个端点的$suf$指向这一段结尾的后一个位置。

　　然后讨论一下就能更新了。

　　同时发现在保证顺序的情况下资瓷删除。（不能也没有关系）

　　然后让莫队回滚一下就做完了。时间复杂度$O(m\sqrt{n})$。

Code

 /**
  * bzoj
  * Problem#4358
  * Accepted
  * Time: 3600ms
  * Memory: 2664k
  */
 #include <bits/stdc++.h>
 using namespace std;
 typedef bool boolean;

 const int cs = ;

 typedef class Query {
     public:
         int l, r, id, res;

         boolean operator < (Query b) const {
             if ((l >> ) != (b.l >> ))
                 return (l >> ) < (b.l >> );
             return r < b.r;
         }
 }Query;

 int n, m;
 int *ar;
 int *suf, *pre;
 Query* qs;

 inline void init() {
     scanf("%d%d", &n, &m);
     ar = new int[(n + )];
     suf = new int[(n + )];
     pre = new int[(n + )];
     qs = new Query[(m + )];
     for (int i = ; i < n; i++)
         scanf("%d", ar + i);
     for (int i = ; i < m; i++) {
         scanf("%d%d", &qs[i].l, &qs[i].r);
         qs[i].l--, qs[i].r--, qs[i].id = i;
     }
 }

 boolean exist(int x) {
     return pre[x] != suf[x];
 }

 void insert(int x, int& res) {
     boolean sgnpre = exist(x - ), sgnsuf = exist(x + );
     if (!sgnpre && !sgnsuf) {
         pre[x] = x - ;
         suf[x] = x + ;
         res = max(res, );
     } else if (sgnpre && !sgnsuf) {
         int front = pre[x - ];
         pre[x] = front, suf[x] = x + ;
         suf[front + ] = x + ;
         res = max(res, x - front);
     } else if (sgnsuf && !sgnpre) {
         int rear = suf[x + ];
         pre[x] = x - , suf[x] = rear;
         pre[rear - ] = x - ;
         res = max(res, rear - x);
     } else {
         int front = pre[x - ], rear = suf[x + ];
         pre[x] = front, suf[x] = rear;
         suf[front + ] = rear, pre[rear - ] = front;
         res = max(res, rear - front - );
     }
 }

 void remove(int x) {
         boolean sgnpre = exist(x - ), sgnsuf = exist(x + );
     if (!sgnpre && !sgnsuf)
         pre[x] = suf[x] = x;
     else if (sgnpre && !sgnsuf) {
         int front = pre[x];
         pre[x] = suf[x] = suf[front + ] = x;
     } else if (sgnsuf && !sgnpre) {
         int rear = suf[x];
         pre[x] = suf[x] = pre[rear - ] = x;
     } else {
         int front = pre[x], rear = suf[x];
         pre[x] = suf[x] = x;
         suf[front + ] = pre[rear - ] = x;
     }
 }

 inline void solve() {
     sort(qs, qs + m);
     Query* q = qs, *ped = qs + m;
     for (int sid = ; q != ped; sid++) {
         int ed = cs * (sid + ), mdzzr = ed - ;
         for (int i = ; i <= n + ; i++)
             pre[i] = suf[i] = i;
         int cures = ;
         for ( ; q != ped && (q->l >> ) == sid; q++) {
             if ((q->r >> ) == sid) {
                 q->res = ;
                 for (int i = q->l; i <= q->r; i++)
                     insert(ar[i], q->res);
                 for (int i = q->r; i >= q->l; i--)
                     remove(ar[i]);
             } else {
                 while (mdzzr < q->r)
                     insert(ar[++mdzzr], cures);
                 int nres = cures;
                 for (int i = ed - ; i >= q->l; i--)
                     insert(ar[i], nres);
                 q->res = nres;
                 for (int i = q->l; i < ed; i++)
                     remove(ar[i]);
             }
         }
     }
     for (int i = ; i < m; i++)
         while (qs[i].id != i)
             swap(qs[i], qs[qs[i].id]);
     for (int i = ; i < m; i++)
         printf("%d\n", qs[i].res);
 }

 int main() {
     init();
     solve();
     return ;
 }