AtCoder Beginner Contest 309 F补题

原创已于 2023-07-10 21:56:33 修改 · 261 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数据结构

于 2023-07-10 21:53:22 首次发布

文章提供了两种算法解法，分别是使用三关键字排序结合线段树的方法和采用三维偏序的经典操作，来解决给定一组箱子，判断是否存在某个箱子能被其他箱子完全装下的问题。代码实现中涉及到排序、区间查询和动态规划等技术。

传送门
题目大意，给定n个属性为 $a_i,b_i,c_i$ 的箱子，可以进行旋转，问是否存在某个箱子可以被其他箱子装进去。一个箱子 $i$ 可以被箱子 $j$ 装进去的条件是他们满足 $\left(a_i \lt a_j\right) \bigwedge \left(b_i \lt b_j\right) \bigwedge \left(c_i \lt c_j\right)$

解法1 三关键字排序+线段树

先按照三关键字排序， $a_i$ 大的优先， $a_i$ 相同按照 $b_i$ 大优先，最后按照 $c_i$ 从大到小排序,然后将w离散化，以w为建立线段树维护相同w可以得到的最大d,然后将h分层插入树，求比当前点w大的区域内的最大d，如果线段树中d大于当前点的，就说明存在更大的盒子。

#pragma GCC optimize(2)
#pragma GCC optimize(3)

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
#include <string>
#include <set>

using namespace std;

/* ------------------------------------------------------------------------------------- */

#define endl '\n'
#define x first
#define y second
#define ul u<<1
#define ur ul|1
#define sc(x) scanf("%d", &x)
#define scll(x) scanf("%lld", &x)
#define alls(x) x.begin(),x.end()
#define ralls(x) x.rbegin(),x.rend()

typedef long long LL;

const int N = 300010, M = 200010;

int n, m;
vector<int>nums;

int find(int x){
    return lower_bound(alls(nums), x) - nums.begin();
}

struct Node{
    int l,r;
    int val;
}tr[N << 2];

struct bi{
    int h,w,d;
    bool operator< (const bi & t){
        if(t.h != h)return h > t.h;
        if(t.w != w)return w > t.w;
        return d > t.d;
    }
    bool operator== (const bi & t){
        return t.h == h && w == t.w && d == t.d;
    }
}a[N];

void build(int u,int l,int r){
    tr[u] = {l, r};
    if(l == r){
        tr[u].val = 0;
        return;
    }
    int mid = (l + r) >> 1;
    build(ul,l,mid);
    build(ur,mid + 1,r);
    tr[u].val = max(tr[ul].val, tr[ur].val);
}

void update(int u,int x,int val){
    if(tr[u].l == tr[u].r){
        tr[u].val = max(tr[u].val, val);
    }
    else{
        int mid = (tr[u].l + tr[u].r) >> 1;
        if(x <= mid)update(ul, x, val);
        if(x > mid)update(ur, x, val);
        tr[u].val = max(tr[ul].val, tr[ur].val);
    }
}

int query(int u,int l,int r){
    if(tr[u].l > r || tr[u].r < l)return 0;
    else if(l <= tr[u].l && tr[u].r <= r)return tr[u].val;
    else{
        int mid = (tr[u].l + tr[u].r) >> 1;
        int res = 0;
        if(l <= mid)res = query(ul, l, r);
        if(r > mid)res = max(res, query(ur, l, r));
        return res;
    }
}

bool check(){
    sort(alls(nums));
    nums.erase(unique(alls(nums)), nums.end());//w数组离散化

    build(1,0,nums.size() - 1);

    int id = 1;
    for(int i = 1;i <= n;i ++){
        vector<bi>emm;
        while (a[i].h == a[id].h && i <= n){
            emm.push_back(a[i]);
            int x = find(a[i].w);
            if(query(1, x + 1, nums.size() - 1) > a[i].d)return true;
            i ++;
        }

        for(auto t : emm){//hi相同的，一起插入，他们之间是肯定不能装下互相的
            int x = t.w, y = t.d;
            x = find(x);
            update(1, x, y);
        }
        
        id = i;
        i --;
    }
    return false;
}

void solve() {
    cin >> n;
    for(int i = 1;i <= n;i ++){
        int w,d,h;
        cin >> h >> w >> d;
        if(h > w)swap(h,w);
        if(h > d)swap(h,d);
        if(w > d)swap(w,d);
        a[i] = {h,w,d};
        nums.push_back(w);
    }

    sort(a + 1,a + n + 1);

    bool ok = check();

    if(ok)cout << "Yes" << endl;
    else cout << "No" << endl;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int t = 1;
    //cin >> t;
    int t_case = 1;
    for (int i = 1; i <= t; i++) {
        /*printf("",t_case ++);*/
        solve();
    }

    return 0;
}

解法2 三维偏序

