oj.uz

답안 #159486

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
159486 2019-10-23T00:44:47 Z arnold518 새 집 (APIO18_new_home) C++14
5 / 100
 5000 ms 547848 KB 
#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

const int MAXN = 3e5;
const int MAXVAL = 1e8;

struct Query
{
    int t, x, k, p;
    bool operator < (const Query &p)
    {
        if(t!=p.t) return t<p.t;
        return k>p.k;
    }
};

int N, K, Q, ans[MAXN+10], SZ, chk;
vector<Query> query;
multiset<int> S[MAXN+10];
set<int> scomp;
vector<int> comp;

int getcomp(int x)
{
    //for(auto it : comp) printf("%d ", it); printf("-> %d\n", x);
    assert(binary_search(comp.begin(), comp.end(), x));
    return lower_bound(comp.begin(), comp.end(), x)-comp.begin();
}

priority_queue<int, vector<int>, less<int>> tree1[5*MAXN+10];
priority_queue<int, vector<int>, less<int>> dead1[5*MAXN+10];

priority_queue<int, vector<int>, greater<int>> tree2[5*MAXN+10];
priority_queue<int, vector<int>, greater<int>> dead2[5*MAXN+10];

ll query1(int x)
{
    int y=x;
    x=getcomp(x);
    int ret=0;
    for(; x>0; x-=(x&-x))
    {
        while(!tree1[x].empty() && !dead1[x].empty() && tree1[x].top()==dead1[x].top()) tree1[x].pop(), dead1[x].pop();
        if(!tree1[x].empty())
        {
            ////printf("QUERY1 %d %d\n", x, tree1[x].top()-y);
            ret=max(ret, tree1[x].top()-y);
        }
    }
    return ret;
}

void erase1(int x, int y)
{
    ////printf("ERASE1 %d %d\n", x, y);
    x=getcomp(x);
    for(; x<=SZ; x+=(x&-x))
    {
        dead1[x].push(y);
    }
}

void insert1(int x, int y)
{
    //printf("INSERT1 %d %d\n", x, y);
    x=getcomp(x);
    for(; x<=SZ; x+=(x&-x))
    {
        tree1[x].push(y);
    }
}

ll query2(int x)
{
    int y=x;
    x=getcomp(x);
    x=SZ-x+1;
    int ret=0;
    for(; x>0; x-=(x&-x))
    {
        while(!tree2[x].empty() && !dead2[x].empty() && tree2[x].top()==dead2[x].top()) tree2[x].pop(), dead2[x].pop();
        if(!tree2[x].empty())
        {
            ////printf("QUERY1 %d %d\n", x, y-tree2[x].top());
            ret=max(ret, y-tree2[x].top());
        }
    }
    return ret;
}

void erase2(int x, int y)
{
    swap(x, y);
    ////printf("ERASE2 %d %d\n", x, y);
    x=getcomp(x);
    x=SZ-x+1;
    for(; x<=SZ; x+=(x&-x))
    {
        dead2[x].push(y);
    }
}

void insert2(int x, int y)
{
    //printf("INSERT2 %d %d\n", x, y);
    swap(x, y);
    x=getcomp(x);
    x=SZ-x+1;
    for(; x<=SZ; x+=(x&-x))
    {
        tree2[x].push(y);
    }
}

