oj.uz

Submission #1054537

# Submission time Handle Problem Language Result Execution time Memory
1054537 2024-08-12T10:32:33 Z Nonoze Mecho (IOI09_mecho) C++17
79 / 100
 667 ms 47356 KB 
/*
*	Author: Nonoze
*	Created: Wednesday 07/08/2024
*/
#include <bits/stdc++.h>
using namespace std;


namespace std {

// https://judge.yosupo.jp/submission/193613
struct IOPre {
    static constexpr int TEN = 10, SZ = TEN * TEN * TEN * TEN;
    std::array<char, 4 * SZ> num;
    constexpr IOPre() : num{} {
        for (int i = 0; i < SZ; i++) for (int n = i, j = 3; j >= 0; j--) num[i * 4 + j] = n % TEN + '0', n /= TEN;
    }
};

struct IO {
#if !HAVE_DECL_FREAD_UNLOCKED
    #define fread_unlocked fread
#endif
#if !HAVE_DECL_FWRITE_UNLOCKED
    #define fwrite_unlocked fwrite
#endif
    static constexpr int SZ = 1 << 17, LEN = 32, TEN = 10, HUNDRED = TEN * TEN,
                         THOUSAND = HUNDRED * TEN, TENTHOUSAND = THOUSAND * TEN,
                         MAGIC_MULTIPLY = 205, MAGIC_SHIFT = 11, MASK = 15,
                         TWELVE = 12, SIXTEEN = 16;
    static constexpr IOPre io_pre = {};
    std::array<char, SZ> input_buffer, output_buffer;
    int input_ptr_left, input_ptr_right, output_ptr_right;

    IO() : input_buffer{}, output_buffer{}, input_ptr_left{}, input_ptr_right{}, output_ptr_right{} {}
    IO(const IO&) = delete;
    IO(IO&&) = delete;
    IO& operator=(const IO&) = delete;
    IO& operator=(IO&&) = delete;
    ~IO() { flush(); }

    template<typename T> static constexpr bool is_char_v    = std::is_same_v<T, char>;
    template<typename T> static constexpr bool is_bool_v    = std::is_same_v<T, bool>;
    template<typename T> static constexpr bool is_string_v  =
            std::is_same_v<T, std::string> || std::is_same_v<T, const char*> ||
            std::is_same_v<T, char*> || std::is_same_v< std::decay_t<T>, char*>;
    template<typename T> static constexpr bool is_default_v =
            is_char_v<T> || is_bool_v<T> || is_string_v<T> || std::is_integral_v<T>;

    inline void load() {
        memmove(std::begin(input_buffer),
                std::begin(input_buffer) + input_ptr_left,
                input_ptr_right - input_ptr_left);
        input_ptr_right =
            input_ptr_right - input_ptr_left +
            fread_unlocked(
                std::begin(input_buffer) + input_ptr_right - input_ptr_left, 1,
                SZ - input_ptr_right + input_ptr_left, stdin);
        input_ptr_left = 0;
    }

    inline void read_char(char& c) {
        if (input_ptr_left + LEN > input_ptr_right) load();
        c = input_buffer[input_ptr_left++];
    }
    inline void read_string(std::string& x) {
        char c;
        while (read_char(c), c < '!') continue;
        x = c;
        while (read_char(c), c >= '!') x += c;
    }
    template<typename T>
    inline std::enable_if_t<std::is_integral_v<T>, void> read_int(T& x) {
        if (input_ptr_left + LEN > input_ptr_right) load();
        char c = 0;
        do c = input_buffer[input_ptr_left++];
        while (c < '-');
        [[maybe_unused]] bool minus = false;
        if constexpr (std::is_signed<T>::value == true)
            if (c == '-') minus = true, c = input_buffer[input_ptr_left++];
        x = 0;
        while (c >= '0')
            x = x * TEN + (c & MASK), c = input_buffer[input_ptr_left++];
        if constexpr (std::is_signed<T>::value == true)
            if (minus) x = -x;
    }

    inline void skip_space() {
        if (input_ptr_left + LEN > input_ptr_right) load();
        while (input_buffer[input_ptr_left] <= ' ') input_ptr_left++;
    }

