답안 #985087

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
985087	2024-05-17T10:32:35 Z	MegatronRobo	Mecho (IOI09_mecho)	C++17	84 / 100	198 ms	12032 KB

mecho

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

using ll = long long;
using db = long double; // or double, if TL is tight
using str = string; // yay python!

using pi = pair<int,int>;
using pl = pair<ll,ll>;
using pd = pair<db,db>;

using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<db>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;


#define tcT template<class T
#define tcTU tcT, class U

// ^ lol this makes everything look weird but I'll try it
tcT> using V = vector<T>;
tcT, size_t SZ> using AR = array<T,SZ>;
tcT> using PR = pair<T,T>;

// pairs
#define mp make_pair
#define f first
#define s second

// vectors
// oops size(x), rbegin(x), rend(x) need C++17
#define sz(x) int((x).size())
#define bg(x) begin(x)
#define all(x) bg(x), end(x)
#define rall(x) x.rbegin(), x.rend()
#define sor(x) sort(all(x))
#define rsz resize
#define ins insert
#define ft front()
#define bk back()
#define pb push_back
#define eb emplace_back
#define pf push_front
#define rtn return

#define lb lower_bound
#define ub upper_bound
tcT> int lwb(V<T>& a, const T& b) { return int(lb(all(a),b)-bg(a)); }

// loops
#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
#define rep(a) F0R(_,a)
#define each(a,x) for (auto& a: x)

const int MOD = 1e9+7; // 998244353;
const int MX = 2e5+5;
const ll INF = 1e18; // not too close to LLONG_MAX
const db PI = acos((db)-1);
const int dx[4] = {1,0,-1,0}, dy[4] = {0,1,0,-1}; // for every grid problem!!
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
template<class T> using pqg = priority_queue<T,vector<T>,greater<T>>;

// bitwise ops
// also see https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
constexpr int pct(int x) { return __builtin_popcount(x); } // # of bits set
constexpr int bits(int x) { // assert(x >= 0); // make C++11 compatible until USACO updates ...
	return x == 0 ? 0 : 31-__builtin_clz(x); } // floor(log2(x))

constexpr int p2(int x) { return 1<<x; }
constexpr int msk2(int x) { return p2(x)-1; }

ll cdiv(ll a, ll b) { return a/b+((a^b)>0&&a%b); } // divide a by b rounded up
ll fdiv(ll a, ll b) { return a/b-((a^b)<0&&a%b); } // divide a by b rounded down

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; }

tcTU> T fstTrue(T lo, T hi, U f) {
	hi ++; assert(lo <= hi); // assuming f is increasing
	while (lo < hi) { // find first index such that f is true
		T mid = lo+(hi-lo)/2;
		f(mid) ? hi = mid : lo = mid+1;
	}
	return lo;
}

tcTU> T lstTrue(T lo, T hi, U f) {
	lo --; assert(lo <= hi); // assuming f is decreasing
	while (lo < hi) { // find first index such that f is true
		T mid = lo+(hi-lo+1)/2;
		f(mid) ? lo = mid : hi = mid-1;
	}
	return lo;
}

tcT> void remDup(vector<T>& v) { // sort and remove duplicates
	sort(all(v)); v.erase(unique(all(v)),end(v)); }

tcTU> void erase(T& t, const U& u) { // don't erase
	auto it = t.find(u); assert(it != end(t));
	t.erase(it); } // element that doesn't exist from (multi)set

#define tcTUU tcT, class ...U

inline namespace Helpers {
	//////////// is_iterable
	// https://stackoverflow.com/questions/13830158/check-if-a-variable-type-is-iterable
	// this gets used only when we can call begin() and end() on that type
	tcT, class = void> struct is_iterable : false_type {};
	tcT> struct is_iterable<T, void_t<decltype(begin(declval<T>())),
	                                  decltype(end(declval<T>()))
	                                 >
	                       > : true_type {};
	tcT> constexpr bool is_iterable_v = is_iterable<T>::value;

	//////////// is_readable
	tcT, class = void> struct is_readable : false_type {};
	tcT> struct is_readable<T,
	        typename std::enable_if_t<
	            is_same_v<decltype(cin >> declval<T&>()), istream&>
	        >
	    > : true_type {};
	tcT> constexpr bool is_readable_v = is_readable<T>::value;

	//////////// is_printable
	// // https://nafe.es/posts/2020-02-29-is-printable/
	tcT, class = void> struct is_printable : false_type {};
	tcT> struct is_printable<T,
	        typename std::enable_if_t<
	            is_same_v<decltype(cout << declval<T>()), ostream&>
	        >
	    > : true_type {};
	tcT> constexpr bool is_printable_v = is_printable<T>::value;
}