int main()
{
    int i, j;

    scanf("%d%d%d", &N, &K, &Q);
    for(i=1; i<=N; i++)
    {
        int x, t, a, b;
        scanf("%d%d%d%d", &x, &t, &a, &b); b++; x*=2;
        query.push_back({a, x, t, 1});
        query.push_back({b, x, t, -1});
        scomp.insert(x);
    }
    for(i=1; i<=Q; i++)
    {
        int l, x;
        scanf("%d%d", &x, &l); x*=2;
        query.push_back({l, x, -i, 0});
        scomp.insert(x);
    }
    sort(query.begin(), query.end());

    scomp.insert(0); scomp.insert(2e8);
    for(auto now : query)
    {
        int x=now.x;
        if(now.p==1)
        {
            if(S[now.k].find(x)==S[now.k].end())
            {
                if(S[now.k].size()!=0)
                {
                    auto it=S[now.k].lower_bound(x);
                    int r=*it, l=*prev(it);
                    if(it==S[now.k].end()) scomp.insert(l+x>>1);
                    else if(it==S[now.k].begin()) scomp.insert(r+x>>1);
                    else
                    {
                        scomp.insert(l+x>>1);
                        scomp.insert(r+x>>1);
                    }
                }
            }
            S[now.k].insert(x);
        }
        else if(now.p==-1)
        {
            S[now.k].erase(x);
            if(S[now.k].find(x)==S[now.k].end())
            {
                if(S[now.k].size()!=0)
                {
                    auto it=S[now.k].lower_bound(x);
                    int r=*it, l=*prev(it);
                    if(it==S[now.k].end());
                    else if(it==S[now.k].begin());
                    else scomp.insert(l+r>>1);
                }
            }
        }
    }

    comp.push_back(-1);
    for(auto it : scomp) comp.push_back(it);
    SZ=comp.size()-1;

    for(i=1; i<=K; i++) S[i].clear();

    for(auto now : query)
    {
        //printf("===============\n");
        int x=now.x;
        if(now.p==0)
        {
            if(chk!=K) ans[-now.k]=-1;
            else ans[-now.k]=max(query1(x), query2(x))>>1;
            //printf("!%d %d %d\n", -now.k, query1(x), query2(x));
        }
        else if(now.p==1)
        {
            if(S[now.k].find(now.x)==S[now.k].end())
            {
                if(S[now.k].size()==0)
                {
                    insert1(0, x);
                    insert2(x, 2e8);
                    chk++;
                }
                else
                {
                    auto it=S[now.k].lower_bound(x);
                    int r=*it, l=*prev(it);
                    if(it==S[now.k].end())
                    {
                        erase2(l, 2e8);
                        insert2(l, l+x>>1);
                        insert1(l+x>>1, x);
                        insert2(x, 2e8);
                    }
                    else if(it==S[now.k].begin())
                    {
                        erase1(0, r);
                        insert1(0, x);
                        insert2(x, r+x>>1);
                        insert1(r+x>>1, r);
                    }
                    else
                    {
                        erase2(l, l+r>>1);
                        erase1(l+r>>1, r);
                        insert2(l, l+x>>1);
                        insert1(l+x>>1, x);
                        insert2(x, x+r>>1);
                        insert1(x+r>>1, r);
                    }
                }
            }
            S[now.k].insert(now.x);
        }
        else if(now.p==-1)
        {
            S[now.k].erase(S[now.k].find(now.x));
            if(S[now.k].find(now.x)==S[now.k].end())
            {
                if(S[now.k].size()==0)
                {
                    erase1(0, x);
                    erase2(x, 2e8);
                    chk--;
                }
                else
                {
                    auto it=S[now.k].lower_bound(x);
                    int r=*it, l=*prev(it);
                    if(it==S[now.k].end())
                    {
                        insert2(l, 2e8);
                        erase2(l, l+x>>1);
                        erase1(l+x>>1, x);
                        erase2(x, 2e8);
                    }
                    else if(it==S[now.k].begin())
                    {
                        insert1(0, r);
                        erase1(0, x);
                        erase2(x, r+x>>1);
                        erase1(r+x>>1, r);
                    }
                    else
                    {
                        insert2(l, l+r>>1);
                        insert1(l+r>>1, r);
                        erase2(l, l+x>>1);
                        erase1(l+x>>1, x);
                        erase2(x, x+r>>1);
                        erase1(x+r>>1, r);
                    }
                }
            }
        }
    }
    for(i=1; i<=Q; i++) printf("%d\n", ans[i]);
}

Compilation message