    inline void flush() {
        fwrite_unlocked(std::begin(output_buffer), 1, output_ptr_right, stdout);
        output_ptr_right = 0;
    }

    inline void write_char(char c) {
        if (output_ptr_right > SZ - LEN) flush();
        output_buffer[output_ptr_right++] = c;
    }

    inline void write_bool(bool b) {
        if (output_ptr_right > SZ - LEN) flush();
        output_buffer[output_ptr_right++] = b ? '1' : '0';
    }

    inline void write_string(const std::string& s) {
        for (auto x : s) write_char(x);
    }

    inline void write_string(const char* s) {
        while (*s) write_char(*s++);
    }

    inline void write_string(char* s) {
        while (*s) write_char(*s++);
    }

    template <typename T>
    inline std::enable_if_t< std::is_integral_v<T>, void> write_int(T x) {
        if (output_ptr_right > SZ - LEN) flush();
        if (!x) {
            output_buffer[output_ptr_right++] = '0';
            return;
        }
        if constexpr (std::is_signed_v<T>) if (x < 0) output_buffer[output_ptr_right++] = '-', x = -x;
        int i = TWELVE;
        std::array<char, SIXTEEN> buf{};
        for (; x >= TENTHOUSAND; x /= TENTHOUSAND, i -= 4)
            memcpy(std::begin(buf) + i, std::begin(io_pre.num) + (x % TENTHOUSAND) * 4, 4);
        if (x < HUNDRED) {
            if (x < TEN) output_buffer[output_ptr_right++] = '0' + x;
            else {
                uint32_t q = (uint32_t(x) * MAGIC_MULTIPLY) >> MAGIC_SHIFT;
                uint32_t r = uint32_t(x) - q * TEN;
                output_buffer[output_ptr_right++] = '0' + q;
                output_buffer[output_ptr_right++] = '0' + r;
            }
        } else {
            if (x < THOUSAND) 
                memcpy(std::begin(output_buffer) + output_ptr_right, std::begin(io_pre.num) + (x << 2) + 1, 3),
                output_ptr_right += 3;
            else
                memcpy(std::begin(output_buffer) + output_ptr_right, std::begin(io_pre.num) + (x << 2), 4),
                output_ptr_right += 4;
        }
        memcpy(std::begin(output_buffer) + output_ptr_right, std::begin(buf) + i + 4, TWELVE - i);
        output_ptr_right += TWELVE - i;
    }

    template <typename T_>
    std::enable_if_t<(is_default_v< std::remove_cv_t< std::remove_reference_t<T_> > >), IO&> operator<<(T_&& x) {
        using T = std::remove_cv_t< std::remove_reference_t<T_> >;
        if constexpr (is_bool_v<T>) write_bool(x);
        else if constexpr (is_string_v<T>) write_string(x);
        else if constexpr (is_char_v<T>) write_char(x);
        else if constexpr (std::is_integral_v<T>) write_int(x);
        return *this;
    }

    template<typename T>
    std::enable_if_t<(is_default_v<T> && !is_bool_v<T>), IO&> operator>>(T& x) {
        if constexpr (is_string_v<T>) read_string(x);
        else if constexpr (is_char_v<T>) read_char(x);
        else if constexpr (std::is_integral_v<T>) read_int(x);
        return *this;
    }

    IO* tie(std::nullptr_t) { return this; }
    void sync_with_stdio(bool) {}
} io;

} // namespace std

using std::io;

#define cin io
#define cout io


#ifndef _IN_LOCAL
	#define dbg(...)
#endif

#define endl '\n'
#define endlfl '\n' << flush
#define quit(x) return (void)(cout << x << endl)

template<typename T> void read(T& x) { cin >> x; }
template<typename T1, typename T2> void read(pair<T1, T2>& p) { read(p.first), read(p.second); }
template<typename T> void read(vector<T>& v) { for (auto& x : v) read(x); }
template<typename T1, typename T2> void read(T1& x, T2& y) { read(x), read(y);}
template<typename T1, typename T2, typename T3> void read(T1& x, T2& y, T3& z) { read(x), read(y), read(z); }
template<typename T1, typename T2, typename T3, typename T4> void read(T1& x, T2& y, T3& z, T4& zz) { read(x), read(y), read(z), read(zz); }
template<typename T> void print(vector<T>& v) { for (auto& x : v) cout << x << ' '; cout << endl; }


