結果

問題 No.1775 Love Triangle 2
ユーザー 👑 hos.lyrichos.lyric
提出日時 2021-12-25 23:02:48
言語 C++14
(gcc 13.2.0 + boost 1.83.0)
結果
AC  
実行時間 112 ms / 8,000 ms
コード長 6,073 bytes
コンパイル時間 1,260 ms
コンパイル使用メモリ 108,100 KB
実行使用メモリ 5,620 KB
最終ジャッジ日時 2023-10-22 03:18:45
合計ジャッジ時間 8,261 ms
ジャッジサーバーID
（参考情報） 		judge13 / judge12
このコードへのチャレンジ（β）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 5 ms
5,580 KB
testcase_01 AC 5 ms
5,580 KB
testcase_02 AC 5 ms
5,580 KB
testcase_03 AC 6 ms
5,580 KB
testcase_04 AC 93 ms
5,584 KB
testcase_05 AC 98 ms
5,584 KB
testcase_06 AC 112 ms
5,584 KB
testcase_07 AC 42 ms
5,608 KB
testcase_08 AC 95 ms
5,584 KB
testcase_09 AC 12 ms
5,620 KB
testcase_10 AC 12 ms
5,620 KB
testcase_11 AC 13 ms
5,620 KB
testcase_12 AC 14 ms
5,620 KB
testcase_13 AC 17 ms
5,616 KB
testcase_14 AC 21 ms
5,616 KB
testcase_15 AC 30 ms
5,612 KB
testcase_16 AC 35 ms
5,612 KB
testcase_17 AC 53 ms
5,604 KB
testcase_18 AC 91 ms
5,588 KB
testcase_19 AC 12 ms
5,620 KB
testcase_20 AC 13 ms
5,620 KB
testcase_21 AC 14 ms
5,620 KB
testcase_22 AC 17 ms
5,620 KB
testcase_23 AC 17 ms
5,620 KB
testcase_24 AC 13 ms
5,620 KB
testcase_25 AC 16 ms
5,620 KB
testcase_26 AC 18 ms
5,616 KB
testcase_27 AC 15 ms
5,620 KB
testcase_28 AC 20 ms
5,616 KB
testcase_29 AC 105 ms
5,580 KB
testcase_30 AC 91 ms
5,588 KB
testcase_31 AC 70 ms
5,596 KB
testcase_32 AC 55 ms
5,604 KB
testcase_33 AC 38 ms
5,608 KB
testcase_34 AC 37 ms
5,608 KB
testcase_35 AC 28 ms
5,612 KB
testcase_36 AC 19 ms
5,616 KB
testcase_37 AC 15 ms
5,620 KB
testcase_38 AC 11 ms
5,620 KB
testcase_39 AC 95 ms
5,588 KB
testcase_40 AC 76 ms
5,592 KB
testcase_41 AC 64 ms
5,600 KB
testcase_42 AC 50 ms
5,604 KB
testcase_43 AC 37 ms
5,608 KB
testcase_44 AC 38 ms
5,608 KB
testcase_45 AC 28 ms
5,612 KB
testcase_46 AC 23 ms
5,616 KB
testcase_47 AC 18 ms
5,616 KB
testcase_48 AC 14 ms
5,620 KB
testcase_49 AC 90 ms
5,584 KB
testcase_50 AC 97 ms
5,588 KB
testcase_51 AC 69 ms
5,596 KB
testcase_52 AC 50 ms
5,604 KB
testcase_53 AC 35 ms
5,608 KB
testcase_54 AC 36 ms
5,608 KB
testcase_55 AC 26 ms
5,612 KB
testcase_56 AC 19 ms
5,616 KB
testcase_57 AC 15 ms
5,620 KB
testcase_58 AC 11 ms
5,620 KB
testcase_59 AC 86 ms
5,588 KB
testcase_60 AC 76 ms
5,592 KB
testcase_61 AC 60 ms
5,600 KB
testcase_62 AC 50 ms
5,604 KB
testcase_63 AC 39 ms
5,608 KB
testcase_64 AC 30 ms
5,612 KB
testcase_65 AC 23 ms
5,616 KB
testcase_66 AC 16 ms
5,616 KB
testcase_67 AC 14 ms
5,620 KB
testcase_68 AC 14 ms
5,620 KB
testcase_69 AC 13 ms
5,620 KB
testcase_70 AC 12 ms
5,620 KB
testcase_71 AC 11 ms
5,620 KB
testcase_72 AC 11 ms
5,620 KB
testcase_73 AC 12 ms
5,620 KB
testcase_74 AC 11 ms
5,620 KB
testcase_75 AC 11 ms
5,620 KB
testcase_76 AC 12 ms
5,620 KB
testcase_77 AC 11 ms
5,620 KB
testcase_78 AC 12 ms
5,620 KB
testcase_79 AC 14 ms
5,620 KB
testcase_80 AC 13 ms
5,620 KB
testcase_81 AC 13 ms
5,620 KB
testcase_82 AC 13 ms
5,620 KB
testcase_83 AC 14 ms
5,620 KB
testcase_84 AC 13 ms
5,620 KB
testcase_85 AC 14 ms
5,620 KB
testcase_86 AC 14 ms
5,620 KB
testcase_87 AC 14 ms
5,620 KB
testcase_88 AC 13 ms
5,620 KB
testcase_89 AC 12 ms
5,620 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