new_home.cpp: In function 'int main()':
new_home.cpp:153:58: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                     if(it==S[now.k].end()) scomp.insert(l+x>>1);
                                                         ~^~
new_home.cpp:154:65: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                     else if(it==S[now.k].begin()) scomp.insert(r+x>>1);
                                                                ~^~
new_home.cpp:157:39: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         scomp.insert(l+x>>1);
                                      ~^~
new_home.cpp:158:39: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         scomp.insert(r+x>>1);
                                      ~^~
new_home.cpp:175:40: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                     else scomp.insert(l+r>>1);
                                       ~^~
new_home.cpp:214:37: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         insert2(l, l+x>>1);
                                    ~^~
new_home.cpp:215:34: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         insert1(l+x>>1, x);
                                 ~^~
new_home.cpp:222:37: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         insert2(x, r+x>>1);
                                    ~^~
new_home.cpp:223:34: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         insert1(r+x>>1, r);
                                 ~^~
new_home.cpp:227:36: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         erase2(l, l+r>>1);
                                   ~^~
new_home.cpp:228:33: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         erase1(l+r>>1, r);
                                ~^~
new_home.cpp:229:37: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         insert2(l, l+x>>1);
                                    ~^~
new_home.cpp:230:34: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         insert1(l+x>>1, x);
                                 ~^~
new_home.cpp:231:37: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         insert2(x, x+r>>1);
                                    ~^~
new_home.cpp:232:34: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         insert1(x+r>>1, r);
                                 ~^~
new_home.cpp:256:36: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         erase2(l, l+x>>1);
                                   ~^~
new_home.cpp:257:33: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         erase1(l+x>>1, x);
                                ~^~
new_home.cpp:264:36: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         erase2(x, r+x>>1);
                                   ~^~
new_home.cpp:265:33: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         erase1(r+x>>1, r);
                                ~^~
new_home.cpp:269:37: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         insert2(l, l+r>>1);
                                    ~^~
new_home.cpp:270:34: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         insert1(l+r>>1, r);
                                 ~^~
new_home.cpp:271:36: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         erase2(l, l+x>>1);
                                   ~^~
new_home.cpp:272:33: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         erase1(l+x>>1, x);
                                ~^~
new_home.cpp:273:36: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         erase2(x, x+r>>1);
                                   ~^~
new_home.cpp:274:33: warning: suggest parentheses around '+' inside '>>' [-Wparentheses]
                         erase1(x+r>>1, r);
                                ~^~
new_home.cpp:121:12: warning: unused variable 'j' [-Wunused-variable]
     int i, j;
            ^
new_home.cpp:123:10: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
     scanf("%d%d%d", &N, &K, &Q);
     ~~~~~^~~~~~~~~~~~~~~~~~~~~~
new_home.cpp:127:14: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
         scanf("%d%d%d%d", &x, &t, &a, &b); b++; x*=2;
         ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
new_home.cpp:135:14: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
         scanf("%d%d", &x, &l); x*=2;
         ~~~~~^~~~~~~~~~~~~~~~

Subtask #1
5.0 / 5.0

# 결과 실행 시간 메모리 Grader output
1 Correct 181 ms 202232 KB Output is correct
2 Correct 182 ms 202308 KB Output is correct
3 Correct 181 ms 202232 KB Output is correct
4 Correct 180 ms 202272 KB Output is correct
5 Correct 182 ms 202276 KB Output is correct
6 Correct 187 ms 202640 KB Output is correct
7 Correct 184 ms 202420 KB Output is correct
8 Correct 183 ms 202624 KB Output is correct
9 Correct 185 ms 202464 KB Output is correct
10 Correct 188 ms 202748 KB Output is correct
11 Correct 187 ms 202744 KB Output is correct
12 Correct 186 ms 202700 KB Output is correct
13 Correct 186 ms 202488 KB Output is correct
14 Correct 183 ms 202488 KB Output is correct
15 Correct 185 ms 202488 KB Output is correct
16 Correct 185 ms 202580 KB Output is correct
17 Correct 189 ms 202644 KB Output is correct
18 Correct 211 ms 202488 KB Output is correct
19 Correct 185 ms 202488 KB Output is correct
20 Correct 186 ms 202616 KB Output is correct
21 Correct 182 ms 202348 KB Output is correct
22 Correct 183 ms 202480 KB Output is correct
23 Correct 182 ms 202436 KB Output is correct
24 Correct 184 ms 202496 KB Output is correct
25 Correct 188 ms 202664 KB Output is correct
26 Correct 186 ms 202472 KB Output is correct
27 Correct 185 ms 202500 KB Output is correct
28 Correct 185 ms 202488 KB Output is correct
29 Correct 186 ms 202604 KB Output is correct
30 Correct 184 ms 202424 KB Output is correct

