답안 #1054576

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
1054576	2024-08-12T10:48:00 Z	Nonoze	Mecho (IOI09_mecho)	C++17	95 / 100	129 ms	39896 KB

mecho

/*
*	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, bees;
vector<vector<int>> adj;
vector<bool> visited;
int ww;

bool propagate(queue<pair<int, pair<int, int>>> &q, 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 (bees[u]<=time+ww+1) continue;
		for (auto v: adj[u]) {
			if (v==t) return 1;
			if (visited[v]) continue;
			visited[v]=1;
			if (nb+1>=comp) q.push({v, {0, time+1}});
			else q.push({v, {nb+1, time}});
		}
	}
	return 0;
}

void precompute() {
	bees.resize(n, 0);
	queue<pair<int, int>> q;
	for (auto u: h) q.push({u, 1});
	while (!q.empty()) {
		int u=q.front().fi, time=q.front().se; q.pop();
		if (bees[u]) continue;
		bees[u]=time;
		for (auto v: adj[u]) q.push({v, time+1});
	}
}


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

95.0 / 100.0

#	결과	실행 시간	메모리	Grader output
1	Correct	1 ms	604 KB	Output is correct
2	Correct	0 ms	604 KB	Output is correct
3	Correct	0 ms	604 KB	Output is correct
4	Correct	0 ms	604 KB	Output is correct
5	Correct	0 ms	604 KB	Output is correct
6	Correct	0 ms	604 KB	Output is correct
7	Correct	100 ms	39192 KB	Output is correct
8	Correct	1 ms	604 KB	Output is correct
9	Correct	1 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	Incorrect	0 ms	860 KB	Output isn't correct
13	Correct	0 ms	860 KB	Output is correct
14	Correct	1 ms	860 KB	Output is correct
15	Correct	0 ms	604 KB	Output is correct
16	Correct	0 ms	604 KB	Output is correct
17	Correct	0 ms	604 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	0 ms	604 KB	Output is correct
23	Correct	0 ms	604 KB	Output is correct
24	Correct	0 ms	600 KB	Output is correct
25	Correct	0 ms	860 KB	Output is correct
26	Correct	0 ms	860 KB	Output is correct
27	Correct	0 ms	860 KB	Output is correct
28	Correct	0 ms	860 KB	Output is correct
29	Correct	0 ms	860 KB	Output is correct
30	Correct	0 ms	860 KB	Output is correct
31	Correct	1 ms	860 KB	Output is correct
32	Correct	0 ms	860 KB	Output is correct
33	Correct	9 ms	6080 KB	Output is correct
34	Correct	6 ms	6132 KB	Output is correct
35	Correct	22 ms	7000 KB	Output is correct
36	Correct	7 ms	7768 KB	Output is correct
37	Correct	7 ms	7592 KB	Output is correct
38	Correct	24 ms	9052 KB	Output is correct
39	Correct	8 ms	9564 KB	Output is correct
40	Correct	9 ms	9564 KB	Output is correct
41	Correct	34 ms	11060 KB	Output is correct
42	Correct	11 ms	11608 KB	Output is correct
43	Correct	11 ms	11580 KB	Output is correct
44	Correct	36 ms	13712 KB	Output is correct
45	Correct	16 ms	14084 KB	Output is correct
46	Correct	13 ms	13912 KB	Output is correct
47	Correct	47 ms	16216 KB	Output is correct
48	Correct	16 ms	16476 KB	Output is correct
49	Correct	16 ms	16616 KB	Output is correct
50	Correct	55 ms	19304 KB	Output is correct
51	Correct	18 ms	19288 KB	Output is correct
52	Correct	23 ms	19288 KB	Output is correct
53	Correct	62 ms	22620 KB	Output is correct
54	Correct	22 ms	22424 KB	Output is correct
55	Correct	20 ms	22364 KB	Output is correct
56	Correct	72 ms	26144 KB	Output is correct
57	Correct	23 ms	25436 KB	Output is correct
58	Correct	24 ms	25436 KB	Output is correct
59	Correct	95 ms	29904 KB	Output is correct
60	Correct	26 ms	28816 KB	Output is correct
61	Correct	26 ms	28976 KB	Output is correct
62	Correct	102 ms	34012 KB	Output is correct
63	Correct	88 ms	30952 KB	Output is correct
64	Correct	124 ms	30860 KB	Output is correct
65	Correct	110 ms	30960 KB	Output is correct
66	Correct	101 ms	30792 KB	Output is correct
67	Correct	87 ms	30808 KB	Output is correct
68	Correct	55 ms	30744 KB	Output is correct
69	Correct	64 ms	30804 KB	Output is correct
70	Correct	47 ms	30808 KB	Output is correct
71	Correct	54 ms	30984 KB	Output is correct
72	Correct	58 ms	30956 KB	Output is correct
73	Correct	87 ms	39668 KB	Output is correct
74	Correct	93 ms	39760 KB	Output is correct
75	Correct	101 ms	39760 KB	Output is correct
76	Correct	98 ms	39792 KB	Output is correct
77	Correct	103 ms	39896 KB	Output is correct
78	Correct	115 ms	39764 KB	Output is correct
79	Correct	89 ms	39764 KB	Output is correct
80	Correct	95 ms	39760 KB	Output is correct
81	Correct	98 ms	39756 KB	Output is correct
82	Correct	94 ms	39764 KB	Output is correct
83	Correct	104 ms	39508 KB	Output is correct
84	Correct	97 ms	39568 KB	Output is correct
85	Correct	105 ms	39508 KB	Output is correct
86	Correct	96 ms	39508 KB	Output is correct
87	Correct	100 ms	39504 KB	Output is correct
88	Correct	101 ms	39252 KB	Output is correct
89	Correct	105 ms	39248 KB	Output is correct
90	Correct	100 ms	39256 KB	Output is correct
91	Correct	100 ms	39416 KB	Output is correct
92	Correct	129 ms	39252 KB	Output is correct