洛谷：传送方阵Mitrix（splay + 思维）

最新推荐文章于 2024-05-07 12:24:19 发布

junior19

最新推荐文章于 2024-05-07 12:24:19 发布

阅读量346

点赞数

分类专栏：平衡树

本文链接：https://blog.csdn.net/junior19/article/details/82598615

版权

平衡树专栏收录该内容

5 篇文章 0 订阅

订阅专栏

题目背景

在博弈和yhzq颓废的时候，dp正在机房认真的学习。

题目描述

他正在学习如何玩一个游戏《传送方阵Mitrix》，据说如果通关，就可以被传送进入虚拟世界。

游戏中，dp可以布置2n2n个传送方阵。这些方阵都是矩形。第ii个方阵的长宽分别是x_i,y_ixi,yi.

他需要把nn个传送方阵一起放在一个坐标系里。方阵可以相互重叠。方阵的四条边必须平行于坐标系的X，Y轴。这些方阵可以旋转90度后摆放。nn个方阵布置完后，这nn个方阵共同重叠（即某一个矩形属于所有的矩形）的区域，会生成一个MitrixMitrix。定义一个MitrixMitrix的传送效应为该矩形的面积。

每个传送门只能被使用一次，因此他需要两个传送门，不然就会迷失在虚拟空间里。因此，他希望布置2n2n个传送方阵，把他们分成AA组，BB组，使得这两组传送方阵构成的MitrixMitrix的传送效应的和最大。请你输出最大的传送效应和$Max\\{S_A+S_B\\}$。

输入输出格式

输入格式：

第一行一个整数nn

之后2n2n行，分别包含两个整数，表示x_i,y_ixi,yi

输出格式：

一个整数，表示$Max\\{S_A+S_B\\}$

输入输出样例

输入样例#1： 复制

输出样例#1： 复制

说明

对于20%的数据 n \leq 5n≤5

对于40%的数据 n \leq 150n≤150

对于60%的数据 n \leq 1000n≤1000

对于全部数据 n \leq 100000n≤100000

题意：给N*2个矩形，分成两组各N个然后重叠起来得到交面积，求两组的交面积的和的最大值（矩形可以旋转，但不可以斜着）。

思路：首先重叠的时候短边对短边长边对长边，然后怎么分呢？设X为短边，Y为长边，考虑按X升序排序，X最短的归为第一组，枚举第二组X最短的那个矩形K。于是K从N+1遍历到2，每次要做的就是将K到2*N里面分N个矩形去第二组，剩下的分到第一组。那么我们对K到2*N的矩形按照Y升序排序，如果最小的Y分在第二组，第二组的最终面积就固定了，那么干脆将前面的N个矩形都分在第二组，这样就使得第一组的Y最大化；同理如果最小的Y分在第一组，第一组的最终面积就固定了，干脆将后面的N个矩形都分在第二组，这样就使得第二组的Y最大化。讨论这两种情况就行，用splay维护区间第K大。

# include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn = 2e5+30;
int imin[maxn];
struct Node{
    int x, y;
    bool operator < (const Node& b){
        return x==b.x?y<b.y:x<b.x;
    }
}a[maxn];
struct node{
    int num, val, siz;
    node *fa, *son[2];
}*root;
node* newnode(int val, node* fa){//新建节点
    node* t = new node;
    t->num = t->siz = 1;
    t->val = val;
    t->fa = fa;
    t->son[0] = t->son[1] = NULL;
    return t;
}
int size(node* t){//返回子树大小
    return t==NULL?0:t->siz;
}
void update(node* t){//更新子树大小
    if(t != NULL){
        t->siz = t->num;
        t->siz += size(t->son[0]);
        t->siz += size(t->son[1]);
    }
}
bool son(node* f, node* s){//判断s是f的哪个儿子
    if(f == NULL) return 0;
    return f->son[1] == s;
}
void connect(node* f, node* s, bool k){//将s将到f的k儿子上
    if(f != NULL) f->son[k] = s;
    else root = s;
    if(s != NULL) s->fa = f;
}
void rotate(node* s){//将s转到它父亲的位置
    node* f = s->fa;
    node* g = f->fa;
    bool a = son(f, s), b = !a;
    connect(f, s->son[b], a);
    connect(g, s, son(g, f));
    connect(s, f, b);
    update(f);
    update(s);
}
void splay(node* s, node* p){//将s成p的儿子
    if(s == NULL) return;
    while(s->fa != p){
        node* f = s->fa;
        node* g = f->fa;
        if(g == p) rotate(s);
        else{
            if(son(g,f) ^ son(f,s)) rotate(f), rotate(s);
            else rotate(s), rotate(s);
        }
    }
}
node* find(int val){//查找某个数所在节点
    node* res = root;
    while(res != NULL && res->val != val)
        res = res->son[val>=res->val];
    return splay(res, NULL), res;//将res转到根节点
}
node* insert(node* t, int val){//插入一个新的数
    node* res = t->son[val>=t->val];
    if(res == NULL) res = t->son[val>=t->val] = newnode(val, t);
    else res = insert(res, val);
    return res;
}
void insert(int val){//插入一个数
    if(root == NULL) root = newnode(val, NULL);
    else if(find(val) != NULL) ++root->num, update(root);
    else splay(insert(root, val), NULL);
}
int qry(int th, node* t){//查询排在第th的是哪个数
    if(size(root) < th) return 0;
    if(th > size(t->son[0])) th -= size(t->son[0]);
    else return qry(th, t->son[0]);
    if(th <= t->num) return t->val;
    return qry(th-t->num, t->son[1]);
}
int main(){
    int n;
    scanf("%d",&n);
    for(int i=1; i<=2*n; ++i){
        scanf("%d%d",&a[i].x,&a[i].y);
        if(a[i].x > a[i].y) swap(a[i].x,a[i].y);
    }
    sort(a+1, a+1+2*n);
    imin[1] = a[1].y;
    for(int i=2; i<=n; ++i) imin[i] = min(imin[i-1], a[i].y);
    for(int i=n+1; i<=2*n; ++i) insert(a[i].y);
    LL ans = 1LL*a[1].x*imin[n] + 1LL*a[n+1].x*qry(1, root);
    for(int i=n, j=1; i>=2; --i,++j){
        insert(a[i].y);
        int t1 = qry(1, root);
        int t2 = qry(j+1, root);
        ans = max(ans, 1LL*a[1].x*min(imin[i-1], t1) + 1LL*a[i].x*t2);
        t2 = qry(n+1, root);
        ans = max(ans, 1LL*a[1].x*min(imin[i-1], t2) + 1LL*a[i].x*t1);
    }
    printf("%lld\n",ans);
    return 0;
}