Subtask #2
0 / 7.0

# 결과 실행 시간 메모리 Grader output
1 Correct 181 ms 202232 KB Output is correct
2 Correct 182 ms 202308 KB Output is correct
3 Correct 181 ms 202232 KB Output is correct
4 Correct 180 ms 202272 KB Output is correct
5 Correct 182 ms 202276 KB Output is correct
6 Correct 187 ms 202640 KB Output is correct
7 Correct 184 ms 202420 KB Output is correct
8 Correct 183 ms 202624 KB Output is correct
9 Correct 185 ms 202464 KB Output is correct
10 Correct 188 ms 202748 KB Output is correct
11 Correct 187 ms 202744 KB Output is correct
12 Correct 186 ms 202700 KB Output is correct
13 Correct 186 ms 202488 KB Output is correct
14 Correct 183 ms 202488 KB Output is correct
15 Correct 185 ms 202488 KB Output is correct
16 Correct 185 ms 202580 KB Output is correct
17 Correct 189 ms 202644 KB Output is correct
18 Correct 211 ms 202488 KB Output is correct
19 Correct 185 ms 202488 KB Output is correct
20 Correct 186 ms 202616 KB Output is correct
21 Correct 182 ms 202348 KB Output is correct
22 Correct 183 ms 202480 KB Output is correct
23 Correct 182 ms 202436 KB Output is correct
24 Correct 184 ms 202496 KB Output is correct
25 Correct 188 ms 202664 KB Output is correct
26 Correct 186 ms 202472 KB Output is correct
27 Correct 185 ms 202500 KB Output is correct
28 Correct 185 ms 202488 KB Output is correct
29 Correct 186 ms 202604 KB Output is correct
30 Correct 184 ms 202424 KB Output is correct
31 Correct 1878 ms 272872 KB Output is correct
32 Correct 289 ms 206676 KB Output is correct
33 Correct 1872 ms 273904 KB Output is correct
34 Correct 1865 ms 271028 KB Output is correct
35 Correct 1897 ms 274212 KB Output is correct
36 Correct 1861 ms 276100 KB Output is correct
37 Runtime error 1626 ms 547848 KB Execution killed with signal 11 (could be triggered by violating memory limits)
38 Halted 0 ms 0 KB -

Subtask #3
0 / 10.0

# 결과 실행 시간 메모리 Grader output
1 Execution timed out 5055 ms 451520 KB Time limit exceeded
2 Halted 0 ms 0 KB -

Subtask #4
0 / 23.0

# 결과 실행 시간 메모리 Grader output
1 Execution timed out 5051 ms 439460 KB Time limit exceeded
2 Halted 0 ms 0 KB -

Subtask #5
0 / 35.0

