洛谷 P4198 楼房重建

最新推荐文章于 2021-08-24 16:31:20 发布

loceaner

最新推荐文章于 2021-08-24 16:31:20 发布

阅读量196

点赞数 1

分类专栏：洛谷

本文链接：https://blog.youkuaiyun.com/Loceaner/article/details/107898626

版权

洛谷专栏收录该内容

9 篇文章

订阅专栏

该博客介绍了如何解决洛谷P4198题目，即如何利用区间单调栈处理楼房重建问题。文章详细阐述了如何将原问题转化为求区间单调栈大小，并讨论了如何进行区间合并，特别是提出了`calc`函数的实现，用于计算合并后的单调栈大小。通过优化`calc`函数，实现了在O(Qlog2n)的时间复杂度内解决问题。

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

思路

此题可转化为以下模型

给定序列 $a [1 . . . n]$ ，支持单点修改，每次求区间单调栈大小

$n,Q\le 10^5$

区间单调栈是什么呢？对于一个区间，建立一个栈，首先将第一个元素入栈，从左往右扫，如果当前元素大于等于栈顶元素，就将其入栈，由此形成的栈即为单调不减的区间单调栈。

转化一下，其实就是求区间内满足 $a[i]=\max\limits_{j=1}^ia[j]$ 的 $a [i]$ 的个数。

一个自然的想法是维护单调栈的大小 $s i z$ ，那么如何去进行区间的合并呢？

合并两个子区间时，假设左子区间为 $L$ ，右子区间为 $R$ ，考虑合并之后的单调栈的组成部分：

第一部分： $L$ 的单调栈

因为单调栈是从左往右做的，所以 $L$ 的单调栈必然是大区间单调栈的一部分
剩余部分

设出函数 $c a l c (n o w, p r e)$ ， $n o w$ 表示当前节点， $p r e$ 表示当前单调栈的栈顶， $c a l c$ 函数计算剩余部分的单调栈的大小

总的单调栈大小 $s i z$ 就是 $L_{siz}+calc(R,L_{max})$

calc的实现

现在有 $c a l c (n o w, p r e)$ ， $l$ 表示 $n o w$ 的左子树， $r$ 表示 $n o w$ 的右子树

如果 $pre>l_{max}$ ，说明整个左子区间都不用考虑了，此时答案就变成了 $c a l c (r, p r e)$
如果 $pre\le l_{max}$ ，此时 $l$ 是有贡献的，他对 $s i z$ 的贡献就是 $c a l c (l, p r e)$ ，右子树的贡献为 $calc(r,l_{max})$ ，总贡献就是 $calc(l,pre)+calc(r,l_{max})$

至此 $c a l c$ 就推完了，但是我们发现如果仅仅是这样的话，在最坏的情况下，复杂度会爆炸，那么怎么优化呢？

观察 $calc(r,l_{max})$ ，发现它就等于 $siz-l_{siz}$ ，所以第二种情况就可以变成 $calc(l,pre)+siz-l_{siz}$ ，其中 $s i z$ 都是可以处理好的

这样我们就可以在 $O(\log n)$ 的时间里完成一次合并

总时间复杂度 $O(Q\log^2 n)$

代码

/*
Author:loceaner
*/
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define lson rt << 1
#define rson rt << 1 | 1
using namespace std;

const int A = 1e5 + 11;
const int B = 1e6 + 11;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;

inline int read() {
  char c = getchar();
  int x = 0, f = 1;
  for ( ; !isdigit(c); c = getchar()) if (c == '-') f = -1;
  for ( ; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
  return x * f;
}

double val;
int n, m, ans, pos;
struct node { double maxn; int siz; } a[A << 2];

void build(int rt, int l, int r) {
  if (l == r) return;
  int mid = (l + r) >> 1;
  build(lson, l, mid), build(rson, mid + 1, r);
}

inline int calc(int rt, int l, int r, double h) {
  if (l == r) return a[rt].maxn > h;
  int mid = (l + r) >> 1;
  if (a[lson].maxn <= h) return calc(rson, mid + 1, r, h);
  return calc(lson, l, mid, h) + a[rt].siz - a[lson].siz;
}

inline void update(int rt, int l, int r) {
  if (l == r) {
    a[rt].maxn = val, a[rt].siz = 1;
    return;
  }
  int mid = (l + r) >> 1;
  if (pos <= mid) update(lson, l, mid);
  else update(rson, mid + 1, r);
  a[rt].maxn = max(a[lson].maxn, a[rson].maxn);
  a[rt].siz = a[lson].siz + calc(rson, mid + 1, r, a[lson].maxn);
}

int main() {
  n = read(), m = read();
  build(1, 1, n);
  while (m--) {
    int x = read(), y = read();
    pos = x, val = (double) y / x;
    update(1, 1, n);
    cout << a[1].siz << '\n';
  }
}