Illuminati

input/code.cpp: In function 'int main()':
input/code.cpp:23:40: warning: comparison of integer expressions of different signedness: 'size_t' {aka 'long unsigned int'} and 'll' {aka 'long long int'} [-Wsign-compare]
   23 | #define fr(i,a,b) for (size_t i = a; i < b; i++)
      |                                        ^
input/code.cpp:148:3: note: in expansion of macro 'fr'
  148 |   fr(i, 0, n) {
      |   ^~
input/code.cpp:23:40: warning: comparison of integer expressions of different signedness: 'size_t' {aka 'long unsigned int'} and 'll' {aka 'long long int'} [-Wsign-compare]
   23 | #define fr(i,a,b) for (size_t i = a; i < b; i++)
      |                                        ^
input/code.cpp:149:5: note: in expansion of macro 'fr'
  149 |     fr(j, 0, n) {
      |     ^~
input/code.cpp:23:40: warning: comparison of integer expressions of different signedness: 'size_t' {aka 'long unsigned int'} and 'll' {aka 'long long int'} [-Wsign-compare]
   23 | #define fr(i,a,b) for (size_t i...

// clang-format off
#include <bits/stdc++.h>
#include <unordered_map>
using namespace std;
#ifdef DO_DBG
template<typename A, typename B> ostream& operator<<(ostream &os, const pair<A, B> &p) { return os << '(' << p.first << ", " << p.second << ')'; }
template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> ostream& operator<<(ostream &os, const T_container &v) { os << '{'; string sep; for (const T &x : v) os << sep << x, sep = ", "; return os << '}'; }
void dbg_out() { cerr << endl; }
template<typename Head, typename... Tail> void dbg_out(Head H, Tail... T) { cerr << ' ' << H; dbg_out(T...); }
#define dbg(...) cerr << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)
#define dout cerr
#define debug true
#else
#define dbg(...)
#define dout if (0) cerr
#define debug false
#endif
typedef long long ll; typedef unsigned long long ull; typedef long double ld;
template <typename T> using v = vector<T>; template <typename T> using us = unordered_set<T>; template <typename K, typename V> using p = pair<K,V>;
template <typename K, typename V> using um = unordered_map<K, V>; template <typename K, typename V> using p = pair<K, V>;
template <typename T> using pq = priority_queue<T>; template <typename T> using nl = numeric_limits<T>; template <typename T> using il = initializer_list<T>;
constexpr int MOD = 1e9 + 7; constexpr int INF = 1e9; constexpr ld EPS = 1e-9;
#define fr(i,a,b) for (size_t i = a; i < b; i++)
#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); cin.exceptions(cin.failbit);
#define frr(i,a,b) for (size_t i = b-1; i >= a; i--)
#define frs(i,a,b) for (ll i = a; i < b; i++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define sq(x) ((x) * (x))
template <typename... Args> void read(Args&... args) { ((cin >> args), ...); }
#define d(...) int __VA_ARGS__; read(__VA_ARGS__);
#define dll(...) ll __VA_ARGS__; read(__VA_ARGS__);
#define dv(x, n) vector<int> x(n); for (int i = 0; i < n; i++) cin >> x[i];
#define dvll(x, n) vector<long long> x(n); for (int i = 0; i < n; i++) cin >> x[i];
#define dvd(x, n) vector<double> x(n); for (int i = 0; i < n; i++) cin >> x[i];
ll ipow(ll a,int b){ll r=1;for(;b;b>>=1,a*=a)if(b&1)r*=a;return r;}
template<class F>struct y_combinator{F f;template<class...Args>decltype(auto)operator()(Args&&...args)const{return f(*this,forward<Args>(args)...);}};
constexpr auto get_nums=[]<typename T>(T&&s){istringstream iss(forward<T>(s));return vector<int>{istream_iterator<int>{iss},{}};};
// clang-format on
template <typename T = int> struct Pos {
  T x, y;
  T &r = x;
  T &c = y;
  Pos() = default;
  Pos(T x_, T y_) : x(x_), y(y_), r(x), c(y) {}
  Pos(const Pos &o) : x(o.x), y(o.y), r(x), c(y) {}
  Pos &operator=(const Pos &o) {
    x = o.x;
    y = o.y;
    return *this;
  }
  auto operator<=>(const Pos<T> &) const = default;
  bool operator==(const Pos &o) const { return x == o.x && y == o.y; }
  Pos operator+(const Pos &o) const { return {x + o.x, y + o.y}; }
  Pos operator-(const Pos &o) const { return {x - o.x, y - o.y}; }
  Pos operator*(T k) const { return {x * k, y * k}; }
  Pos &operator+=(const Pos &o) {
    x += o.x;
    y += o.y;
    return *this;
  }
  Pos &operator-=(const Pos &o) {
    x -= o.x;
    y -= o.y;
    return *this;
  }
  Pos operator%(T k) const { return {x % k, y % k}; }
  Pos &operator%=(T k) {
    x %= k;
    y %= k;
    return *this;
  }
  Pos operator%(const Pos &o) const { return {x % o.x, y % o.y}; }
  Pos &operator%=(const Pos &o) {
    x %= o.x;
    y %= o.y;
    return *this;
  }
  Pos &operator*=(T k) {
    x *= k;
    y *= k;
    return *this;
  }
  friend ostream &operator<<(ostream &os, const Pos<T> &p) {
    return os << '(' << p.x << ", " << p.y << ')';
  }
};
template <size_t I, typename T> decltype(auto) get(Pos<T> &p) {
  if constexpr (I == 0)
    return (p.x);
  else
    return (p.y);
}
template <size_t I, typename T> decltype(auto) get(const Pos<T> &p) {
  if constexpr (I == 0)
    return (p.x);
  else
    return (p.y);
}
template <size_t I, typename T> decltype(auto) get(Pos<T> &&p) {
  if constexpr (I == 0)
    return std::move(p.x);
  else
    return std::move(p.y);
}
template <size_t I, typename T> decltype(auto) get(const Pos<T> &&p) {
  if constexpr (I == 0)
    return std::move(p.x);
  else
    return std::move(p.y);
}

namespace std {
template <typename T> struct hash<Pos<T>> {
  size_t operator()(const Pos<T> &p) const noexcept {
    size_t h1 = hash<T>{}(p.x);
    size_t h2 = hash<T>{}(p.y);
    return h1 ^ (h2 + 0x9e3779b9 + (h1 << 6) + (h1 >> 2));
  }
};
template <size_t I, typename T> decltype(auto) get(Pos<T> &p) {
  if constexpr (I == 0)
    return (p.x);
  else
    return (p.y);
}
template <size_t I, typename T> decltype(auto) get(const Pos<T> &p) {
  if constexpr (I == 0)
    return (p.x);
  else
    return (p.y);
}
template <typename T>
struct tuple_size<Pos<T>> : std::integral_constant<size_t, 2> {};
template <typename T> struct tuple_element<0, Pos<T>> {
  using type = T;
};
template <typename T> struct tuple_element<1, Pos<T>> {
  using type = T;
};
} // namespace std

int main() {
  // fastio;
  dll(n);
  v<string> a{istream_iterator<string>{cin}, {}};
  v<us<ll>> adj(n);
  fr(i, 0, n) {
    fr(j, 0, n) {
      if (a[i][j] == '1') {
        adj[i].insert(j);
      }
    }
  }
  v<us<Pos<ll>>> cycles(n);
  // easy way to find out if a cycle exists eg. 13 23 4. order the numbers i.e.
  // 4 13 23 and check if cycles[4].contains({13,23});
  //
  //
  // for each pin
  fr(i, 0, n) {
    fr(j, 0, n) {
      if (a[i][j] != '1')
        continue;
      fr(k, 0, n) {
        if (adj[i].contains(k) && adj[j].contains(k)) {

          ll x = i, y = j, c = k;
          // we have found a cycle
          if (x > y) {
            swap(x, y);
          }
          if (y > c) {
            swap(y, c);
          }
          if (x > y) {
            swap(x, y);
          }
          cycles[x].insert({y, c});
        }
      }
      // is there something shared between
    }
  }

  // fr(i, 0, n) {
  //   // for a pin we check all of its neighbours
  //   for (auto j : adj[i]) {
  //     // and its neighbors
  //     for (auto k : adj[j]) {
  //       if (a[k][i] == '1') {
  //       }
  //     }
  //   }
  // }
  // dbg(cycles);
  ll count = 0;
  fr(i, 0, n) { count += cycles[i].size(); }
  cout << count << '\n';
}

Test 1

Verdict: ACCEPTED

Test 2

Verdict: ACCEPTED

Test 3

Verdict: ACCEPTED

Test 4

Verdict: ACCEPTED

Test 5

Verdict: ACCEPTED

Test 6

Verdict: ACCEPTED

Test 7

Verdict: ACCEPTED

Test 8

Verdict: ACCEPTED

Test 9

Verdict: ACCEPTED

Test 10

Verdict: ACCEPTED

Test 11

Verdict: ACCEPTED

Test 12

Verdict: ACCEPTED

Test 13

Verdict: ACCEPTED

Test 14

Verdict: ACCEPTED

Test 15

Verdict: ACCEPTED

Test 16

Verdict: ACCEPTED

Test 17

Verdict: ACCEPTED

Test 18

Verdict: ACCEPTED

Test 19

Verdict: ACCEPTED

Test 20

Verdict: ACCEPTED

Test 21

Verdict: ACCEPTED

Test 22

Verdict: ACCEPTED

Test 23

Verdict: ACCEPTED

Test 24

Verdict: ACCEPTED

Test 25

Verdict: ACCEPTED

Test 26

Verdict: ACCEPTED

Test 27

Verdict: ACCEPTED

Test 28

Verdict: ACCEPTED

Test 29

Verdict: ACCEPTED

Test 30

Verdict: ACCEPTED

Test 31

Verdict: ACCEPTED

Test 32

Verdict: ACCEPTED

Test 33

Verdict: ACCEPTED

Test 34

Verdict: ACCEPTED

Test 35

Verdict: ACCEPTED

Test 36

Verdict: ACCEPTED

Test 37

Verdict: ACCEPTED

Test 38

Verdict: ACCEPTED

Test 39

Verdict: ACCEPTED

Test 40

Verdict: ACCEPTED

Test 41

Verdict: ACCEPTED

Test 42

Verdict: ACCEPTED

Test 43

Verdict: ACCEPTED

Test 44

Verdict: ACCEPTED

Test 45

Verdict: ACCEPTED

Test 46

Verdict: ACCEPTED

Test 47

Verdict: ACCEPTED

Test 48

Verdict: TIME LIMIT EXCEEDED

Test 49

Verdict: TIME LIMIT EXCEEDED

Test 50

Verdict: TIME LIMIT EXCEEDED

Test 51

Verdict: TIME LIMIT EXCEEDED

Test 52

Verdict: TIME LIMIT EXCEEDED

Test 53

Verdict: TIME LIMIT EXCEEDED