hdu 4429 Split the Rectangle(lca+二叉树)

最新推荐文章于 2019-08-11 22:07:59 发布

Timeclimber

最新推荐文章于 2019-08-11 22:07:59 发布

阅读量465

点赞数

CC 4.0 BY-SA版权

分类专栏： LCA 二叉树文章标签： hdu lca 二叉树

本文链接：https://blog.youkuaiyun.com/Timeclimber/article/details/78477513

LCA 同时被 2 个专栏收录

1 篇文章

订阅专栏

二叉树

1 篇文章

订阅专栏

本文介绍了一个基于矩形分割的游戏算法，玩家需要通过绘制线段来分割初始矩形，并解决如何通过删除部分线段使得两个指定点位于同一空白矩形内的同时，最大化剩余空白矩形数量的问题。

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

Split the Rectangle

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 699 Accepted Submission(s): 247

Problem Description

Alice comes up with a new game and wants to play with Bob.
There is one rectangle on the paper initially, we define its lower-left corner's coordinate is (x_L, y_L) and upper-right corner's coordinate is (x_R, y_R).
Bob has executed the step as description below N times:
Bob should select one empty rectangle. If the rectangle is the initial one or is split by one vertical segment, he should split it into two parts by drawing one horizontal segment; otherwise he should split the rectangle into two parts by drawing one vertical segment. An empty rectangle means there is no segment in this rectangle except its only four boundary segments.
You should pay attention that there are only two kinds segments: vertical segment and horizontal segment.
Now Bob has several queries. In each query, Bob selects two target points in the paper. (You can assume that all given target points are always located inside the initial rectangle and not in any drawing segments.) He wants Alice to answer the question as soon as possible: Alice can erase several existing segments, and make two target points in one empty rectangle, and she should answer how many empty rectangles at most would be left at last.
But there are some restrictions: Alice cannot erase segments of the initial rectangle (the (x_L, y_L) to (x_R, y_R) one), she can only erase segments drew by Bob; if Alice want to erase one segment, both sides of the segment must be empty rectangles, and after erase it, the two empty rectangles must combine to one bigger empty rectangle; if erasing an existing segment will lead to a disconnected graph, the operation is forbidden.

Input

There are multiple test cases.
The first line contains four integers x_L, y_L, x_R, y_R indicating the coordinates of the lower-left corner and the upper-right corner of the initial huge rectangle respectively. (-100,000 <= x_L, y_L, x_R, y_R <= 100,000, x_L< x_R, y_L< y_R)
The next line contains two integers N and Q. (1 <= N, Q <= 1000)
The next N lines each line contains four integers x₁, y₁, x₂, y₂ indicating the coordinates of two endpoints of one drawing segments. (-100,000 <= x₁, y₁, x₂, y₂ <= 100,000, x₁=x₂ | y₁=y₂)
The next Q lines each line contains four integers x_A, y_A, x_B, y_B indicating the coordinates of two target points in this query. (-100,000 <= x_A, y_A, x_B, y_B <= 100,000).

Output

For each test case, output Q lines, output the answer of each query in each line.

Sample Input

-10 -10 10 10
5 1
-10 0 10 0  
5 -10 5 0
-5 0 -5 10
-5 5 10 5
5 -5 10 -5
0 -3 7 -3
0 0 4 4
3 2
0 2 4 2
2 0 2 2
2 2 2 4
1 1 1 3
1 1 3 1
-10 -10 10 10
3 4
-10 0 10 0
0 -10 0 0
0 0 0 10
-9 -9 -8 -8
-9 -9 -9 9
-9 -9 9 -9
-9 -9 9 9

Sample Output

题意：

给定一个矩形，并给出n条线段，每个线段会将空白的矩形划分成两块。现给出两个点，问通过删除线段的方法能让两个点在同一块空白矩形的时候最多能剩多少个空白矩形？

思路：

每次线段划分矩形的时候都会划分成左右两块矩形。于是可以将这个二维的图建成一棵树。保存线段划分成左右子图的状态。在询问时，寻找他们的最近公共祖先。然后答案就是num[0]-num[pos]+1。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
const int maxn=2005;
int num[maxn];//表示子图的数量
struct rec
{
    int lx,ly,rx,ry;
    int fath,lson,rson,dep;
}q[maxn];
int find(int x,int y)
{
    int r=0,t;
    while(1)
    {
        if(q[r].lson==0) return r;
        t=q[r].lson;
        if(x>=q[t].lx&&x<=q[t].rx&&y>=q[t].ly&&y<=q[t].ry)
            r=t;
        else
            r=q[r].rson;
    }
}
int get_num(int u)
{
    num[u]=0;
    if(q[u].lson==0) return num[u]=1;
    else
    {
        num[u]+=get_num(q[u].lson);
        num[u]+=get_num(q[u].rson);
    }
    return num[u];
}
int lca(int lx,int ly,int rx,int ry)
{
    int a=find(lx,ly);
    int b=find(rx,ry);
    while(a!=b)
    {
        if(q[a].dep<q[b].dep)
            b=q[b].fath;
        else if(q[a].dep>q[b].dep)
            a=q[a].fath;
        else
        {
            a=q[a].fath;
            b=q[b].fath;
        }
    }
    return a;
}
int main()
{
    int lx,ly,rx,ry,n,w,now;
    while(~scanf("%d%d%d%d",&lx,&ly,&rx,&ry))
    {
        now=0;
        q[now++]=(rec){lx,ly,rx,ry,-1,0,0,0};
        scanf("%d%d",&n,&w);
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d%d%d",&lx,&ly,&rx,&ry);
            if(lx>rx) swap(lx,rx);
            if(ly>ry) swap(ly,ry);
            int mx=(lx+rx)/2,my=(ly+ry)/2;
            int pos=find(mx,my);
            int dep=q[pos].dep;
            q[pos].lson=now;
            q[now]=(rec){q[pos].lx,q[pos].ly,rx,ry,pos,0,0,dep+1};
            now++;
            q[pos].rson=now;
            q[now]=(rec){lx,ly,q[pos].rx,q[pos].ry,pos,0,0,dep+1};
            now++;
        }
        get_num(0);
        for(int i=1;i<=w;i++)
        {
            scanf("%d%d%d%d",&lx,&ly,&rx,&ry);
            int pos=lca(lx,ly,rx,ry);
            printf("%d\n",num[0]-num[pos]+1);
        }
    }
    return 0;
}