Submission #916801

# Submission time Handle Problem Language Result Execution time Memory
916801 2024-01-26T14:37:30 Z sleepntsheep Plahte (COCI17_plahte) C++17
0 / 160
320 ms 102960 KB
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cmath>
#include <cassert>
#include <cstring>
#include <vector>
#include <algorithm>
#include <deque>
#include <set>
#include <utility>
#include <array>
#include <complex>

using u32 = unsigned;
using i32 = int;
using i64 = long long;
using u64 = unsigned long long;
using f64 = double;
using f80 = long double;

using namespace std;
using pt = complex<f80>;
#define ALL(x) begin(x), end(x)
#define ShinLena cin.tie(nullptr)->sync_with_stdio(false);
#define N 500005

int n, m;
array<int, 4> a[N];
array<int, 3> b[N];

vector<tuple<int, int, int>> ev_x;

set<pair<int, int>> fw[N];

void input_c()
{
    cin >> n >> m;

    vector<int> cord_x, cord_y;
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < 4; ++j) cin >> a[i][j];
        cord_x.push_back(a[i][0]);
        cord_x.push_back(a[i][2]);
        cord_y.push_back(a[i][1]);
        cord_y.push_back(a[i][3]);
    }
    for (int i = 0; i < m; ++i)
    {
        cin >> b[i][0] >> b[i][1] >> b[i][2];
        cord_x.push_back(b[i][0]);
        cord_y.push_back(b[i][1]);
    }
    sort(ALL(cord_x));
    sort(ALL(cord_y));
    for (int i = 0; i < n; ++i)
    {
        a[i][0] = lower_bound(ALL(cord_x), a[i][0]) - cord_x.begin() + 1;
        a[i][2] = lower_bound(ALL(cord_x), a[i][2]) - cord_x.begin() + 1;
        a[i][1] = lower_bound(ALL(cord_y), a[i][1]) - cord_y.begin() + 1;
        a[i][3] = lower_bound(ALL(cord_y), a[i][3]) - cord_y.begin() + 1;
    }
    for (int i = 0; i < m; ++i)
    {
        b[i][0] = lower_bound(ALL(cord_x), b[i][0]) - cord_x.begin() + 1;
        b[i][1] = lower_bound(ALL(cord_y), b[i][1]) - cord_y.begin() + 1;
    }

}

int par[N], parball[N];

int lz[N<<2], t[N<<2];

void push(int v, int l, int r)
{
    if (lz[v] != -86)
    {
        if (l != r) lz[2*v+1] = lz[2*v+2] = lz[v];
        t[v] = lz[v];
        lz[v] = -86;
    }
}
 
void upd(int v, int l, int r, int x, int y, int k)
{
    push(v, l, r);
    if (r < x||y<l)return;
    if(x<=l&&r<=y){lz[v]=k;push(v,l,r);return;}
    upd(2*v+1, l,(l+r)/2,x,y,k),upd(2*v+2,(l+r)/2+1,r,x,y,k);
}
 
int qry(int v,int l,int r,int p)
{
    push(v,l,r);
    if (l==r)return t[v];
    if(p<=(l+r)/2)return qry(2*v+1,l,(l+r)/2,p);
    return qry(2*v+2, (l+r)/2+1, r, p);
}


/*
void ins(int i)
{
    for (int p = a[i][1]; p < N; p += p&-p)
        fw[p].insert({a[i][3], i});
}

void del(int i)
{
    for (int p = a[i][1]; p < N; p += p&-p)
        fw[p].erase({a[i][3], i});
}

int qry(int down_brder, int up_brder)
{
    pair<int, int> z { 1000000, -1 };
    for (int p = down_brder; p; p -= p&-p)
    {
        auto it = fw[p].lower_bound({up_brder, -1});
        if (it != fw[p].end() and a[it->second][1] <= down_brder) z = min(z, *it);
    }
    return z.second;
}
*/


set<int> st[N];
basic_string<int> g[N];
int vis[N], ans[N], _prev[N];

void dfs(int u)
{
    if (vis[u]) return;
    vis[u] = 1;
    for (auto v : g[u]) 
    {
        dfs(v);
        if (st[v].size() > st[u].size()) st[v].swap(st[u]);
        for (auto x : st[v]) st[u].insert(x);
    }
    ans[u] = st[u].size();
}


int main()
{
    memset(lz, -86, sizeof lz);
    ShinLena;
    input_c();

    for (int i = 0; i < n; ++i)
    {
        ev_x.emplace_back(a[i][0], i, -3);
        ev_x.emplace_back(a[i][2], i, -1);
    }

    for (int i = 0; i < m; ++i)
    {
        ev_x.emplace_back(b[i][0], i, -2);
    }

    sort(ALL(ev_x));

    upd(0, 1, N, 1, N, -1);
    for (auto [x, id, ty] : ev_x)
    {
        if (ty == -1)
        {
            upd(0, 1, N, a[id][1], a[id][3], _prev[id]);
        }
        else if (ty == -3)
        {
            par[id] = qry(0, 1, N, a[id][3]);
            if (par[id] + 1)
                g[par[id]].push_back(id);

            _prev[id] = qry(0, 1, N, a[id][1]);
            upd(0, 1, N, a[id][1], a[id][3], id);
        }
        else
        {
            parball[id] = qry(0, 1, N, b[id][2]);
            if (parball[id] != -1)
                st[parball[id]].insert(b[id][2]);
        }
    }

    /*
    for (int i = 0; i < n; ++i)
    {
        cout << i << " <-- " << par[i] << '\n';
    }

    for (int i = 0; i < m; ++i)
    {
        cout << i << " <-- " << parball[i] << '\n';
    }
    */

    for (int i = 0; i < n; ++i) if (!vis[i]) dfs(i);
    for (int i = 0; i < n; ++i) cout << ans[i] << '\n';

    return 0;
}


# Verdict Execution time Memory Grader output
1 Incorrect 110 ms 91780 KB Output isn't correct
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Incorrect 117 ms 92488 KB Output isn't correct
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Incorrect 183 ms 98320 KB Output isn't correct
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Incorrect 298 ms 102960 KB Output isn't correct
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Incorrect 320 ms 102048 KB Output isn't correct
2 Halted 0 ms 0 KB -