oj.uz

Submission #840890

# Submission time Handle Problem Language Result Execution time Memory
840890 2023-08-31T20:14:06 Z Charizard2021 Bread First Search (CCO21_day2problem2) C++17
25 / 25
 88 ms 5936 KB 
#include<bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(false);; cin.tie(NULL)
long long gcd(long long a, long long b){
    return (b == 0 ? a : gcd(b, a % b));
}
void selfMax(long long& a, long long b){
    a = max(a, b);
}
void selfMin(long long& a, long long b){
    a = min(a, b);
}
template<typename T> istream& operator>>(istream& in, vector<T>& a) {for(auto &x : a) in >> x; return in;};
template<typename T1, typename T2> istream& operator>>(istream& in, pair<T1, T2>& x) {return in >> x.first >> x.second;}

template<typename T1, typename T2> ostream& operator<<(ostream& out, const pair<T1, T2>& x) {return out << x.first << ' ' << x.second;}
template<typename T> ostream& operator<<(ostream& out, vector<T>& a) {for(auto &x : a) out << x << ' '; return out;};
template<typename T> ostream& operator<<(ostream& out, vector<vector<T> >& a) {for(auto &x : a) out << x << '\n'; return out;};
template<typename T1, typename T2> ostream& operator<<(ostream& out, vector<pair<T1, T2> >& a) {for(auto &x : a) out << x << '\n'; return out;};

/*

Use DSU dsu(N);

*/
struct DSU {
    vector<long long> adj2;
    DSU(long long N) { adj2 = vector<long long>(N, -1); }

    // get representive component (uses path compression)
    long long get(long long x) { return adj2[x] < 0 ? x : adj2[x] = get(adj2[x]); }

    bool same_set(long long a, long long b) { return get(a) == get(b); }

    long long size(long long x) { return -adj2[get(x)]; }

    bool unite(long long x, long long y) {  // union by size
        x = get(x), y = get(y);
        if (x == y) return false;
        if (adj2[x] > adj2[y]) swap(x, y);
        adj2[x] += adj2[y]; adj2[y] = x;
        return true;
    }
};
/*

Run with Bit<long long> BIT

*/
template <class T> class BIT {
    private:
        long long size;
        vector<T> bit;
        vector<T> arr;
    public:
        BIT(long long size) : size(size), bit(size + 1), arr(size) {}
        void set(long long ind, long long val) { add(ind, val - arr[ind]); }
        void add(long long ind, long long val) {
            arr[ind] += val;
            ind++;
            for (; ind <= size; ind += ind & -ind) { bit[ind] += val; }
        }
        T pref_sum(long long ind) {
            ind++;
            T total = 0;
            for (; ind > 0; ind -= ind & -ind) { total += bit[ind]; }
            return total;
        }
};
/*

Change Comb for specific Seg tree probs, but run with Seg<long long> Seg;

*/
template<class T> struct Seg {
    const T ID = 1e18; T comb(T a, T b) { return min(a,b); }
    long long n; vector<T> seg;
    void init(long long _n) { n = _n; seg.assign(2*n,ID); }
    void pull(long long p) { seg[p] = comb(seg[2*p],seg[2*p+1]); }
    void upd(long long p, T val) {
        seg[p += n] = val; for (p /= 2; p; p /= 2) pull(p); }
    T query(long long l, long long r) {
        T ra = ID, rb = ID;
        for (l += n, r += n+1; l < r; l /= 2, r /= 2) {
            if (l&1) ra = comb(ra,seg[l++]);
            if (r&1) rb = comb(seg[--r],rb);
        }
        return comb(ra,rb);
    }
};
int main(){
    int n, m;
    cin >> n >> m;
    int l[n];
    int r[n];
    for(int i = 0; i < n; i++){
        l[i] = i;
        r[i] = i;
    }
    for(int i = 0; i < m; i++){
        int a, b;
        cin >> a >> b;
        a--;
        b--;
        if(a > b){
            swap(a, b);
        }
        r[a] = max(r[a], b);
        l[b] = min(l[b], a);
    }
    vector<int> prefSum(n, 0);
    for(int i = 1; i < n; i++){
        prefSum[l[i]]++;
        prefSum[i]--;
    }
    int cur1 = 0;
    int cur2 = 0;
    vector<int> d(n, 0);
    if(r[0] > 0){
        d[r[0]] = prefSum[0];
    }
    for(int i = 0; i < n; i++){
        cur1 += prefSum[i];
        cur2 = max(cur2, r[i]);
        if(i >= r[0]){
            d[i] = max(d[i], d[i - 1]);
            d[cur2] = max(d[cur2], d[i] + cur1);
        }
    }
    cout << n - d[n - 1] - 1 << "\n";
}