inline namespace Input {
	tcT> constexpr bool needs_input_v = !is_readable_v<T> && is_iterable_v<T>;
	tcTUU> void re(T& t, U&... u);
	tcTU> void re(pair<T,U>& p); // pairs

	// re: read
	tcT> typename enable_if<is_readable_v<T>,void>::type re(T& x) { cin >> x; } // default
	tcT> void re(complex<T>& c) { T a,b; re(a,b); c = {a,b}; } // complex
	tcT> typename enable_if<needs_input_v<T>,void>::type re(T& i); // ex. vectors, arrays
	tcTU> void re(pair<T,U>& p) { re(p.f,p.s); }
	tcT> typename enable_if<needs_input_v<T>,void>::type re(T& i) {
		each(x,i) re(x); }

	tcTUU> void re(T& t, U&... u) { re(t); re(u...); } // read multiple

	// rv: resize and read vectors
	void rv(size_t) {}
	tcTUU> void rv(size_t N, V<T>& t, U&... u);

	template<class...U> void rv(size_t, size_t N2, U&... u);
	tcTUU> void rv(size_t N, V<T>& t, U&... u) {
		t.rsz(N); re(t);
		rv(N,u...); }

	template<class...U> void rv(size_t, size_t N2, U&... u) {
		rv(N2,u...); }

	// dumb shortcuts to read in ints
	void decrement() {} // subtract one from each
	tcTUU> void decrement(T& t, U&... u) { --t; decrement(u...); }
	#define ints(...) int __VA_ARGS__; re(__VA_ARGS__);
	#define int1(...) ints(__VA_ARGS__); decrement(__VA_ARGS__);
}


inline namespace ToString {
	tcT> constexpr bool needs_output_v = !is_printable_v<T> && is_iterable_v<T>;

	// ts: string representation to print
	tcT> typename enable_if<is_printable_v<T>,str>::type ts(T v) {
		stringstream ss; ss << fixed << setprecision(15) << v;
		return ss.str(); } // default

	tcT> str bit_vec(T t) { // bit vector to string
		str res = "{"; F0R(i,sz(t)) res += ts(t[i]);
		res += "}"; return res; }
	str ts(V<bool> v) { return bit_vec(v); }
	template<size_t SZ> str ts(bitset<SZ> b) { return bit_vec(b); } // bit vector
	tcTU> str ts(pair<T,U> p); // pairs
	tcT> typename enable_if<needs_output_v<T>,str>::type ts(T v); // vectors, arrays
	tcTU> str ts(pair<T,U> p) { return "("+ts(p.f)+", "+ts(p.s)+")"; }
	tcT> typename enable_if<is_iterable_v<T>,str>::type ts_sep(T v, str sep) {
		// convert container to string w/ separator sep
		bool fst = 1; str res = "";
		for (const auto& x: v) {
			if (!fst) res += sep;
			fst = 0; res += ts(x);
		}
		return res;
	}
	tcT> typename enable_if<needs_output_v<T>,str>::type ts(T v) {
		return "{"+ts_sep(v,", ")+"}"; }

	// for nested DS
	template<int, class T> typename enable_if<!needs_output_v<T>,vs>::type
	  ts_lev(const T& v) { return {ts(v)}; }
	template<int lev, class T> typename enable_if<needs_output_v<T>,vs>::type
	  ts_lev(const T& v) {
		if (lev == 0 || !sz(v)) return {ts(v)};
		vs res;
		for (const auto& t: v) {
			if (sz(res)) res.bk += ",";
			vs tmp = ts_lev<lev-1>(t);
			res.ins(end(res),all(tmp));
		}
		F0R(i,sz(res)) {
			str bef = " "; if (i == 0) bef = "{";
			res[i] = bef+res[i];
		}
		res.bk += "}";
		return res;
	}
}


