亚特兰蒂斯中的Push_Up分析

最新推荐文章于 2024-08-12 22:53:14 发布

IDSY QAQ

最新推荐文章于 2024-08-12 22:53:14 发布

阅读量356

点赞数

分类专栏：题目方法证明数据结构

本文链接：https://blog.csdn.net/C2022lihan/article/details/111084496

版权

题目方法证明同时被 2 个专栏收录

9 篇文章

订阅专栏

数据结构

8 篇文章

订阅专栏

本文深入剖析了一种区间覆盖算法，特别是其核心部分Push_Up函数的工作原理。通过递归更新树状结构中的区间覆盖计数和长度，实现了高效计算指定区域被覆盖的总长度。适用于解决涉及区间覆盖与查询的问题。

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

csdn

0.前言

由于笔者翻阅了较多 $b l o g$ ，其中都未分析 $P u s h U p$ 的使用原理，在经过笔者 $_很$ 长时间的思考后，想明白了 $T a$ 的使用原理，下面是我较为清晰的思路，虽笔者斟酌了 $_很$ 长时间，但由于能力问题，若有没讲清楚的地方，望不吝赐教或提出疑问， $d a l a o$ 轻喷

1.定义

当前节点为 $p$ ， $T a$ 的父节点为 $f a$

$l$ 表示矩阵的左上角的 $y$ 坐标集合

$r$ 表示矩阵的右下角的 $y$ 坐标集合

$t r [p] . c n t$ 表示 $l i < = t r [p] . l, t r [p] . r < = r i, t r [f a] . l < = l i 或者 t r [f a] . r > r i$ 时， $[t r [p] . l, t r [p] . r]$ 被覆盖的次数

$t r [p] . l e n$ 表示 $l i < = t r [p] . l, t r [p] . r < = r i, t r [f a] . l < = l i 或者 t r [f a] . r > r i$ 时， $[t r [p] . l, t r [p] . r]$ 被覆盖的大小

2.分析

先放出代码

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

template <typename T>
void read (T &x) {
	x = 0; T f = 1;
	char tem = getchar ();
	
	while (tem < '0' || tem > '9') {
		if (tem == '-') f = -1;
		tem = getchar ();
	}
	
	while (tem >= '0' && tem <= '9') {
		x = (x << 1) + (x << 3) + tem - '0';
		tem = getchar ();
	}
	
	x *= f;
}

template <typename T>
void write (T x) {
	if (x < 0) {
		x = -x;
		putchar ('-');
	}
	if (x > 9) write (x / 10);
	putchar (x % 10 + '0');
}

const int MAXN = 1e5 + 5;

int n;

double rev[MAXN * 2];

int cnt;
struct date {
    double x, y_1, y_2;
	int flag;
    date () {}
    date (double X, double Y_1, double Y_2, int FLAG) {
        x = X, y_1 = Y_1, y_2 = Y_2, flag = FLAG;
    }
}a[MAXN * 2];

struct Segment_Tree {
    int l, r, cnt;
    double len;
}tr[MAXN * 4];

void Push_Up (int p) {
    if (tr[p].cnt) {
        tr[p].len = rev[tr[p].r + 1] - rev[tr[p].l];
    }
    else {
        tr[p].len = tr[p << 1].len + tr[p << 1 | 1].len;
    }
}

void Build (int p, int l, int r) {
    tr[p].l = l;
    tr[p].r = r;
    if (l == r) {
        tr[p].cnt = tr[p].len = 0;
        return;
    }
    
    int mid = (l + r) >> 1;
    Build (p << 1, l, mid);
    Build (p << 1 | 1, mid + 1, r);
    tr[p].cnt = tr[p].len = 0;
}

void Update (int p, int l, int r, int x) {
    if (l <= tr[p].l && tr[p].r <= r) {
        tr[p].cnt += x;
        Push_Up (p);
        return;
    }
    int mid = (tr[p].l + tr[p].r) >> 1;
    if (l <= mid) 
        Update (p << 1, l, r, x);
    if (r > mid)
        Update (p << 1 | 1, l, r, x);
    Push_Up (p);
}

bool cmp (date x, date y) {
    return x.x < y.x;
}

int main () {
    int T = 0;
    while (1) {
        read (n);
        if (n == 0) break;
        Build (1, 1, n * 2);
        cnt = 0;
        for (int i = 1; i <= n; i++) {
            double x_1, y_1, x_2, y_2;
            scanf ("%lf %lf %lf %lf", &x_1, &y_1, &x_2, &y_2);
            a[++cnt] = date (x_1, y_1, y_2, 1);
            rev[cnt] = y_1;
            a[++cnt] = date (x_2, y_1, y_2, -1);
            rev[cnt] = y_2;
        }
        
        sort (rev + 1, rev + 1 + cnt);
        int len = unique (rev + 1, rev + 1 + cnt) - rev - 1;
        
        sort (a + 1, a + 1 + cnt, cmp);
        double ans = 0;
        for (int i = 1; i <= cnt; i++) {
            if (i > 1) {
                ans += tr[1].len * (a[i].x - a[i - 1].x);
            }
            int l = lower_bound (rev + 1, rev + 1 + len, a[i].y_1) - rev;
            int r = lower_bound (rev + 1, rev + 1 + len, a[i].y_2) - rev;
            Update (1, l, r - 1, a[i].flag);
        }
        printf ("Test case #%d\n", ++T);
        printf ("Total explored area: %.2lf\n\n", ans);
    }
    return 0;
}

由于Build，离散化等操作十分基础，我只谈谈Push_Up（也是我卡了很久的点）

1. $\neq 0$

十分简单，整个区间都被包含， $t r [p] . l e n = r e v [t r [p] . r + 1] - r e v [t r [p] . l];$

2. $t r [p] . c n t = 0$ （重点）

首先我们可以明确，所有的祖先节点都没有被完全覆盖，那么我们得到所有矩阵都没有完全覆盖 $[t r [p] . l, t r [p] . r]$ （否则在祖先节点是就已经 $r e t u r n$ 了），所以我们只需要考虑子孙节点对 $[t r [p] . l, t r [p] . r]$ 的影响，又由于所有矩阵都没有完全覆盖 $[t r [p] . l, t r [p] . r]$ ，所以 $p$ 节点的子节点只考虑Ta所代表的区间被完全覆盖，且父节点所代表的区间没有被完全覆盖的被覆盖的大小，我们可以发现，这就是 $t r [s o n] . l e n$