Submission #1287894

#	Time	Username	Problem	Language	Result	Execution time	Memory
1287894		SamueleVid	The short shank; Redemption (BOI21_prison)	C++20	100 / 100	413 ms	325284 KiB

prison

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

#define all(x) begin(x), end(x)
#define rep(i,a,b) for(int i = a; i < (b); ++i)
typedef long long ll;
#define sz(x) (int)(x).size()
typedef vector<int> vi;
typedef pair<int, int> pii;

void dfs(int u, vector<vi> &adj, vi &height, vi &max_depth_node) {
    max_depth_node[u] = u;
    height[u] = 0;
    for (auto x : adj[u]) {
        dfs(x, adj, height, max_depth_node);
        if (height[x] + 1 > height[u]) {
            height[u] = height[x] + 1;
            max_depth_node[u] = max_depth_node[x];
        }
    }
}

int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    int N, D, T; cin >> N >> D >> T;
    vector<ll> t(N);
    for (int i = 0; i < N; i ++) cin >> t[i];

    vi is_passive(N);
    ll curr_min = 1e18;
    for (int i = 0; i < N; i ++) {
        curr_min = min(curr_min + 1, t[i]);
        if (t[i] > T && curr_min <= T) is_passive[i] = 1;
    }

    vi p(N, -1);
    stack<pair<int, ll>> passive_without_parent;
    passive_without_parent.push({-1, -1}); // placeholder iniziale, non si toglie mai per le proprietà dei passive
    for (int i = 0; i < N; i ++) {
		// cout << "i : " << i << '\n';
		// cout << "passive : " << is_passive[i] << '\n';
		// if (i >= 2) return 0;
        if (is_passive[i]) {
			while (passive_without_parent.top().second < i) {
				// se gli ultimi non passivi dopo l'ultimo passive non fa ribellare i, che è passive
				// allora setto il parent dell'ultimo passive nello stack come i
				auto [idx, max_rebel] = passive_without_parent.top();
				passive_without_parent.pop();
				p[idx] = i;
				// sposto a sx il materasso e quindi unisco al passive precedente le influenze dei non passive a destra dell'ultimo passive
				passive_without_parent.top().second = max(passive_without_parent.top().second, max_rebel);
			}
			// aggiungo l'ultimo e metto materasso alla sinistra. essendo passive, t[i] > T quindi non fa ribellare nessuno (-1)
       		passive_without_parent.push({i, -1}); 
		}
		else {
			// aggiorno quanto in là fanno ribellare i non passive a destra dell'ultimo passive
		
			ll max_rebel = passive_without_parent.top().second;
			ll max_rebel_from_i = T + i - t[i]; // t[i] fa ribellare tutti i passive che si trovano entro T + i - t[i]
			passive_without_parent.top().second = max(max_rebel, max_rebel_from_i);
		}
    }

    vector<vi> adj(N);
    for (int i = 0; i < N; i ++) {
        if (!is_passive[i]) continue;
        if (p[i] != -1) adj[p[i]].push_back(i);
    }
    
    vi height(N), max_depth_node(N);
    vector<vi> roots_at_depth(N);

    for (int i = 0; i < N; i ++) {
        if (is_passive[i] && p[i] == -1) {
            dfs(i, adj, height, max_depth_node);
            roots_at_depth[height[i]].push_back(i);
        }
    }

    vi visited(N);
    for (int d = N - 1; d >= 0; d --) {
        while (D && !roots_at_depth[d].empty()) {

            int r = roots_at_depth[d].back();
            roots_at_depth[d].pop_back();

            if (visited[r]) continue;
            int u = max_depth_node[r]; ;
            
            while (u != -1) {
                for (auto x : adj[u]) {
                    if (visited[x]) continue;
                    p[x] = -1;
                    roots_at_depth[height[x]].push_back(x);        
                }
                visited[u] = 1;
                u = p[u];
            }
            D --;
        }        
    }

    ll sol = 0;
    for (int i = 0; i < N; i ++) {
        if (!is_passive[i] && t[i] <= T) sol ++;
        if (is_passive[i] && !visited[i]) sol ++;
    }

    cout << sol << '\n';
}

• Subtask 1: 15 / 15
• Subtask 2: 10 / 10
• Subtask 3: 20 / 20
• Subtask 4: 10 / 10
• Subtask 5: 25 / 25
• Subtask 6: 20 / 20