oj.uz

답안 #216804

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
216804 2020-03-28T05:16:10 Z combi1k1 청소 (JOI20_sweeping) C++14
11 / 100
 18000 ms 169620 KB 
//this solution is referred from comment of 300iq:
//https://codeforces.com/blog/entry/74871?#comment-590823
#include<bits/stdc++.h>

using namespace std;

#define ll  long long
#define ld  double

#define sz(x)   (int)x.size()
#define all(x)  x.begin(),x.end()

#define pb  emplace_back
#define X   first
#define Y   second

const int   N   = 15e5 + 5;

typedef pair<int,int>   ii;
typedef pair<int,ii>    pii;

struct Node {
    Node *l, *r;
    Node *par;
    ii  key;
    int pri;
    int lzX, lzY;

    Node(int x = 0,int y = 0) : l(0), r(0), par(0), key(ii(x,y)), pri(rand() << 16 ^ rand()), lzX(-1), lzY(-1)  {}
}  *p[N];

void app(Node *x,int a,int b)   {
    if (a >= 0) (x -> key).X = x -> lzX = a;
    if (b >= 0) (x -> key).Y = x -> lzY = b;
}
void pull(Node *x)  {
    if (x -> l) x -> l -> par = x;
    if (x -> r) x -> r -> par = x;
}
void push(Node *x)  {
    if (x -> l) app(x -> l,x -> lzX,x -> lzY);
    if (x -> r) app(x -> r,x -> lzX,x -> lzY);

    x -> lzX = -1;
    x -> lzY = -1;
}
Node *join(Node *x,Node *y) {
    if (!x) return  y;
    if (!y) return  x;

    if (x -> pri > y -> pri)    {
        push(x);    x -> r = join(x -> r,y);
        pull(x);    return  x;
    }
    else    {
        push(y);    y -> l = join(x,y -> l);
        pull(y);    return  y;
    }
}
void split(Node *x,Node*&l,Node*&r,ii  v)   {
    if (!x) {
        l = r = 0;
        return;
    }
    push(x);

    if (v.X < (x -> key).X) {   split(x -> l,l,x -> l,v);   pull(r = x);    return; }
    if (v.Y < (x -> key).Y) {   split(x -> l,l,x -> l,v);   pull(r = x);    return; }

    split(x -> r,x -> r,r,v);
    pull(l = x);
}
Node* unite(Node*&a,Node *b)    {
    if (!a) return  b;
    if (!b) return  a;

    if (a -> pri < b -> pri)
        swap(a,b);

    Node *l;
    Node *r;

    split(b,l,r,a -> key);

    push(a);

    a -> l = unite(a -> l,l);
    a -> r = unite(a -> r,r);

    pull(a);    return  a;
}

struct Group    {
    Node *Rt;
    int x, y;
};
bool operator < (const Group&a,const Group&b)   {
    ii  tmp1(-a.y,a.Rt -> pri);
    ii  tmp2(-b.y,b.Rt -> pri);

    return  tmp1 < tmp2;
}

priority_queue<Group>   pq[N];

int tr[N << 2];

#define lch     i << 1
#define rch     i << 1 | 1

void upd(int i,int l,int r,int p)   {
    if (l > p)  return;
    if (r < p)  return;
    if (l == r) {
        if (pq[l].size())   tr[i] = pq[l].top().y;
        else                tr[i] = 1e9 + 7;
        return;
    }
    int m = (l + r) / 2;

    upd(lch,l,m,p); ++m;
    upd(rch,m,r,p);

    tr[i] = min(tr[lch],tr[rch]);
}