先按照三关键字排序， $a_i$ 大的优先， $a_i$ 相同按照 $b_i$ 大优先，最后按照 $c_i$ 从大到小排序,然后开始三维偏序的经典操作，分治，区间l到r分为三部分，第一部分是i,j都在l到mid的，第二部分是i,j都在mid+1到r的，第三部分则是i在l到mid,j在mid+1到r的，第一部分第二部分则是通过递归处理出来的，那么想办法解决第三部分就行了。
首先因为分治和归并排序的思想，令q[x]代表第x个元素，令i为l到mid的指针，j为mid+1到r的指针，因为最开始进行了三关键字排序，所以一定有q[i].h >= q[j].h,然而我们需要的是q[i].h>q[j].h，并且我们可以发现，只有mid+1到某个位置会和mid以及mid以前某些区域的h会一样，因此我们可以用两个变量d1,d2，一个记录h和右边相同时的最大d（也就是左边区间h最小的），另一个就是是无所谓h是否相同的最大d，因为只有右边j的h不等于左边的最小h时才会使用它。
解决了h的问题之后，在考虑怎么计算，因为我们分治的归并按照w从大到小排序，因此我们可以令a[i].w > a[j].w时，对于d1, d2分别更新,然后对于答案进行计算。

#pragma GCC optimize(2)
#pragma GCC optimize(3)

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
#include <cmath>
#include <map>

using namespace std;

/* ------------------------------------------------------------------------------------- */

#define endl '\n'
#define x first
#define y second
#define ul u<<1
#define ur ul|1
#define alls(x) x.begin(),x.end()
#define ralls(x) x.rbegin(),x.rend()

const int N = 300010, M = 200010;
typedef long long LL;

int n, m;
vector<int>nums;

int find(int x){
    return lower_bound(alls(nums), x) - nums.begin();
}

struct Node{
    int l,r;
    int val;
}tr[N << 2];

struct bi{
    int h,w,d;
    bool operator< (const bi & t){
        if(t.h != h)return h > t.h;
        if(t.w != w)return w > t.w;
        return d > t.d;
    }
    bool operator== (const bi & t){
        return t.h == h && w == t.w && d == t.d;
    }
}a[N],q[N];

void build(int u,int l,int r){//此处的线段树是维护区间最小值的
    tr[u] = {l, r};
    if(l == r){
        tr[u].val = a[l].h;
        return;
    }
    int mid = (l + r) >> 1;
    build(ul,l,mid);
    build(ur,mid + 1,r);
    tr[u].val = min(tr[ul].val, tr[ur].val);
}

int query(int u,int l,int r){
    if(tr[u].l > r || tr[u].r < l)return 1e9 + 7;
    else if(l <= tr[u].l && tr[u].r <= r)return tr[u].val;
    else{
        int mid = (tr[u].l + tr[u].r) >> 1;
        int res = 1e9 + 7;
        if(l <= mid)res = query(ul, l, r);
        if(r > mid)res = min(res, query(ur, l, r));
        return res;
    }
}

LL merge_sort(int l,int r){//每个区间排序前都保证了前面的h >= 后面，之后保证w >= 后面的w
    if (l >= r)return 0;
    int mid = (l + r) >> 1;
    int res = merge_sort(l, mid) + merge_sort(mid + 1, r);
    int minh = query(1,l,mid);
    int d1 = 0,d2 = 0;//h和l到mid中最小的不同，h无所谓相同与否

    int i = l,j = mid + 1,k = 0;
    while(i <= mid && j <= r){
        if(a[i].w > a[j].w){//d1,d2只有前面有大的w才会被更新
            d2 = max(d2, a[i].d);
            if(a[i].h != minh)d1 = max(d1, a[i].d);//h一定 > 右边全部
            q[k ++] = a[i ++];
        }
        else{//a[i].w == a[j].w
            if(a[j].h == minh)res += a[j].d < d1;
            else res += a[j].d < d2;
            q[k ++] = a[j ++];
        }
    }

    while(i <= mid)q[k ++] = a[i ++];
    while(j <= r){
        if(a[j].h == minh)res += a[j].d < d1;
        else res += a[j].d < d2;
        q[k ++] = a[j ++];
    }

    for(i = l,j = 0;i <= r;i ++,j ++)a[i] = q[j];

    return res;
}

bool check(){
    build(1,1,n);
    LL ok = merge_sort(1, n);
    if(ok)return true;
    return false;
}

void solve() {
    cin >> n;
    for(int i = 1;i <= n;i ++){
        int w,d,h;
        cin >> h >> w >> d;
        if(h > w)swap(h,w);
        if(h > d)swap(h,d);
        if(w > d)swap(w,d);
        a[i] = {h,w,d};
    }

    sort(a + 1,a + n + 1);

    bool ok = check();

    if(ok)cout << "Yes" << endl;
    else cout << "No" << endl;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int t = 1;
    //cin >> t;
    int t_case = 1;
    for (int i = 1; i <= t; i++) {
        /*printf("",t_case ++);*/
        solve();
    }

    return 0;
}