Submission #679635

#	Time	Username	Problem	Language	Result	Execution time	Memory
679635		peijar	Three Friends (BOI14_friends)	C++17	35 / 100	612 ms	31776 KiB

friends

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

namespace std {
template <typename T> ostream &operator<<(ostream &out, const vector<T> &vec) {
  out << "[";
  for (int i = 0; i < (int)vec.size(); ++i) {
    out << vec[i];
    if (i + 1 < (int)vec.size())
      out << ", ";
  }
  return out << "]";
}
} // namespace std

void dbg_out() { cout << endl; }
template <typename Head, typename... Tail> void dbg_out(Head H, Tail... T) {
  cout << ' ' << H;
  dbg_out(T...);
}

#ifdef DEBUG
#define dbg(...) cout << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)
#else
#define dbg(...)
#endif

template <const int32_t MOD> struct ModInt {
  int32_t x;
  ModInt() : x(0) {}
  ModInt(long long u) : x(u % MOD) {
    if (x < 0)
      x += MOD;
  }
  friend bool operator==(const ModInt &a, const ModInt &b) {
    return a.x == b.x;
  }
  friend bool operator!=(const ModInt &a, const ModInt &b) {
    return a.x != b.x;
  }
  friend bool operator<(const ModInt &a, const ModInt &b) { return a.x < b.x; }
  friend bool operator>(const ModInt &a, const ModInt &b) { return a.x > b.x; }
  friend bool operator<=(const ModInt &a, const ModInt &b) {
    return a.x <= b.x;
  }
  friend bool operator>=(const ModInt &a, const ModInt &b) {
    return a.x >= b.x;
  }
  static ModInt sign(long long k) {
    return ((k & 1) ? ModInt(MOD - 1) : ModInt(1));
  }

  ModInt &operator+=(const ModInt &m) {
    x += m.x;
    if (x >= MOD)
      x -= MOD;
    return *this;
  }
  ModInt &operator-=(const ModInt &m) {
    x -= m.x;
    if (x < 0LL)
      x += MOD;
    return *this;
  }
  ModInt &operator*=(const ModInt &m) {
    x = (1LL * x * m.x) % MOD;
    return *this;
  }

  friend ModInt operator-(const ModInt &a) {
    ModInt res(a);
    if (res.x)
      res.x = MOD - res.x;
    return res;
  }
  friend ModInt operator+(const ModInt &a, const ModInt &b) {
    return ModInt(a) += ModInt(b);
  }
  friend ModInt operator-(const ModInt &a, const ModInt &b) {
    return ModInt(a) -= ModInt(b);
  }
  friend ModInt operator*(const ModInt &a, const ModInt &b) {
    return ModInt(a) *= ModInt(b);
  }

  static long long fp(long long u, long long k) {
    long long res = 1LL;
    while (k > 0LL) {
      if (k & 1LL)
        res = (res * u) % MOD;
      u = (u * u) % MOD;
      k /= 2LL;
    }
    return res;
  }

  static constexpr int mod() { return MOD; }

  ModInt fastpow(long long k) { return ModInt(fp(x, k)); }
  ModInt inv() {
    assert(x);
    return ModInt(fp(x, MOD - 2));
  }
  ModInt &operator/=(const ModInt &m) { return *this *= ModInt(m).inv(); }
  friend ModInt operator/(const ModInt &a, const ModInt &b) {
    return ModInt(a) *= ModInt(b).inv();
  }

  friend ostream &operator<<(ostream &out, const ModInt &a) {
    return out << a.x;
  }
  friend istream &operator>>(istream &in, ModInt &a) { return in >> a.x; }
};

const int MOD1 = 1e9 + 9, MOD2 = 1e9 + 7;