int main()  {
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);

    srand(time(NULL));

    int n;  cin >> n;
    int m;  cin >> m;
    int q;  cin >> q;

    vector<pii> Que;
    vector<int> val;

    for(int i = 0 ; i < m ; ++i)    {
        int x;  cin >> x;
        int y;  cin >> y;

        Que.pb(4,ii(x,y));
        val.pb(x);
    }
    for(int i = 0 ; i < q ; ++i)    {
        int t;  cin >> t;
        int x;  cin >> x;
        int y = n - x;

        if (t == 4) cin >> y;
        if (t == 2) swap(x,y);

        Que.pb(t,ii(x,y));

        if (t != 1)
            val.pb(x);
    }
    sort(all(val));
    val.erase(unique(all(val)),val.end());

    auto add = [&](Node *R) {
        if(!R)  return;
        Group G;
        G.Rt = R;

        while (R -> l)
            push(R),
            R = R -> l;

        G.x = (R -> key).X;
        G.y = (R -> key).Y;

        int p = upper_bound(all(val),G.x) - val.begin();

        pq[p].push(G);

        if (pq[p].top().y == G.y)
            upd(1,1,sz(val),p);
    };

    fill(tr + 1,tr + 4 * sz(val),1e9 + 7);
    int tot = 0;

    for(pii T : Que)    {
        int t = T.X;
        int x = T.Y.X;
        int y = T.Y.Y;

        if (t == 1) {
            vector<Node*> Path;

            for(Node* a = p[x] ; a -> par ; Path.pb(a = a -> par)); reverse(all(Path));
            for(Node* a : Path) push(a);

            cout << (p[x] -> key).X << " ";
            cout << (p[x] -> key).Y << "\n";
            continue;
        }
        if (t == 4) {
            add(p[++tot] = new Node(x,y));
            continue;
        }
        Node *Rt = 0;

        while (tr[1] <= y)  {
            int i = 1;
            int l = 1;
            int r = sz(val);

            while (l < r)   {
                int m = (l + r) / 2;

                if (tr[lch] <= y)   i = lch, r = m;
                else                i = rch, l = m + 1;
            }
            if (val[l - 1] > x)
                break;

            while (pq[l].size())    {
                if(pq[l].top().y > y)
                    break;

                Group G = pq[l].top();  pq[l].pop();

                Node *a;
                Node *b;

                split(G.Rt,a,b,ii(x,y));    add(b);

                if (a)  a -> par = 0;
                if (b)  b -> par = 0;

                if (t == 2) app(a,x,-1);
                if (t == 3) app(a,-1,y);

                Rt = unite(Rt,a);
            }
            upd(1,1,sz(val),l);
        }
        add(Rt);
    }
}

Compilation message

sweeping.cpp: In function 'int main()':
sweeping.cpp:194:13: warning: this 'for' clause does not guard... [-Wmisleading-indentation]
             for(Node* a = p[x] ; a -> par ; Path.pb(a = a -> par)); reverse(all(Path));
             ^~~
sweeping.cpp:194:69: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'for'
             for(Node* a = p[x] ; a -> par ; Path.pb(a = a -> par)); reverse(all(Path));
                                                                     ^~~~~~~

Subtask #1
1.0 / 1.0

# 결과 실행 시간 메모리 Grader output
1 Correct 39 ms 47872 KB Output is correct
2 Correct 37 ms 47616 KB Output is correct
3 Correct 35 ms 47992 KB Output is correct
4 Correct 39 ms 47864 KB Output is correct
5 Correct 40 ms 47872 KB Output is correct
6 Correct 154 ms 47736 KB Output is correct

Subtask #2
10.0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Correct 2942 ms 166684 KB Output is correct
2 Correct 2886 ms 169284 KB Output is correct
3 Correct 2909 ms 169620 KB Output is correct
4 Correct 1997 ms 163820 KB Output is correct
5 Correct 3514 ms 168940 KB Output is correct
6 Correct 3325 ms 164932 KB Output is correct
7 Correct 2924 ms 167084 KB Output is correct

Subtask #3
0 / 11.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1959 ms 148004 KB Output is correct
2 Correct 1858 ms 146924 KB Output is correct
3 Correct 1231 ms 148992 KB Output is correct
4 Execution timed out 18013 ms 148960 KB Time limit exceeded
5 Halted 0 ms 0 KB -

Subtask #4
0 / 53.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1959 ms 148004 KB Output is correct
2 Correct 1858 ms 146924 KB Output is correct
3 Correct 1231 ms 148992 KB Output is correct
4 Execution timed out 18013 ms 148960 KB Time limit exceeded
5 Halted 0 ms 0 KB -

Subtask #5
0 / 25.0

# 결과 실행 시간 메모리 Grader output
1 Correct 39 ms 47872 KB Output is correct
2 Correct 37 ms 47616 KB Output is correct
3 Correct 35 ms 47992 KB Output is correct
4 Correct 39 ms 47864 KB Output is correct
5 Correct 40 ms 47872 KB Output is correct
6 Correct 154 ms 47736 KB Output is correct
7 Correct 2942 ms 166684 KB Output is correct
8 Correct 2886 ms 169284 KB Output is correct
9 Correct 2909 ms 169620 KB Output is correct
10 Correct 1997 ms 163820 KB Output is correct
11 Correct 3514 ms 168940 KB Output is correct
12 Correct 3325 ms 164932 KB Output is correct
13 Correct 2924 ms 167084 KB Output is correct
14 Correct 1959 ms 148004 KB Output is correct
15 Correct 1858 ms 146924 KB Output is correct
16 Correct 1231 ms 148992 KB Output is correct
17 Execution timed out 18013 ms 148960 KB Time limit exceeded
18 Halted 0 ms 0 KB -