Subtask #1
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 0 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 1 ms 212 KB Output is correct
6 Correct 1 ms 212 KB Output is correct
7 Correct 1 ms 216 KB Output is correct
8 Correct 1 ms 212 KB Output is correct
9 Correct 0 ms 212 KB Output is correct
10 Correct 1 ms 212 KB Output is correct
11 Correct 1 ms 212 KB Output is correct

Subtask #2
6.0 / 6.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 0 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 1 ms 212 KB Output is correct
6 Correct 1 ms 212 KB Output is correct
7 Correct 1 ms 216 KB Output is correct
8 Correct 1 ms 212 KB Output is correct
9 Correct 0 ms 212 KB Output is correct
10 Correct 1 ms 212 KB Output is correct
11 Correct 1 ms 212 KB Output is correct
12 Correct 1 ms 212 KB Output is correct
13 Correct 0 ms 212 KB Output is correct
14 Correct 0 ms 212 KB Output is correct
15 Correct 0 ms 212 KB Output is correct
16 Correct 1 ms 212 KB Output is correct
17 Correct 1 ms 212 KB Output is correct
18 Correct 1 ms 216 KB Output is correct
19 Correct 1 ms 212 KB Output is correct
20 Correct 0 ms 212 KB Output is correct
21 Correct 1 ms 212 KB Output is correct
22 Correct 1 ms 212 KB Output is correct
23 Correct 1 ms 340 KB Output is correct
24 Correct 1 ms 340 KB Output is correct
25 Correct 6 ms 468 KB Output is correct
26 Correct 6 ms 468 KB Output is correct
27 Correct 6 ms 468 KB Output is correct
28 Correct 6 ms 468 KB Output is correct
29 Correct 2 ms 364 KB Output is correct
30 Correct 14 ms 704 KB Output is correct
31 Correct 14 ms 724 KB Output is correct

Subtask #3
14.0 / 14.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 212 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 0 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 1 ms 212 KB Output is correct
6 Correct 1 ms 212 KB Output is correct
7 Correct 1 ms 216 KB Output is correct
8 Correct 1 ms 212 KB Output is correct
9 Correct 0 ms 212 KB Output is correct
10 Correct 1 ms 212 KB Output is correct
11 Correct 1 ms 212 KB Output is correct
12 Correct 1 ms 212 KB Output is correct
13 Correct 0 ms 212 KB Output is correct
14 Correct 0 ms 212 KB Output is correct
15 Correct 0 ms 212 KB Output is correct
16 Correct 1 ms 212 KB Output is correct
17 Correct 1 ms 212 KB Output is correct
18 Correct 1 ms 216 KB Output is correct
19 Correct 1 ms 212 KB Output is correct
20 Correct 0 ms 212 KB Output is correct
21 Correct 1 ms 212 KB Output is correct
22 Correct 1 ms 212 KB Output is correct
23 Correct 1 ms 340 KB Output is correct
24 Correct 1 ms 340 KB Output is correct
25 Correct 6 ms 468 KB Output is correct
26 Correct 6 ms 468 KB Output is correct
27 Correct 6 ms 468 KB Output is correct
28 Correct 6 ms 468 KB Output is correct
29 Correct 2 ms 364 KB Output is correct
30 Correct 14 ms 704 KB Output is correct
31 Correct 14 ms 724 KB Output is correct
32 Correct 3 ms 3416 KB Output is correct
33 Correct 5 ms 3404 KB Output is correct
34 Correct 83 ms 5020 KB Output is correct
35 Correct 87 ms 5924 KB Output is correct
36 Correct 87 ms 5936 KB Output is correct
37 Correct 88 ms 5928 KB Output is correct
38 Correct 3 ms 3416 KB Output is correct
39 Correct 5 ms 3412 KB Output is correct
40 Correct 40 ms 2892 KB Output is correct
41 Correct 81 ms 5020 KB Output is correct
42 Correct 88 ms 5816 KB Output is correct
43 Correct 81 ms 5800 KB Output is correct
44 Correct 0 ms 212 KB Output is correct
45 Correct 0 ms 212 KB Output is correct