#define sz(x) (int)(x.size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define cmin(a, b) a = min(a, b)
#define cmax(a, b) a = max(a, b)

#define int long long
const int inf = numeric_limits<int>::max() / 4;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 1e9+7, LOG=25;



void solve();

signed main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	int tt=1;
	// cin >> tt;
	while(tt--) solve();
	return 0;
}




int n, k, s, t;
vector<int> h;
vector<vector<int>> adj;
vector<bool> bees, visited;

bool propagate(queue<pair<int, pair<int, int>>> &q, bool bee, int comp) {
	int limit=q.front().se.se;
	while (!q.empty() && q.front().se.se<=limit) {
		int u=q.front().fi, nb=q.front().se.fi, time=q.front().se.se; q.pop();
		if (!bee && bees[u]) continue;
		for (auto v: adj[u]) {
			if (!bee && v==t) return 1;
			if (bees[v] || (!bee && visited[v])) continue;
			if (bee) bees[v]=1;
			else visited[v]=1;
			if (nb+1>=comp) q.push({v, {0, time+1}});
			else q.push({v, {nb+1, time}});
		}
	}
	return 0;
}


bool ok(int wait) {
	bees.clear(), visited.clear(), bees.resize(n, 0), visited.resize(n, 0); visited[s]=1; bees[t]=1;
	for (auto u: h) bees[u]=1;
	queue<pair<int, pair<int, int>>> qbees;
	queue<pair<int, pair<int, int>>> q2; q2.push({s, {0, 0}});
	for (auto u: h) qbees.push({u, {0, 0}});
	propagate(qbees, 1, wait);
	while (!q2.empty()) {
		if (propagate(q2, 0, k)) return 1;
		propagate(qbees, 1, 1);
	}
	return 0;
}


void solve() {
	read(n, k);
	vector<string> a(n, string(n, '.')); 
	for (int i=0; i<n; i++) {
		for (int j=0; j<n; j++) cin >> a[i][j];
		char x; cin >> x;
		
	}
	adj.clear(), adj.resize(n*n);
	for (int i=0; i<n; i++) {
		for (int j=0; j<n; j++) {
			if (a[i][j]=='T') continue;
			int act=i*n+j;
			if (i && a[i-1][j]!='T') {
				int nxt=(i-1)*n+j;
				adj[act].pb(nxt), adj[nxt].pb(act);
			}
			if (j && a[i][j-1]!='T') {
				int nxt=i*n+j-1;
				adj[act].pb(nxt), adj[nxt].pb(act);
			}
			if (a[i][j]=='M') s=act;
			if (a[i][j]=='D') t=act;
			if (a[i][j]=='H') h.pb(act);
		}
	}
	n*=n;
	int ans=-1, l=0, r=n/2;
	while (l<=r) {
		int mid=(l+r)/2;
		if (ok(mid)) ans=mid, l=mid+1;
		else r=mid-1;
	}
	cout << ans << endl;
}