////////////////////////////////////////////////////////////////////////////////
namespace nim {

using u16 = unsigned short;
using u32 = unsigned;
using u64 = unsigned long long;

template <int L> inline u64 mulSlow(u64 a, u64 b) {
  static constexpr int l = L >> 1;
  const u64 a0 = a & ((1ULL << l) - 1), a1 = a >> l;
  const u64 b0 = b & ((1ULL << l) - 1), b1 = b >> l;
  const u64 a0b0 = mulSlow<l>(a0, b0);
  return (a0b0 ^ mulSlow<l>(1ULL << (l - 1), mulSlow<l>(a1, b1)))
      | (a0b0 ^ mulSlow<l>(a0 ^ a1, b0 ^ b1)) << l;
}
template <> inline u64 mulSlow<1>(u64 a, u64 b) {
  return a & b;
}

constexpr u16 G16 = 10279U;
u16 buf[4 * ((1 << 16) - 1) + 26];
u16 *exp = buf + (2 * ((1 << 16) - 1) + 18), *exp3 = exp + 3, *exp6 = exp + 6;
int log[1 << 16];

struct Preparator {
  Preparator() {
    exp[0] = 1;
    for (int i = 1; i < (1 << 16) - 1; ++i) exp[i] = mulSlow<16>(exp[i - 1], G16);
    log[0] = -(((1 << 16) - 1) + 9);
    for (int i = 0; i < (1 << 16) - 1; ++i) log[exp[i]] = i;
    memcpy(exp + ((1 << 16) - 1), exp, ((1 << 16) - 1) * sizeof(u16));
    memcpy(exp + 2 * ((1 << 16) - 1), exp, 8 * sizeof(u16));
  }
} preparator;

inline u16 mul(u16 a, u16 b) {
  return exp[log[a] + log[b]];
}
inline u32 mul(u32 a, u32 b) {
  const u16 a0 = a, a1 = a >> 16;
  const u16 b0 = b, b1 = b >> 16;
  const u16 a01 = a0 ^ a1;
  const u16 b01 = b0 ^ b1;
  const u16 a0b0 = mul(a0, b0);
  return (a0b0 ^ exp3[log[a1] + log[b1]]) | (u32)(a0b0 ^ mul(a01, b01)) << 16;
}
inline u64 mul(u64 a, u64 b) {
  u64 aa = a >> 16, aaa = a >> 32;
  u64 bb = b >> 16, bbb = b >> 32;
  const u16 a0 = a, a1 = aa, a2 = aaa, a3 = a >> 48;
  const u16 b0 = b, b1 = bb, b2 = bbb, b3 = b >> 48;
  aa ^= a; aaa ^= a;
  bb ^= b; bbb ^= b;
  const u16 a01 = aa, a23 = aa >> 32, a02 = aaa, a13 = aaa >> 16;
  const u16 b01 = bb, b23 = bb >> 32, b02 = bbb, b13 = bbb >> 16;
  const u16 a0123 = a01 ^ a23;
  const u16 b0123 = b01 ^ b23;
  const u16 a0b0 = mul(a0, b0), a23b23 = mul(a23, b23), a02b02 = mul(a02, b02);
  const u32 c = (a0b0 ^ exp3[log[a1] + log[b1]]) | (u32)(a0b0 ^ mul(a01, b01)) << 16;
  return (c ^ (exp6[log[mul(a2, b2) ^ a23b23]] | (u32)exp3[log[exp3[log[a3] + log[b3]] ^ a23b23]] << 16))
      | (u64)(c ^ ((a02b02 ^ exp3[log[a13] + log[b13]]) | (u32)(a02b02 ^ mul(a0123, b0123)) << 16)) << 32;
}

}  // namespace nim
////////////////////////////////////////////////////////////////////////////////