inline namespace Output {
	template<class T> void pr_sep(ostream& os, str, const T& t) { os << ts(t); }
	template<class T, class... U> void pr_sep(ostream& os, str sep, const T& t, const U&... u) {
		pr_sep(os,sep,t); os << sep; pr_sep(os,sep,u...); }
	// print w/ no spaces
	template<class ...T> void pr(const T&... t) { pr_sep(cout,"",t...); }

	// print w/ spaces, end with newline
	void ps() { cout << "\n"; }
	template<class ...T> void ps(const T&... t) { pr_sep(cout," ",t...); ps(); }

	// debug to cerr
	template<class ...T> void dbg_out(const T&... t) {
		pr_sep(cerr," | ",t...); cerr << endl; }
	void loc_info(int line, str names) {
		cerr << "Line(" << line << ") -> [" << names << "]: "; }
	template<int lev, class T> void dbgl_out(const T& t) {
		cerr << "\n\n" << ts_sep(ts_lev<lev>(t),"\n") << "\n" << endl; }
	#ifdef LOCAL
		#define dbg(...) loc_info(__LINE__,#__VA_ARGS__), dbg_out(__VA_ARGS__)
		#define dbgl(lev,x) loc_info(__LINE__,#x), dbgl_out<lev>(x)
	#else // don't actually submit with this
		#define dbg(...) 0
		#define dbgl(lev,x) 0
	#endif
}

inline namespace FileIO {
	void setIn(str s)  { freopen(s.c_str(), "r", stdin); }
	void setOut(str s) { freopen(s.c_str(), "w", stdout); }
	void setIO(str s = "") {
		cin.tie(0)->sync_with_stdio(0); // unsync C / C++ I/O streams
		// cin.exceptions(cin.failbit);
		// throws exception when do smth illegal
		// ex. try to read letter into int
		if (sz(s)) setIn(s+".in"), setOut(s+".out"); // for old USACO
	}
}
/*
Binary search on ans
The more the bear waits, more chances of it getting caught, last_true, hi = the time bees took to reach bear's home adjacent cells

1) First we start BFS from bee hives and then determine the time taken to every grid
2) then we do binary search on ans, and assign dist/time to every node as mid+time_now_from_start/S and we will push into queue only when if it is strictly less than bees time taken

*/
int r_change[] = {0, 0, 1, -1};
int c_change[] = {1, -1, 0, 0};
int main(){
    int n, sp;
    cin>>n>>sp;

    V<string> grid(n);
    V<pi> hives;
    pi mecho, home;
    FOR(i, 0, n){
        string s;
        cin>>s;
        FOR(j, 0, n){
            if(s[j]=='M'){
                mecho={i, j};
            }else if(s[j]=='D'){
                home = {i, j};
            }else if(s[j]=='H'){
                hives.pb({i, j});
            }
        }
        grid[i]=s;
    }

    // starting BFS from hives to determing the dist to every grid

    V<vpi> dist(n, vpi(n, {INT_MAX, INT_MAX})); // first for bear and second for bee hives
    queue<pi> q;
    each(t, hives){
        q.push(t);
        dist[t.f][t.s].s = 0;
    }
    while(!q.empty()){
        const auto [r, c] = q.ft;
        q.pop();

        FOR(i, 0, 4){
            int new_r = r+r_change[i];
            int new_c = c+c_change[i];

            if(new_r < 0 || new_r >= n || new_c < 0 || new_c >= n || dist[new_r][new_c].s != INT_MAX || grid[new_r][new_c]=='T')
                continue;
            q.push({new_r, new_c});
            dist[new_r][new_c].s = dist[r][c].s+1;
        }
    }
    dist[home.f][home.s].s = INT_MAX;

    // determining max time it took for bees to reach home adjacent cells
    int time_took_max = 0;
    FOR(i, 0, 4){
        if(home.f+r_change[i] < 0 || home.f+r_change[i] >= n || home.s+c_change[i] < 0 || home.s+c_change[i] >= n || dist[home.f+r_change[i]][home.s+c_change[i]].s == INT_MAX)
            continue;
        time_took_max = max(time_took_max, dist[home.f+r_change[i]][home.s+c_change[i]].s);
    }

    // last_true
    int lo=-1, hi=time_took_max;
    while(lo<hi){
        int mid=lo+(hi-lo+1)/2;
        // to check if bear is able to escape if it waits this much time
        FOR(i, 0, n){
            FOR(j, 0, n){
                dist[i][j].f = INT_MAX;
            }
        }
        dist[mecho.f][mecho.s].f = 0;
        V<V<double>> pup(n, V<double>(n, INT_MAX));
        pup[mecho.f][mecho.s] = mid;

        q.push(mecho);
        while(!q.empty()){
            const auto [r, c] = q.ft;
            q.pop();

            FOR(i, 0, 4){
                int new_r = r+r_change[i];
                int new_c = c+c_change[i];

                if(new_r < 0 || new_r >= n || new_c < 0 || new_c >= n || dist[new_r][new_c].f != INT_MAX || grid[new_r][new_c]=='T' || (float)mid+(float)(dist[r][c].f+1)/(float)sp>=dist[new_r][new_c].s){
                    continue;
                }
                q.push({new_r, new_c});
                pup[new_r][new_c] = (float)mid+(float)(dist[r][c].f+1)/(float)sp;
                dist[new_r][new_c].f = dist[r][c].f+1;  
            }         
        }
        // cout<<endl;
        // cout<<"mid: "<<mid<<endl;
        // FOR(i, 0, n){
        //     FOR(j, 0, n){
        //         if(pup[i][j]==INT_MAX)
        //             cout<<-1<<" ";
        //         else{
        //             cout<<setprecision(2);
        //             cout<<pup[i][j]<<" ";
        //         }
        //     }
        //     cout<<endl;
        // }
        // cout<<endl;
        // FOR(i, 0, n){
        //     FOR(j, 0, n){   
        //         if(dist[i][j].f==INT_MAX)
        //             cout<<-1<<" ";
        //         else
        //             cout<<dist[i][j].f<<" ";
        //     }
        //     cout<<endl;
        // }
        // cout<<endl;
        // FOR(i, 0, n){
        //     FOR(j, 0, n){   
        //         if(dist[i][j].s==INT_MAX)
        //             cout<<-1<<" ";
        //         else
        //             cout<<dist[i][j].s<<" ";
        //     }
        //     cout<<endl;
        // }
        bool possible = false;
        FOR(i, 0, 4){
            int new_r=home.f+r_change[i], new_c=home.s+c_change[i];
            if(new_r < 0 || new_r >= n || new_c < 0 || new_c >= n || pup[new_r][new_c] == INT_MAX)
                continue;
            possible = true;
            break;
        }
        if(possible){
            // possible to reach
            lo=mid;
        }else{
            hi=mid-1;
        }
    }
    cout<<lo<<endl;
}

