#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); }
| ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
| # |
Verdict |
Execution time |
Memory |
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 |