unsigned xrand() {
  static unsigned x = 314159265, y = 358979323, z = 846264338, w = 327950288;
  unsigned t = x ^ x << 11; x = y; y = z; z = w; return w = w ^ w >> 19 ^ t ^ t >> 8;
}


using namespace nim;

constexpr int MAX_N = 110;

int N, M;
int X, Y, Z;
vector<int> A, B;

bool adj[MAX_N][MAX_N];

u64 C[MAX_N][MAX_N];
u64 dp[MAX_N][4][MAX_N];
u64 dpY[MAX_N][4][MAX_N];
u64 dpZ[MAX_N][4][MAX_N];

int main() {
  for (; ~scanf("%d%d", &N, &M); ) {
    scanf("%d%d%d", &X, &Y, &Z);
    --X;
    --Y;
    --Z;
    A.resize(M);
    B.resize(M);
    for (int i = 0; i < M; ++i) {
      scanf("%d%d", &A[i], &B[i]);
      --A[i];
      --B[i];
    }
    
    memset(adj, 0, sizeof(adj));
    for (int u = 0; u < N; ++u) for (int v = 0; v < N; ++v) {
      adj[u][v] = (u != v);
    }
    for (int i = 0; i < M; ++i) {
      adj[A[i]][B[i]] = adj[B[i]][A[i]] = false;
    }
    for (int u = 0; u < N; ++u) {
      adj[N][u] = adj[X][u];
      adj[u][N] = adj[u][X];
    }
    
    int ans = N + 1;
    for (int iter = 0; iter < 1; ++iter) {
      memset(C, 0, sizeof(C));
      for (int u = 0; u <= N; ++u) for (int v = u + 1; v <= N; ++v) {
        u64 c = xrand();
        c <<= 32;
        c |= xrand();
        C[u][v] = C[v][u] = c;
      }
      memset(dp, 0, sizeof(dp));
      memset(dpY, 0, sizeof(dpY));
      memset(dpZ, 0, sizeof(dpZ));
      dp[0][0][X] = 1;
      for (int l = 0; l < N; ++l) {
        for (int p = 0; p < 4; ++p) {
          for (int u = 0; u <= N; ++u) {
            for (int v = 0; v <= N; ++v) if (adj[u][v]) {
              const u64 prod = mul(dp[l][p][u], C[u][v]);
              if (v == Y) {
                if (!(p & 1)) {
                  dpY[l + 1][p | 1][u] ^= prod;
                }
              } else if (v == Z) {
                if (!(p & 2)) {
                  dpZ[l + 1][p | 2][u] ^= prod;
                }
              } else {
                dp[l + 1][p][v] ^= prod;
              }
            }
          }
          if (p & 1) {
            u64 sum = 0;
            for (int u = 0; u <= N; ++u) {
              sum ^= dpY[l][p][u];
            }
            for (int u = 0; u <= N; ++u) if (adj[Y][u]) {
              dp[l + 1][p][u] ^= mul(sum ^ dpY[l][p][u], C[Y][u]);
            }
          }
          if (p & 2) {
            u64 sum = 0;
            for (int u = 0; u <= N; ++u) {
              sum ^= dpZ[l][p][u];
            }
            for (int u = 0; u <= N; ++u) if (adj[Z][u]) {
              dp[l + 1][p][u] ^= mul(sum ^ dpZ[l][p][u], C[Z][u]);
            }
          }
        }
      }
      for (int l = 0; l <= N; ++l) {
        if (dp[l][3][N]) {
          chmin(ans, l);
        }
      }
    }
    
    printf("%d\n", (ans >= N + 1) ? -1 : ans);
  }
  return 0;
}
0