oj.uz

Submission #388428

# Submission time Handle Problem Language Result Execution time Memory
388428 2021-04-11T12:39:54 Z osaaateiasavtnl Islands (IOI08_islands) C++14
100 / 100
 374 ms 42820 KB 
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <bitset>
#include <fstream>
#include <stack>
using namespace std;
#define ii pair <int, int>
#define app push_back
#define all(a) a.begin(), a.end()
#define bp __builtin_popcountll
#define ll long long
#define mp make_pair
#define x first
#define y second
#define Time (double)clock()/CLOCKS_PER_SEC
#define debug(x) std::cerr << #x << ": " << x << '\n';
#define FOR(i, n) for (int i = 0; i < n; ++i)
#define FORN(i, n) for (int i = 1; i <= n; ++i)
#define pb push_back
#define trav(a, x) for (auto& a : x)
using vi = vector<int>;
template <typename T>
std::istream& operator >>(std::istream& input, std::vector<T>& data)
{
    for (T& x : data)
        input >> x;
    return input;
}
template <typename T>
std::ostream& operator <<(std::ostream& output, const pair <T, T> & data)
{
    output << "(" << data.x << "," << data.y << ")";
    return output;
}
template <typename T>
std::ostream& operator <<(std::ostream& output, const std::vector<T>& data)
{
    for (const T& x : data)
        output << x << " ";
    return output;
}
ll div_up(ll a, ll b) { return a/b+((a^b)>0&&a%b); } // divide a by b rounded up
ll div_down(ll a, ll b) { return a/b-((a^b)<0&&a%b); } // divide a by b rounded down 
ll math_mod(ll a, ll b) { return a - b * div_down(a, b); }
#define tcT template<class T
#define tcTU tcT, class U
tcT> using V = vector<T>; 
tcT> void re(V<T>& x) { 
    trav(a, x)
        cin >> a;
}
tcT> bool ckmin(T& a, const T& b) {
    return b < a ? a = b, 1 : 0; 
} // set a = min(a,b)
tcT> bool ckmax(T& a, const T& b) {
    return a < b ? a = b, 1 : 0; 
}
ll gcd(ll a, ll b) {
    while (b) {
        tie(a, b) = mp(b, a % b);
    }
    return a;
}

const int N = 1e6 + 7;
const ll INF = 1e18 + 7;
bool inc[N];
int in[N];
int n;

int to[N], len[N];

struct Queue {
int qu[N];
int l, r; // r - number of added, l - number of used
void clear() {
    l = r = 0;
}   
int size() {
    return r - l;
}   
int pop() {
    assert(size());
    l++;
    return qu[l - 1];
}   
void push(int x) {
    qu[r] = x;
    r++;
}   
} q;  

ll h[N], diam[N];
void bfs() {
    for (int i = 1; i <= n; ++i) {
        if (in[i] == 0) q.push(i);
        inc[i] = 1;
    }   
    while (q.size()) {
        int u = q.pop();
        inc[u] = 0;
        int v = to[u];
        assert(in[v] > 0);
        in[v]--;
        ckmax(diam[u], h[u]);

    	ckmax(diam[v], diam[u]);
    	ckmax(diam[v], h[v] + h[u] + len[u]);
    	ckmax(h[v], h[u] + len[u]);

        if (in[v] == 0) {
        	q.push(v);
        } 
    }   
    FORN (u, n) {
    	ckmax(diam[u], h[u]);
    }
}

ll pref[N];
int r[N];
int cl[N];
int s[N];
ll solve(int n) {
    ll ans = 0;
    for (int i = 0; i < n; ++i)
    	ans = max(ans, diam[cl[i]]);
    for (int i = 1; i < n; ++i) pref[i] = pref[i - 1] + len[cl[i - 1]];
    int sz = 0;
    for (int i = 0; i < n; ++i) r[i] = n;
    for (int i = 0; i < n; ++i) {
        while (sz && h[cl[s[sz - 1]]] - pref[s[sz - 1]] <= h[cl[i]] - pref[i]) {
            r[s[sz - 1]] = i;
            sz--;
        }   
        s[sz++] = i;
    }
    int ptr = 0; ll cur = 0;
    auto get = [&] (int i) {
    	if (i < n)
    		return cl[i];
    	else
    		return cl[i - n];
    };	
    for (int i = 1; i < 2 * n - 1; ++i) {
        cur += len[get(i - 1)];
        ptr = max(ptr, i - n + 1);
        while (r[ptr] != n && r[ptr] < i) ptr = r[ptr];
        ans = max(ans, h[get(i)] + cur + h[get(ptr)] - pref[ptr]);
    }   
    return ans;        
}
bool used[N]; 
signed main() {
    #ifdef HOME
    freopen("input.txt", "r", stdin);
    #else
    ios_base::sync_with_stdio(0); cin.tie(0);
    #endif
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> to[i] >> len[i];
        in[to[i]]++;
    }   
    bfs();
    ll ans = 0;
    for (int i = 1; i <= n; ++i) {
        if (!used[i] && inc[i]) {
            int u = i;
            int len = 0;
            while (!used[u]) {
                used[u] = 1;
                cl[len++] = u;
                u = to[u];
            }   
            ans += solve(len);
        }
    }   
    cout << ans << '\n';
}

Subtask #1
33.0 / 33.0

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

Subtask #2
3.0 / 3.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 460 KB Output is correct
2 Correct 1 ms 332 KB Output is correct

Subtask #3
4.0 / 4.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 460 KB Output is correct
2 Correct 1 ms 460 KB Output is correct

Subtask #4
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 4 ms 880 KB Output is correct
2 Correct 9 ms 1652 KB Output is correct
3 Correct 6 ms 1104 KB Output is correct
4 Correct 3 ms 688 KB Output is correct

Subtask #5
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 13 ms 2260 KB Output is correct
2 Correct 23 ms 3372 KB Output is correct

Subtask #6
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 48 ms 7240 KB Output is correct
2 Correct 46 ms 6536 KB Output is correct
3 Correct 62 ms 10948 KB Output is correct

Subtask #7
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 92 ms 11992 KB Output is correct
2 Correct 113 ms 19320 KB Output is correct
3 Correct 124 ms 14764 KB Output is correct
4 Correct 158 ms 27576 KB Output is correct

Subtask #8
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 223 ms 13112 KB Output is correct
2 Correct 280 ms 30628 KB Output is correct
3 Correct 179 ms 24992 KB Output is correct
4 Correct 227 ms 37060 KB Output is correct
5 Correct 228 ms 36900 KB Output is correct
6 Correct 358 ms 32228 KB Output is correct
7 Correct 243 ms 42820 KB Output is correct

Subtask #9
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 238 ms 32680 KB Output is correct
2 Correct 235 ms 32520 KB Output is correct
3 Correct 294 ms 33588 KB Output is correct
4 Correct 229 ms 14056 KB Output is correct
5 Correct 232 ms 36292 KB Output is correct
6 Correct 230 ms 34624 KB Output is correct
7 Correct 374 ms 32788 KB Output is correct