Compilation message

mecho.cpp: In function 'void FileIO::setIn(str)':
mecho.cpp:261:30: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  261 |  void setIn(str s)  { freopen(s.c_str(), "r", stdin); }
      |                       ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~
mecho.cpp: In function 'void FileIO::setOut(str)':
mecho.cpp:262:30: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  262 |  void setOut(str s) { freopen(s.c_str(), "w", stdout); }
      |                       ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~

Subtask #1

84.0 / 100.0

#	결과	실행 시간	메모리	Grader output
1	Correct	1 ms	344 KB	Output is correct
2	Correct	1 ms	348 KB	Output is correct
3	Correct	1 ms	344 KB	Output is correct
4	Correct	1 ms	348 KB	Output is correct
5	Correct	1 ms	348 KB	Output is correct
6	Correct	1 ms	348 KB	Output is correct
7	Correct	68 ms	11152 KB	Output is correct
8	Correct	1 ms	348 KB	Output is correct
9	Correct	0 ms	440 KB	Output is correct
10	Correct	0 ms	348 KB	Output is correct
11	Correct	1 ms	348 KB	Output is correct
12	Incorrect	1 ms	348 KB	Output isn't correct
13	Incorrect	1 ms	348 KB	Output isn't correct
14	Correct	1 ms	348 KB	Output is correct
15	Correct	0 ms	348 KB	Output is correct
16	Correct	1 ms	348 KB	Output is correct
17	Correct	1 ms	348 KB	Output is correct
18	Correct	1 ms	348 KB	Output is correct
19	Correct	1 ms	348 KB	Output is correct
20	Correct	1 ms	348 KB	Output is correct
21	Correct	0 ms	348 KB	Output is correct
22	Correct	1 ms	348 KB	Output is correct
23	Correct	1 ms	348 KB	Output is correct
24	Correct	0 ms	348 KB	Output is correct
25	Correct	1 ms	344 KB	Output is correct
26	Correct	1 ms	344 KB	Output is correct
27	Correct	1 ms	348 KB	Output is correct
28	Correct	1 ms	348 KB	Output is correct
29	Correct	1 ms	348 KB	Output is correct
30	Correct	1 ms	348 KB	Output is correct
31	Correct	1 ms	348 KB	Output is correct
32	Correct	1 ms	348 KB	Output is correct
33	Correct	9 ms	2588 KB	Output is correct
34	Correct	10 ms	2612 KB	Output is correct
35	Correct	10 ms	2612 KB	Output is correct
36	Correct	12 ms	3260 KB	Output is correct
37	Correct	12 ms	3328 KB	Output is correct
38	Correct	15 ms	3392 KB	Output is correct
39	Correct	22 ms	4024 KB	Output is correct
40	Correct	17 ms	4060 KB	Output is correct
41	Correct	18 ms	4028 KB	Output is correct
42	Correct	20 ms	4880 KB	Output is correct
43	Correct	19 ms	4884 KB	Output is correct
44	Correct	20 ms	4844 KB	Output is correct
45	Correct	23 ms	5780 KB	Output is correct
46	Correct	28 ms	5788 KB	Output is correct
47	Correct	25 ms	5764 KB	Output is correct
48	Correct	27 ms	6764 KB	Output is correct
49	Correct	33 ms	6732 KB	Output is correct
50	Correct	32 ms	6704 KB	Output is correct
51	Correct	47 ms	7952 KB	Output is correct
52	Correct	35 ms	7812 KB	Output is correct
53	Correct	39 ms	7808 KB	Output is correct
54	Correct	42 ms	9040 KB	Output is correct
55	Correct	41 ms	9060 KB	Output is correct
56	Correct	49 ms	8904 KB	Output is correct
57	Correct	50 ms	10260 KB	Output is correct
58	Correct	44 ms	10332 KB	Output is correct
59	Correct	64 ms	10224 KB	Output is correct
60	Correct	51 ms	11784 KB	Output is correct
61	Correct	56 ms	11668 KB	Output is correct
62	Correct	77 ms	11560 KB	Output is correct
63	Correct	107 ms	11624 KB	Output is correct
64	Correct	158 ms	11516 KB	Output is correct
65	Correct	198 ms	11636 KB	Output is correct
66	Correct	163 ms	11596 KB	Output is correct
67	Correct	118 ms	11624 KB	Output is correct
68	Correct	62 ms	11656 KB	Output is correct
69	Correct	64 ms	11632 KB	Output is correct
70	Correct	54 ms	11668 KB	Output is correct
71	Correct	53 ms	11688 KB	Output is correct
72	Incorrect	47 ms	11668 KB	Output isn't correct
73	Incorrect	42 ms	11652 KB	Output isn't correct
74	Correct	63 ms	11688 KB	Output is correct
75	Correct	82 ms	11744 KB	Output is correct
76	Correct	68 ms	11684 KB	Output is correct
77	Correct	61 ms	11712 KB	Output is correct
78	Correct	69 ms	11652 KB	Output is correct
79	Correct	60 ms	11676 KB	Output is correct
80	Correct	75 ms	11640 KB	Output is correct
81	Correct	72 ms	11560 KB	Output is correct
82	Correct	69 ms	11668 KB	Output is correct
83	Correct	88 ms	11664 KB	Output is correct
84	Correct	68 ms	11484 KB	Output is correct
85	Correct	63 ms	11644 KB	Output is correct
86	Correct	84 ms	11740 KB	Output is correct
87	Correct	82 ms	12032 KB	Output is correct
88	Correct	74 ms	11660 KB	Output is correct
89	Correct	69 ms	11648 KB	Output is correct
90	Correct	73 ms	11664 KB	Output is correct
91	Correct	75 ms	11616 KB	Output is correct
92	Correct	63 ms	11668 KB	Output is correct