oj.uz

Submission #428192

# Submission time Handle Problem Language Result Execution time Memory
428192 2021-06-15T08:45:28 Z 반딧불(#7617) Posters on the wall (CPSPC17_posters) C++17
20 / 100
 2988 ms 1048580 KB 
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

vector<ll> xVec, yVec;
int node_cnt;

struct xNode {
    struct yNode {
        ll globalSum; int globalLazy;
        ll totalSum, totalLazy;
        yNode *lchild, *rchild;

        yNode(){
            globalSum = globalLazy = totalSum = totalLazy = 0;
            lchild = rchild = nullptr;
            node_cnt++;
        }

        ~yNode(){
            if(lchild) delete lchild;
            if(rchild) delete rchild;
        }

        void update(int l, int r, int s, int e, int bonus, int len, bool same){
            if(l==s && r==e){
                if(same){
                    globalSum += yVec[e] - yVec[s];
                    globalLazy++;
                }
                totalSum += len * (yVec[e] - yVec[s]);
                totalLazy += len;
                return;
            }
            int m = (l+r)/2;
            if(s<m){
                if(!lchild) lchild = new yNode();
                lchild->update(l, m, s, min(m, e), bonus, len, same);
            }
            if(m<e){
                if(!rchild) rchild = new yNode();
                rchild->update(m, r, max(s, m), e, bonus, len, same);
            }
            if(same){
                globalSum = (lchild ? lchild->globalSum : 0) + (rchild ? rchild->globalSum : 0) + globalLazy * (yVec[r] - yVec[l]);
            }
            totalSum = (lchild ? lchild->totalSum : 0) + (rchild ? rchild->totalSum : 0) + totalLazy * (yVec[r] - yVec[l]);
        }
    };
    yNode *tree;
    xNode *lchild, *rchild;

    xNode(){
        tree = nullptr;
        lchild = rchild = nullptr;
    }

    ~xNode(){
        if(tree) delete tree;
        if(lchild) delete lchild;
        if(rchild) delete rchild;
    }

    void update(int xl, int xr, int yl, int yr, int xs, int xe, int ys, int ye){
        ll len = xVec[xe] - xVec[xs];
        if(xl != xs || xr != xe){
            int m = (xl+xr)/2;
            if(xs < m){
                if(!lchild) lchild = new xNode();
                lchild->update(xl, m, yl, yr, xs, min(m, xe), ys, ye);
            }
            if(m < xe){
                if(!rchild) rchild = new xNode();
                rchild->update(m, xr, yl, yr, max(xs, m), xe, ys, ye);
            }
        }
        if(!tree) tree = new yNode();
        tree->update(yl, yr, ys, ye, xVec[xr] - xVec[xl], len, xl==xs && xr==xe);
    }
} *tree;

ll ans = 0;
void query(xNode::yNode *i, int l, int r, int s, int e, ll lazySum, int len, bool same){
    if(l==s && r==e){
        if(same){
            if(i) ans += i->totalSum;
            ans += lazySum * (yVec[r] - yVec[l]);
        }
        else{
            if(i) ans += i->globalSum * len;
            ans += lazySum * len * (yVec[r] - yVec[l]);
        }
        return;
    }
    lazySum = !i ? lazySum : (lazySum + (same ? i->totalLazy : i->globalLazy));
    int m = (l+r)/2;
    if(s<m) query(i ? i->lchild : nullptr, l, m, s, min(m, e), lazySum, len, same);
    if(m<e) query(i ? i->rchild : nullptr, m, r, max(s, m), e, lazySum, len, same);
}

void query(xNode *i, int xl, int xr, int yl, int yr, int xs, int xe, int ys, int ye){
    int len = xVec[xe] - xVec[xs];
    query(i->tree, yl, yr, ys, ye, 0, len, xl==xs && xr==xe);
    if(xl!=xs || xr!=xe){
        int m = (xl+xr)/2;
        if(xs<m && i->lchild) query(i->lchild, xl, m, yl, yr, xs, min(m, xe), ys, ye);
        if(m<xe && i->rchild) query(i->rchild, m, xr, yl, yr, max(xs, m), xe, ys, ye);
    }
}

int r, c, n, q, m, N, M;
ll _x1[50002], _y1[50002], _x2[50002], _y2[50002];
ll _qx1[50002], _qy1[50002], _qx2[50002], _qy2[50002], _qw[50002];

void query(int xs, int xe, int ys, int ye){
    return query(tree, 0, N-1, 0, M-1, xs, xe, ys, ye);
}

int main(){
    scanf("%d %d %d %d %d", &r, &c, &n, &q, &m);
    xVec.push_back(0), xVec.push_back(r);
    yVec.push_back(0), yVec.push_back(c);
    for(int i=1; i<=n; i++){
        scanf("%lld %lld %lld %lld", &_x1[i], &_y1[i], &_x2[i], &_y2[i]);
//        _x1[i] = _y1[i] = (i-1)*6, _x2[i] = _y2[i] = i*6; _x2[i] = 300000;
        if(_x1[i] > _x2[i]) swap(_x1[i], _x2[i]);
        if(_y1[i] > _y2[i]) swap(_y1[i], _y2[i]);
        xVec.push_back(_x1[i]), xVec.push_back(_x2[i]);
        yVec.push_back(_y1[i]), yVec.push_back(_y2[i]);
    }
    for(int i=1; i<=q; i++){
        scanf("%lld %lld %lld %lld %lld", &_qx1[i], &_qy1[i], &_qx2[i], &_qy2[i], &_qw[i]);
//        _qx1[i] = rand(), _qx2[i] = rand(), _qy1[i] = rand(), _qy2[i] = rand();
        xVec.push_back(_qx1[i]), xVec.push_back(_qx2[i]);
        yVec.push_back(_qy1[i]), yVec.push_back(_qy2[i]);
    }
    sort(xVec.begin(), xVec.end());
    xVec.erase(unique(xVec.begin(), xVec.end()), xVec.end());
    sort(yVec.begin(), yVec.end());
    yVec.erase(unique(yVec.begin(), yVec.end()), yVec.end());
    N = (int)xVec.size(), M = (int)yVec.size();

    tree = new xNode();
    for(int i=1; i<=n; i++){
        _x1[i] = lower_bound(xVec.begin(), xVec.end(), _x1[i]) - xVec.begin();
        _x2[i] = lower_bound(xVec.begin(), xVec.end(), _x2[i]) - xVec.begin();
        _y1[i] = lower_bound(yVec.begin(), yVec.end(), _y1[i]) - yVec.begin();
        _y2[i] = lower_bound(yVec.begin(), yVec.end(), _y2[i]) - yVec.begin();
        tree->update(0, N-1, 0, M-1, _x1[i], _x2[i], _y1[i], _y2[i]);
    }

    #ifdef TEST
    printf("node_cnt: %d, size: %d\n", node_cnt, sizeof(xNode::yNode) * node_cnt);
    #endif // TEST

    for(int i=1; i<=q; i++){
        ll qx1 = _qx1[i], qy1 = _qy1[i], qx2 = _qx2[i], qy2 = _qy2[i], v = _qw[i];
        ans %= m, v %= m;
        qx1 = (qx1 + ans * v) % m;
        qx2 = (qx2 + ans * v) % m;
        qy1 = (qy1 + ans * v) % m;
        qy2 = (qy2 + ans * v) % m;
        if(qx1 > qx2) swap(qx1, qx2);
        if(qy1 > qy2) swap(qy1, qy2);

        int xl = upper_bound(xVec.begin(), xVec.end(), qx1) - xVec.begin() - 1;
        int xr = lower_bound(xVec.begin(), xVec.end(), qx2) - xVec.begin();
        int yl = upper_bound(yVec.begin(), yVec.end(), qy1) - yVec.begin() - 1;
        int yr = lower_bound(yVec.begin(), yVec.end(), qy2) - yVec.begin();

        ans = 0;
        query(xl, xr, yl, yr);

        printf("%lld\n", ans);
    }
    delete tree;
}

Compilation message

Main.cpp: In function 'int main()':
Main.cpp:122:10: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
  122 |     scanf("%d %d %d %d %d", &r, &c, &n, &q, &m);
      |     ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:126:14: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
  126 |         scanf("%lld %lld %lld %lld", &_x1[i], &_y1[i], &_x2[i], &_y2[i]);
      |         ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Main.cpp:134:14: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
  134 |         scanf("%lld %lld %lld %lld %lld", &_qx1[i], &_qy1[i], &_qx2[i], &_qy2[i], &_qw[i]);
      |         ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Subtask #1
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 8 ms 2764 KB Output is correct
2 Correct 11 ms 2760 KB Output is correct
3 Correct 8 ms 2544 KB Output is correct

Subtask #2
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 8 ms 2764 KB Output is correct
2 Correct 11 ms 2760 KB Output is correct
3 Correct 8 ms 2544 KB Output is correct
4 Correct 265 ms 58844 KB Output is correct
5 Correct 201 ms 40896 KB Output is correct
6 Correct 198 ms 38068 KB Output is correct

Subtask #3
0 / 40.0

# Verdict Execution time Memory Grader output
1 Correct 8 ms 2764 KB Output is correct
2 Correct 11 ms 2760 KB Output is correct
3 Correct 8 ms 2544 KB Output is correct
4 Correct 265 ms 58844 KB Output is correct
5 Correct 201 ms 40896 KB Output is correct
6 Correct 198 ms 38068 KB Output is correct
7 Correct 2214 ms 310872 KB Output is correct
8 Runtime error 1852 ms 1048580 KB Execution killed with signal 9
9 Halted 0 ms 0 KB -

Subtask #4
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 8 ms 2764 KB Output is correct
2 Correct 11 ms 2760 KB Output is correct
3 Correct 8 ms 2544 KB Output is correct
4 Correct 265 ms 58844 KB Output is correct
5 Correct 201 ms 40896 KB Output is correct
6 Correct 198 ms 38068 KB Output is correct
7 Correct 2988 ms 735048 KB Output is correct
8 Runtime error 1892 ms 1048580 KB Execution killed with signal 9
9 Halted 0 ms 0 KB -

Subtask #5
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 8 ms 2764 KB Output is correct
2 Correct 11 ms 2760 KB Output is correct
3 Correct 8 ms 2544 KB Output is correct
4 Correct 265 ms 58844 KB Output is correct
5 Correct 201 ms 40896 KB Output is correct
6 Correct 198 ms 38068 KB Output is correct
7 Correct 2214 ms 310872 KB Output is correct
8 Runtime error 1852 ms 1048580 KB Execution killed with signal 9
9 Halted 0 ms 0 KB -

Subtask #6
0 / 10.0

# Verdict Execution time Memory Grader output
1 Incorrect 1678 ms 300124 KB Output isn't correct
2 Halted 0 ms 0 KB -

Subtask #7
0 / 10.0

# Verdict Execution time Memory Grader output
1 Incorrect 1678 ms 300124 KB Output isn't correct
2 Halted 0 ms 0 KB -