Submission #1301394

#	Time	Username	Problem	Language	Result	Execution time	Memory
1301394		tamir1	Obstacles for a Llama (IOI25_obstacles)	C++20	Compilation error	0 ms	0 KiB

obstacles

#include <bits/stdc++.h>
#include "obstacles.h"
using namespace std;

static int N, M;
static vector<int> Tval, Hval;
static vector<int> c;
static vector<int> b;
static vector<int> sum;
static vector<int> left, right;

// Segment trees
static vector<int> seg_min, seg_max;

// Build segment trees
void build_seg_min(int node, int l, int r) {
    if (l == r) { seg_min[node] = Hval[l]; return; }
    int mid = (l + r) / 2;
    build_seg_min(2*node, l, mid);
    build_seg_min(2*node+1, mid+1, r);
    seg_min[node] = min(seg_min[2*node], seg_min[2*node+1]);
}

void build_seg_max(int node, int l, int r) {
    if (l == r) { seg_max[node] = Hval[l]; return; }
    int mid = (l + r) / 2;
    build_seg_max(2*node, l, mid);
    build_seg_max(2*node+1, mid+1, r);
    seg_max[node] = max(seg_max[2*node], seg_max[2*node+1]);
}

int query_min(int node, int l, int r, int ql, int qr) {
    if (qr < l || r < ql) return INT_MAX;
    if (ql <= l && r <= qr) return seg_min[node];
    int mid = (l + r) / 2;
    return min(query_min(2*node, l, mid, ql, qr),
               query_min(2*node+1, mid+1, r, ql, qr));
}

int query_max(int node, int l, int r, int ql, int qr) {
    if (qr < l || r < ql) return INT_MIN;
    if (ql <= l && r <= qr) return seg_max[node];
    int mid = (l + r) / 2;
    return max(query_max(2*node, l, mid, ql, qr),
               query_max(2*node+1, mid+1, r, ql, qr));
}

// Wrappers
int call_min(int l, int r) { return query_min(1, 0, M-1, l, r); }
int call_max(int l, int r) { return query_max(1, 0, M-1, l, r); }

void initialize(vector<int> T, vector<int> H) {
    Tval = T; Hval = H;
    N = Tval.size(); M = Hval.size();

    int d = Tval[0];
    c.assign(M, 0);
    b.assign(M, -1);
    sum.assign(M, 0);
    left.assign(M, 0);
    right.assign(M, 0);

    for(int i = 0; i < M; i++) c[i] = (Hval[i] >= d ? 1 : 0);

    sum[0] = c[0];
    for(int i = 1; i < M; i++) sum[i] = sum[i-1] + c[i];

    int last = M;
    for(int i = M-1; i >= 0; i--) {
        if(c[i] == 1) last = i;
        right[i] = last-1;
    }

    last = -1;
    for(int i = 0; i < M; i++) {
        if(c[i] == 1) last = i;
        left[i] = last+1;
    }

    seg_min.assign(4*M, INT_MAX);
    seg_max.assign(4*M, INT_MIN);
    build_seg_min(1, 0, M-1);
    build_seg_max(1, 0, M-1);
}

bool can_reach(int L, int R, int S, int D) {
    bool st=false, en=false;
    if(S > D) swap(S,D);

    if(call_max(S,D) >= 3) return false;

    int sad = left[S];
    int happy = right[S];
    if(call_min(sad, happy) == 0) st = true;

    sad = left[D];
    happy = right[D];
    if(call_min(sad, happy) == 0) en = true;

    if(st && en) return true;

    int sum_Sminus1 = (S == 0 ? 0 : sum[S-1]);
    if(sum[D]-sum_Sminus1 == 0) return true;

    return false;
}

Compilation message (stderr)

obstacles.cpp: In function 'void initialize(std::vector<int>, std::vector<int>)':
obstacles.cpp:60:5: error: reference to 'left' is ambiguous
   60 |     left.assign(M, 0);
      |     ^~~~
