oj.uz

Submission #586879

# Submission time Handle Problem Language Result Execution time Memory
586879 2022-06-30T21:40:20 Z Bench0310 Flood (IOI07_flood) C++17
55 / 100
 330 ms 65536 KB 
#include <bits/stdc++.h>

using namespace std;
typedef long long ll;

const int N=1000001;
vector<int> tree(4*(N+5),0);

void update(int idx,int l,int r,int ql,int qr,int x)
{
    if(ql>qr) return;
    if(l==ql&&r==qr) tree[idx]=x;
    else
    {
        int m=(l+r)/2;
        update(2*idx,l,m,ql,min(qr,m),x);
        update(2*idx+1,m+1,r,max(ql,m+1),qr,x);
    }
}

int query(int idx,int l,int r,int pos)
{
    if(l==r) return tree[idx];
    int m=(l+r)/2;
    if(pos<=m) return max(tree[idx],query(2*idx,l,m,pos));
    else return max(tree[idx],query(2*idx+1,m+1,r,pos));
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    vector<array<int,2>> points(n+1,{0,0});
    vector<array<int,3>> hot_pos(1,{0,0,0});
    int hot_cnt=0;
    auto add_hot=[&](int x,int y)->int
    {
        hot_cnt++;
        hot_pos.push_back({x,y,hot_cnt});
        return hot_cnt;
    };
    vector<array<int,4>> point_hots(n+1);
    for(int i=1;i<=n;i++)
    {
        auto &[x,y]=points[i];
        cin >> x >> y;
        int t=0;
        for(int j=0;j<=1;j++) for(int k=0;k<=1;k++) point_hots[i][t++]=add_hot(x+j,y+k);
    }
    int m;
    cin >> m;
    vector<array<int,2>> walls(m+1,{0,0});
    vector<array<int,2>> wall_hots(m+1,{0,0});
    for(int i=1;i<=m;i++)
    {
        auto &[a,b]=walls[i];
        cin >> a >> b;
        if(points[a]>points[b]) swap(a,b);
        if(points[a][0]==points[b][0]) wall_hots[i]={point_hots[a][1],point_hots[a][3]};
        else wall_hots[i]={point_hots[a][2],point_hots[a][3]};
    }
    vector<int> v[hot_cnt+1];
    auto add_edge=[&](int a,int b)
    {
        v[a].push_back(b);
        v[b].push_back(a);
    };
    auto process=[&]()
    {
        //extract edges
        fill(tree.begin(),tree.end(),-1);
        vector<array<int,2>> prv(N+1,{-1,-1}); //x,hot_id
        vector<array<int,4>> events; //x,tp,[y,hot_id] or [yl,yr]
        for(int i=1;i<=hot_cnt;i++) events.push_back({hot_pos[i][0],0,hot_pos[i][1],i});
        for(int i=1;i<=m;i++)
        {
            auto [a,b]=walls[i];
            auto [xa,ya]=points[a];
            auto [xb,yb]=points[b];
            if(xa==xb) events.push_back({xa,1,ya+1,yb});
        }
        sort(events.begin(),events.end());
        for(auto [x,tp,yl,yr]:events)
        {
            if(tp==0)
            {
                int w=query(1,0,N,yl);
                auto [px,pid]=prv[yl];
                if(w<px) add_edge(yr,pid);
                prv[yl]={x,yr};
            }
            else update(1,0,N,yl,yr,x);
        }
        //flip coordinates
        for(int i=1;i<=n;i++) swap(points[i][0],points[i][1]);
        for(int i=1;i<=hot_cnt;i++) swap(hot_pos[i][0],hot_pos[i][1]);
    };
    process();
    process();
    vector<int> cc_id(hot_cnt+1,0);
    int cc_cnt=0;
    for(int i=1;i<=hot_cnt;i++)
    {
        if(cc_id[i]!=0) continue;
        cc_cnt++;
        queue<int> q;
        auto add=[&](int a)
        {
            if(cc_id[a]==0)
            {
                cc_id[a]=cc_cnt;
                q.push(a);
            }
        };
        add(i);
        while(!q.empty())
        {
            int a=q.front();
            q.pop();
            for(int to:v[a]) add(to);
        }
    }
    vector<int> g[cc_cnt+1];
    for(int i=1;i<=m;i++)
    {
        auto [a,b]=wall_hots[i];
        g[cc_id[a]].push_back(cc_id[b]);
        g[cc_id[b]].push_back(cc_id[a]);
    }
    vector<int> d(cc_cnt+1,0);
    sort(hot_pos.begin(),hot_pos.end());
    queue<int> q;
    auto add=[&](int a,int nd)
    {
        if(d[a]==0)
        {
            d[a]=nd;
            q.push(a);
        }
    };
    for(auto [x,y,hot]:hot_pos)
    {
        add(cc_id[hot],1);
        while(!q.empty())
        {
            int a=q.front();
            q.pop();
            for(int to:g[a]) add(to,d[a]+1);
        }
    }
    vector<int> res;
    for(int i=1;i<=m;i++)
    {
        auto [a,b]=wall_hots[i];
        if(d[cc_id[a]]==d[cc_id[b]]) res.push_back(i);
    }
    cout << res.size() << "\n";
    for(int w:res) cout << w << "\n";
    return 0;
}

Subtask #1
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 18 ms 23764 KB Output is correct

Subtask #2
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 18 ms 23764 KB Output is correct
2 Correct 18 ms 23780 KB Output is correct
3 Correct 20 ms 23764 KB Output is correct

Subtask #3
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 18 ms 23812 KB Output is correct

Subtask #4
3.0 / 3.0

# Verdict Execution time Memory Grader output
1 Correct 18 ms 23864 KB Output is correct
2 Correct 19 ms 24012 KB Output is correct

Subtask #5
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 18 ms 23828 KB Output is correct
2 Correct 18 ms 23852 KB Output is correct

Subtask #6
3.0 / 3.0

# Verdict Execution time Memory Grader output
1 Correct 20 ms 23920 KB Output is correct

Subtask #7
3.0 / 3.0

# Verdict Execution time Memory Grader output
1 Correct 19 ms 23880 KB Output is correct

Subtask #8
3.0 / 3.0

# Verdict Execution time Memory Grader output
1 Correct 20 ms 23892 KB Output is correct
2 Correct 20 ms 23972 KB Output is correct

Subtask #9
3.0 / 3.0

# Verdict Execution time Memory Grader output
1 Correct 21 ms 24012 KB Output is correct
2 Correct 19 ms 24012 KB Output is correct

Subtask #10
0 / 9.0

# Verdict Execution time Memory Grader output
1 Runtime error 110 ms 34296 KB Memory limit exceeded
2 Halted 0 ms 0 KB -

Subtask #11
0 / 9.0

# Verdict Execution time Memory Grader output
1 Runtime error 330 ms 63160 KB Memory limit exceeded
2 Halted 0 ms 0 KB -

Subtask #12
0 / 9.0

# Verdict Execution time Memory Grader output
1 Runtime error 328 ms 65536 KB Memory limit exceeded
2 Halted 0 ms 0 KB -

Subtask #13
0 / 9.0

# Verdict Execution time Memory Grader output
1 Runtime error 238 ms 65536 KB Execution killed with signal 9
2 Halted 0 ms 0 KB -

Subtask #14
0 / 9.0

# Verdict Execution time Memory Grader output
1 Runtime error 236 ms 65536 KB Execution killed with signal 9
2 Halted 0 ms 0 KB -