more files

codeforces/920/e.cc

@@ -0,0 +1,181 @@
+#include <bits/stdc++.h>  // {{{
+
+#include <version>
+#ifdef __cpp_lib_ranges_enumerate
+#include <ranges>
+namespace rv = std::views;
+namespace rs = std::ranges;
+#endif
+
+// https://codeforces.com/blog/entry/96344
+
+#pragma GCC optimize("O2,unroll-loops")
+#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
+
+using namespace std;
+
+using i32 = int32_t;
+using u32 = uint32_t;
+using i64 = int64_t;
+using u64 = uint64_t;
+using f64 = double;
+using f128 = long double;
+
+#if __cplusplus >= 202002L
+template <typename T>
+constexpr T MIN = std::numeric_limits<T>::min();
+
+template <typename T>
+constexpr T MAX = std::numeric_limits<T>::max();
+
+template <typename T>
+[[nodiscard]] static T sc(auto&& x) {
+  return static_cast<T>(x);
+}
+
+template <typename T>
+[[nodiscard]] static T sz(auto&& x) {
+  return static_cast<T>(x.size());
+}
+#endif
+
+static void NO() {
+  std::cout << "NO\n";
+}
+
+static void YES() {
+  std::cout << "YES\n";
+}
+
+template <typename T>
+using vec = std::vector<T>;
+
+#define all(x) (x).begin(), (x).end()
+#define rall(x) (x).rbegin(), (x).rend()
+#define ff first
+#define ss second
+
+#ifdef LOCAL
+#define db(...) std::print(__VA_ARGS__)
+#define dbln(...) std::println(__VA_ARGS__)
+#else
+#define db(...)
+#define dbln(...)
+#endif
+//  }}}
+
+void solve() {
+  i64 n, m;
+  cin >> n >> m;
+
+  i64 ar, ac, br, bc;
+  cin >> ar >> ac >> br >> bc;
+
+  // NOTE: forgot to adjust frontier + 1 (rly think thru!)
+
+  string ans{"Draw"};
+  if (ar < br) {
+    i64 frontier = (u64)ceill((ar + br) / 2.0);
+
+    // NOTE: key is alice gets extra move
+    // TBH, still confused (see mistaken note above) - don't understand
+    // didn't think about "optimal" play - i.e. alice leading one way
+    // can bob just go the opposite? then, alice ought to lead straight
+    // i think if u dig into the logic alice can lead straight in which bob
+    // can't do antyhing, but anyway all of this logic circumvented my mind, smh
+    // NOTE: this is why - SIMPLIFY
+    // simply consider the two player's positions on the frontier row itself -
+    // both on the same alice goes first so she gets extra move if frontier
+    // distance odd also, optimal strategy principle (explore too)
+    i64 aleft = max((i64)1, ac - (frontier - ar));
+    i64 aright = min(m, ac + frontier - ar);
+
+    i64 bleft = max((i64)1, bc - (br - frontier));
+    i64 bright = min(m, bc + (br - frontier));
+
+    bool alice_aggressor = (br - ar) & 1;
+
+    if (alice_aggressor) {
+      if (aleft <= bleft && aright >= bright) {
+        ans = "Alice";
+      }
+    } else {
+      if (bleft <= aleft && bright >= aright) {
+        ans = "Bob";
+      }
+    }
+  }
+
+  println("{}", ans);
+  /*
+
+--A-------
+-A-A------
+BB--------
+B---------
+----------
+----------
+----------
+----------
+----------
+----------
+
+ Alice
+Bob
+Draw
+Draw
+Draw
+Alice
+Draw
+Draw
+Bob
+Alice
+Alice
+Draw
+
+idea: consider frontier
+
+note: ar >= br -> DRAW
+ow, alice below bob, and there is a frontier
+
+alice/bob have frontier pos - enumerate them
+find aggressor - they cannot lose
+
+if aggressor can take all passive piece -> win, print aggressor
+ow, draw
+
+chess moment :sunglasses:
+
+O(h) -> ok
+
+to flesh out:
+
+derive frontier row
+derive a/b cols on row
+derive aggressor
+
+note: only care about the coords
+     */
+}
+
+int main() {  // {{{
+  std::cin.exceptions(std::cin.failbit);
+
+#ifdef LOCAL
+  std::cerr.rdbuf(std::cout.rdbuf());
+  std::cout.setf(std::ios::unitbuf);
+  std::cerr.setf(std::ios::unitbuf);
+#else
+  std::cin.tie(nullptr)->sync_with_stdio(false);
+#endif
+
+  u32 tc = 1;
+  std::cin >> tc;
+
+  for (u32 t = 0; t < tc; ++t) {
+    solve();
+  }
+
+  return 0;
+}
+// }}}