Subtask #1
79.0 / 100.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 600 KB Output is correct
2 Correct 0 ms 600 KB Output is correct
3 Correct 0 ms 604 KB Output is correct
4 Correct 0 ms 604 KB Output is correct
5 Incorrect 0 ms 604 KB Output isn't correct
6 Correct 0 ms 604 KB Output is correct
7 Correct 603 ms 46724 KB Output is correct
8 Correct 0 ms 604 KB Output is correct
9 Correct 0 ms 604 KB Output is correct
10 Correct 0 ms 604 KB Output is correct
11 Correct 0 ms 604 KB Output is correct
12 Correct 0 ms 860 KB Output is correct
13 Incorrect 1 ms 860 KB Output isn't correct
14 Correct 1 ms 860 KB Output is correct
15 Correct 0 ms 600 KB Output is correct
16 Correct 0 ms 604 KB Output is correct
17 Correct 1 ms 600 KB Output is correct
18 Correct 0 ms 604 KB Output is correct
19 Correct 0 ms 604 KB Output is correct
20 Correct 0 ms 604 KB Output is correct
21 Correct 0 ms 604 KB Output is correct
22 Correct 1 ms 600 KB Output is correct
23 Correct 0 ms 604 KB Output is correct
24 Correct 0 ms 604 KB Output is correct
25 Correct 1 ms 692 KB Output is correct
26 Correct 1 ms 860 KB Output is correct
27 Correct 1 ms 860 KB Output is correct
28 Correct 1 ms 860 KB Output is correct
29 Correct 1 ms 860 KB Output is correct
30 Correct 1 ms 860 KB Output is correct
31 Correct 1 ms 860 KB Output is correct
32 Correct 1 ms 860 KB Output is correct
33 Correct 17 ms 5564 KB Output is correct
34 Correct 12 ms 5680 KB Output is correct
35 Correct 28 ms 7512 KB Output is correct
36 Correct 22 ms 7004 KB Output is correct
37 Correct 21 ms 7004 KB Output is correct
38 Correct 37 ms 9564 KB Output is correct
39 Correct 29 ms 8796 KB Output is correct
40 Correct 27 ms 8796 KB Output is correct
41 Correct 45 ms 11864 KB Output is correct
42 Correct 36 ms 10844 KB Output is correct
43 Correct 27 ms 10588 KB Output is correct
44 Correct 53 ms 14684 KB Output is correct
45 Correct 44 ms 12892 KB Output is correct
46 Correct 32 ms 12892 KB Output is correct
47 Correct 64 ms 17500 KB Output is correct
48 Correct 51 ms 15192 KB Output is correct
49 Correct 44 ms 15196 KB Output is correct
50 Correct 92 ms 20828 KB Output is correct
51 Correct 61 ms 17756 KB Output is correct
52 Correct 45 ms 17756 KB Output is correct
53 Correct 94 ms 24352 KB Output is correct
54 Correct 73 ms 20316 KB Output is correct
55 Correct 52 ms 20316 KB Output is correct
56 Correct 118 ms 27992 KB Output is correct
57 Correct 83 ms 23276 KB Output is correct
58 Correct 60 ms 23384 KB Output is correct
59 Correct 192 ms 32088 KB Output is correct
60 Correct 97 ms 26456 KB Output is correct
61 Correct 104 ms 26456 KB Output is correct
62 Correct 219 ms 36440 KB Output is correct
63 Incorrect 225 ms 30288 KB Output isn't correct
64 Correct 294 ms 30040 KB Output is correct
65 Correct 273 ms 30040 KB Output is correct
66 Correct 370 ms 30044 KB Output is correct
67 Correct 339 ms 29956 KB Output is correct
68 Incorrect 350 ms 30204 KB Output isn't correct
69 Correct 281 ms 30044 KB Output is correct
70 Correct 314 ms 30044 KB Output is correct
71 Correct 360 ms 30196 KB Output is correct
72 Correct 359 ms 30188 KB Output is correct
73 Correct 448 ms 47148 KB Output is correct
74 Correct 577 ms 47152 KB Output is correct
75 Correct 655 ms 47136 KB Output is correct
76 Correct 632 ms 47356 KB Output is correct
77 Correct 589 ms 47180 KB Output is correct
78 Correct 584 ms 46996 KB Output is correct
79 Correct 534 ms 47108 KB Output is correct
80 Correct 587 ms 47108 KB Output is correct
81 Correct 560 ms 47100 KB Output is correct
82 Correct 583 ms 47100 KB Output is correct
83 Incorrect 641 ms 46896 KB Output isn't correct
84 Correct 573 ms 47144 KB Output is correct
85 Correct 667 ms 47024 KB Output is correct
86 Correct 615 ms 46880 KB Output is correct
87 Correct 609 ms 46888 KB Output is correct
88 Incorrect 649 ms 46836 KB Output isn't correct
89 Correct 560 ms 46676 KB Output is correct
90 Correct 545 ms 46672 KB Output is correct
91 Correct 562 ms 46668 KB Output is correct
92 Correct 653 ms 46912 KB Output is correct