template <typename T1, typename T2> struct ModPair {
  T1 x;
  T2 y;

  ModPair() : x(0), y(0) {}

  ModPair(int u) : x(u), y(u) {}

  ModPair(T1 _x, T2 _y) : x(_x), y(_y) {}

  ModPair &operator+=(const ModPair &other) {
    x += other.x;
    y += other.y;
    return *this;
  }

  ModPair &operator*=(const ModPair &other) {
    x *= other.x;
    y *= other.y;
    return *this;
  }

  ModPair &operator-=(const ModPair &other) {
    x -= other.x;
    y -= other.y;
    return *this;
  }

  friend ModPair operator+(const ModPair &a, const ModPair &b) {
    return ModPair(a) += ModPair(b);
  }
  friend ModPair operator-(const ModPair &a, const ModPair &b) {
    return ModPair(a) -= ModPair(b);
  }
  friend ModPair operator*(const ModPair &a, const ModPair &b) {
    return ModPair(a) *= ModPair(b);
  }

  bool operator<(const ModPair &o) const { return pair(x, y) < pair(o.x, o.y); }
  bool operator>(const ModPair &o) const { return pair(x, y) > pair(o.x, o.y); }
  bool operator<=(const ModPair &o) const {
    return pair(x, y) <= pair(o.x, o.y);
  }
  bool operator>=(const ModPair &o) const {
    return pair(x, y) >= pair(o.x, o.y);
  }
  bool operator==(const ModPair &o) const {
    return pair(x, y) == pair(o.x, o.y);
  }

  ModPair inv() { return ModPair(x.inv(), y.inv()); };
};

using H = ModInt<MOD1>;
// using H = ModPair<ModInt<MOD1>, ModInt<MOD2>>;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int randint(int lb, int ub) {
  return uniform_int_distribution<int>(lb, ub)(rng);
}
const H base = randint(1e3, 1e4);

struct SuffixArray {
  vector<H> po, pref, invPo;

  string s;
  SuffixArray(string &_s) {
    s = _s;
    int N = s.size();
    po.resize(N + 1);
    invPo.resize(N + 1);
    pref.resize(N + 1);
    po[0] = 1;
    for (int i = 1; i <= N; ++i)
      po[i] = base * po[i - 1];
    invPo[N] = po[N].inv();
    for (int i = N; i; --i)
      invPo[i - 1] = base * invPo[i];
    for (int i = 0; i < N; ++i)
      pref[i + 1] = pref[i] + s[i] * po[i];
  }

  H getHsh(int deb, int fin) { return (pref[fin] - pref[deb]) * invPo[deb]; }

  int getLCP(int i, int j) {
    if (i == j)
      return s.size() - i;
    int lcp = 0;
    for (int p = 20; p >= 0; --p)
      if (i + (1 << p) <= (int)s.size() and j + (1 << p) <= (int)s.size() and
          getHsh(i, i + (1 << p)) == getHsh(j, j + (1 << p)))
        i += 1 << p, j += 1 << p, lcp += 1 << p;
    return lcp;
  }
};

bool get(string U) {
  int N = U.size() / 2;
  SuffixArray suffix(U);
  for (int skip = N; skip < 2 * N + 1; ++skip) {
    if (suffix.getLCP(0, N) < skip - N)
      continue;
    if (skip < 2 * N and suffix.getLCP(skip - N, skip + 1) < N - (skip - N))
      continue;
    return true;
  }
  return false;
}

signed main(void) {
  ios_base::sync_with_stdio(false);
  cin.tie(0);

  int N;
  string U;
  cin >> N >> U;

  if (N % 2 == 0) {
    cout << "NOT POSSIBLE\n";
    return 0;
  }

  string T = U;
  reverse(T.begin(), T.end());
  bool okL = get(U);
  bool okR = get(T);
  N /= 2;
  string L = U.substr(0, N);
  string R = U.substr(N + 1, N);
  dbg(L, R);
  dbg(okL, okR);

  if (!okL and !okR) {
    cout << "NOT POSSIBLE\n";
    return 0;
  }
  if (okL and okR and L != R) {
    cout << "NOT UNIQUE\n";
    return 0;
  }
  cout << (okL ? L : R) << endl;
}

• Subtask 1: 35 / 35
• Subtask 2: 0 / 65