제출 #1320199

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
1320199		MunkhErdene	장애물 (IOI25_obstacles)	C++17	23 / 100	2113 ms	516460 KiB

obstacles

#include<bits/stdc++.h>
#include "obstacles.h"
using namespace std;
#define ll long long
#define pb push_back
#define ff first
#define ss second
#define _ << " " <<
#define yes cout<<"YES\n"
#define no cout<<"NO\n"
#define ull unsigned long long
#define lll __int128
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
#define BlueCrowner ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORD(i, a, b) for (ll i = (a); i >= (b); i--)
const ll mod = 1e9 + 7;
const ll mod1 = 998244353;
const ll naim = 1e9;
const ll max_bit = 60;
const ull tom = ULLONG_MAX;
const ll MAXN = 2e6 + 5;
const ll LOG = 20;
const ll NAIM = 1e18;
const ll N = 2e6 + 5;
// ---------- GCD ----------
ll gcd(ll a, ll b) {
    while (b) {
        a %= b;
        swap(a, b);
    }
    return a;
}
// ---------- LCM ----------
ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}
// ---------- Modular Exponentiation ----------
ll modpow(ll a, ll b, ll m = mod) {
    ll c = 1;
    a %= m;
    while (b > 0) {
        if (b & 1) c = c * a % m;
        a = a * a % m;
        b >>= 1;
    }
    return c;
}
// ---------- Modular Inverse (Fermat’s Little Theorem) ----------
ll modinv(ll a, ll m = mod) {
    return modpow(a, m - 2, m);
}
// ---------- Factorials and Inverse Factorials ----------
ll fact[N], invfact[N];
void pre_fact(ll n = N-1, ll m = mod) {
    fact[0] = 1;
    for (ll i = 1; i <= n; i++) fact[i] = fact[i-1] * i % m;
    invfact[n] = modinv(fact[n], m);
    for (ll i = n; i > 0; i--) invfact[i-1] = invfact[i] * i % m;
}
// ---------- nCr ----------
ll nCr(ll n, ll r, ll m = mod) {
    if (r < 0 || r > n) return 0;
    return fact[n] * invfact[r] % m * invfact[n-r] % m;
}
// ---------- Sieve of Eratosthenes ----------
vector<ll> primes;
bool is_prime[N];
void sieve(ll n = N-1) {
    fill(is_prime, is_prime + n + 1, true);
    is_prime[0] = is_prime[1] = false;
    for (ll i = 2; i * i <= n; i++) {
        if (is_prime[i]) {
            for (ll j = i * i; j <= n; j += i)
                is_prime[j] = false;
        }
    }
    for (ll i = 2; i <= n; i++)
        if (is_prime[i]) primes.pb(i);
}
vector<int> t, h;

struct UnionFind {
    vector<int> par, sz;
    UnionFind(int n) {
        par.resize(n);
        sz.resize(n, 1);
        iota(all(par), 0);
    }
    int find(int a) {
        if(par[a] == a) return a;
        return par[a] = find(par[a]);
    }
    int unite(int a, int b) {
        a = find(a);
        b = find(b);
        if(a == b) return 0;
        if(sz[a] < sz[b]) swap(a, b);
        par[b] = a;
        sz[a] += sz[b];
        return 1;
    }
};
map<pair<ll, ll>, ll> id;
UnionFind dsu(MAXN);
void initialize(vector<int> T, vector<int> H) {
    t = T; 
    h = H;  
    ll cur = 0;
    FOR(i, 0, t.size()) {
        FOR(j, 0, h.size()) {
            id[{i, j}] = cur++;
        }
    }
    FOR(i, 1, h.size()) {
        if(t[0] > h[i] && t[0] > h[i - 1]) {
            dsu.unite(id[{0, i - 1}], id[{0, i}]);
        }
    }
    FOR(i, 1, t.size()) {
        if(t[i] > h[0] && t[i - 1] > h[0]) {
            dsu.unite(id[{i - 1, 0}], id[{i, 0}]);
        }
    }
    FOR(i, 1, t.size()) {
        FOR(j, 1, h.size()) {
            if(t[i] > h[j] && t[i] > h[j - 1]) {
                dsu.unite(id[{i, j - 1}], id[{i, j}]);
            }
            if(t[i] > h[j] && t[i - 1] > h[j]) {
                dsu.unite(id[{i, j}], id[{i - 1, j}]);
            }
        }
    }
}
bool can_reach(int l, int r, int s, int d) {
    if(dsu.find(id[{0, s}]) == dsu.find(id[{0, d}])) return 1;
    return 0;
}

• Subtask 0: 0 / 0
• Subtask 1: 10 / 10
• Subtask 2: 0 / 14
• Subtask 3: 13 / 13
• Subtask 4: 0 / 21
• Subtask 5: 0 / 25
• Subtask 6: 0 / 17