# 결과 실행 시간 메모리 Grader output
1 Correct 181 ms 202232 KB Output is correct
2 Correct 182 ms 202308 KB Output is correct
3 Correct 181 ms 202232 KB Output is correct
4 Correct 180 ms 202272 KB Output is correct
5 Correct 182 ms 202276 KB Output is correct
6 Correct 187 ms 202640 KB Output is correct
7 Correct 184 ms 202420 KB Output is correct
8 Correct 183 ms 202624 KB Output is correct
9 Correct 185 ms 202464 KB Output is correct
10 Correct 188 ms 202748 KB Output is correct
11 Correct 187 ms 202744 KB Output is correct
12 Correct 186 ms 202700 KB Output is correct
13 Correct 186 ms 202488 KB Output is correct
14 Correct 183 ms 202488 KB Output is correct
15 Correct 185 ms 202488 KB Output is correct
16 Correct 185 ms 202580 KB Output is correct
17 Correct 189 ms 202644 KB Output is correct
18 Correct 211 ms 202488 KB Output is correct
19 Correct 185 ms 202488 KB Output is correct
20 Correct 186 ms 202616 KB Output is correct
21 Correct 182 ms 202348 KB Output is correct
22 Correct 183 ms 202480 KB Output is correct
23 Correct 182 ms 202436 KB Output is correct
24 Correct 184 ms 202496 KB Output is correct
25 Correct 188 ms 202664 KB Output is correct
26 Correct 186 ms 202472 KB Output is correct
27 Correct 185 ms 202500 KB Output is correct
28 Correct 185 ms 202488 KB Output is correct
29 Correct 186 ms 202604 KB Output is correct
30 Correct 184 ms 202424 KB Output is correct
31 Correct 1878 ms 272872 KB Output is correct
32 Correct 289 ms 206676 KB Output is correct
33 Correct 1872 ms 273904 KB Output is correct
34 Correct 1865 ms 271028 KB Output is correct
35 Correct 1897 ms 274212 KB Output is correct
36 Correct 1861 ms 276100 KB Output is correct
37 Runtime error 1626 ms 547848 KB Execution killed with signal 11 (could be triggered by violating memory limits)
38 Halted 0 ms 0 KB -

Subtask #6
0 / 20.0

# 결과 실행 시간 메모리 Grader output
1 Correct 181 ms 202232 KB Output is correct
2 Correct 182 ms 202308 KB Output is correct
3 Correct 181 ms 202232 KB Output is correct
4 Correct 180 ms 202272 KB Output is correct
5 Correct 182 ms 202276 KB Output is correct
6 Correct 187 ms 202640 KB Output is correct
7 Correct 184 ms 202420 KB Output is correct
8 Correct 183 ms 202624 KB Output is correct
9 Correct 185 ms 202464 KB Output is correct
10 Correct 188 ms 202748 KB Output is correct
11 Correct 187 ms 202744 KB Output is correct
12 Correct 186 ms 202700 KB Output is correct
13 Correct 186 ms 202488 KB Output is correct
14 Correct 183 ms 202488 KB Output is correct
15 Correct 185 ms 202488 KB Output is correct
16 Correct 185 ms 202580 KB Output is correct
17 Correct 189 ms 202644 KB Output is correct
18 Correct 211 ms 202488 KB Output is correct
19 Correct 185 ms 202488 KB Output is correct
20 Correct 186 ms 202616 KB Output is correct
21 Correct 182 ms 202348 KB Output is correct
22 Correct 183 ms 202480 KB Output is correct
23 Correct 182 ms 202436 KB Output is correct
24 Correct 184 ms 202496 KB Output is correct
25 Correct 188 ms 202664 KB Output is correct
26 Correct 186 ms 202472 KB Output is correct
27 Correct 185 ms 202500 KB Output is correct
28 Correct 185 ms 202488 KB Output is correct
29 Correct 186 ms 202604 KB Output is correct
30 Correct 184 ms 202424 KB Output is correct
31 Correct 1878 ms 272872 KB Output is correct
32 Correct 289 ms 206676 KB Output is correct
33 Correct 1872 ms 273904 KB Output is correct
34 Correct 1865 ms 271028 KB Output is correct
35 Correct 1897 ms 274212 KB Output is correct
36 Correct 1861 ms 276100 KB Output is correct
37 Runtime error 1626 ms 547848 KB Execution killed with signal 11 (could be triggered by violating memory limits)
38 Halted 0 ms 0 KB -