In file included from /usr/include/c++/13/streambuf:43,
                 from /usr/include/c++/13/bits/streambuf_iterator.h:35,
                 from /usr/include/c++/13/iterator:66,
                 from /usr/include/x86_64-linux-gnu/c++/13/bits/stdc++.h:54,
                 from obstacles.cpp:1:
/usr/include/c++/13/bits/ios_base.h:1042:3: note: candidates are: 'std::ios_base& std::left(ios_base&)'
 1042 |   left(ios_base& __base)
      |   ^~~~
obstacles.cpp:10:20: note:                 'std::vector<int> left'
   10 | static vector<int> left, right;
      |                    ^~~~
obstacles.cpp:61:5: error: reference to 'right' is ambiguous
   61 |     right.assign(M, 0);
      |     ^~~~~
/usr/include/c++/13/bits/ios_base.h:1050:3: note: candidates are: 'std::ios_base& std::right(ios_base&)'
 1050 |   right(ios_base& __base)
      |   ^~~~~
obstacles.cpp:10:26: note:                 'std::vector<int> right'
   10 | static vector<int> left, right;
      |                          ^~~~~
obstacles.cpp:71:9: error: reference to 'right' is ambiguous
   71 |         right[i] = last-1;
      |         ^~~~~
/usr/include/c++/13/bits/ios_base.h:1050:3: note: candidates are: 'std::ios_base& std::right(ios_base&)'
 1050 |   right(ios_base& __base)
      |   ^~~~~
obstacles.cpp:10:26: note:                 'std::vector<int> right'
   10 | static vector<int> left, right;
      |                          ^~~~~
obstacles.cpp:77:9: error: reference to 'left' is ambiguous
   77 |         left[i] = last+1;
      |         ^~~~
/usr/include/c++/13/bits/ios_base.h:1042:3: note: candidates are: 'std::ios_base& std::left(ios_base&)'
 1042 |   left(ios_base& __base)
      |   ^~~~
obstacles.cpp:10:20: note:                 'std::vector<int> left'
   10 | static vector<int> left, right;
      |                    ^~~~
obstacles.cpp: In function 'bool can_reach(int, int, int, int)':
obstacles.cpp:92:15: error: reference to 'left' is ambiguous
   92 |     int sad = left[S];
      |               ^~~~
/usr/include/c++/13/bits/ios_base.h:1042:3: note: candidates are: 'std::ios_base& std::left(ios_base&)'
 1042 |   left(ios_base& __base)
      |   ^~~~
obstacles.cpp:10:20: note:                 'std::vector<int> left'
   10 | static vector<int> left, right;
      |                    ^~~~
obstacles.cpp:93:17: error: reference to 'right' is ambiguous
   93 |     int happy = right[S];
      |                 ^~~~~
/usr/include/c++/13/bits/ios_base.h:1050:3: note: candidates are: 'std::ios_base& std::right(ios_base&)'
 1050 |   right(ios_base& __base)
      |   ^~~~~
obstacles.cpp:10:26: note:                 'std::vector<int> right'
   10 | static vector<int> left, right;
      |                          ^~~~~
obstacles.cpp:96:11: error: reference to 'left' is ambiguous
   96 |     sad = left[D];
      |           ^~~~
/usr/include/c++/13/bits/ios_base.h:1042:3: note: candidates are: 'std::ios_base& std::left(ios_base&)'
 1042 |   left(ios_base& __base)
      |   ^~~~
obstacles.cpp:10:20: note:                 'std::vector<int> left'
   10 | static vector<int> left, right;
      |                    ^~~~
obstacles.cpp:97:13: error: reference to 'right' is ambiguous
   97 |     happy = right[D];
      |             ^~~~~
/usr/include/c++/13/bits/ios_base.h:1050:3: note: candidates are: 'std::ios_base& std::right(ios_base&)'
 1050 |   right(ios_base& __base)
      |   ^~~~~
obstacles.cpp:10:26: note:                 'std::vector<int> right'
   10 | static vector<int> left, right;
      |                          ^~~~~