maxclique dyn

#include <algorithm>
#include <cassert>
#include <bitset>
#include <numeric>
#include <vector>

const int kN = 100;
const double kT = 0.025;
int s[kN + 1], t[kN + 1], deg[kN], steps;
std::bitset<kN> Q, Qmax;
std::vector<int> z[kN];
std::bitset<kN> adj[kN];

std::vector<int> ColorSort(std::vector<int> &R) {
  int kmin = Qmax.count() - Q.count() + 1;
  if (kmin < 1) kmin = 1;
  int kmax = 1;
  int j = 0;
  z[1].clear(), z[2].clear();
  for (int i = 0; i < R.size(); ++i) {
    int p = R[i];
    int k = 1;
    while (true) {
      bool tc = false;
      for (int u : z[k]) tc |= adj[p].test(u);
      if (tc)
        ++k;
      else
        break;
    }
    if (k > kmax) {
      kmax = k;
      z[kmax + 1].clear();
    }
    z[k].push_back(p);
    if (k < kmin) R[j++] = R[i];
  }
  std::vector<int> C(R.size());
  if (j > 0) C[j - 1] = 0;
  for (int k = kmin; k <= kmax; ++k) {
    for (int u : z[k]) {
      assert(j < R.size());
      R[j] = u;
      C[j] = k;
      j++;
    }
  }
  return C;
}

void MaxCliqueDyn(const std::vector<int> &R, const std::vector<int> &C,
                  int depth) {
  s[depth] += s[depth - 1] - t[depth];
  t[depth] = s[depth - 1];
  for (int i = R.size() - 1; i >= 0; --i) {
    int p = R[i];
    if (Q.count() + C[i] > Qmax.count()) {
      Q.set(p);
      bool ok = false;
      std::vector<int> v;
      for (int j = 0; !ok && j < i; ++j) {
        if (adj[p].test(R[j])) v.push_back(R[j]);
      }
      if (!v.empty()) {
        if (s[depth] < kT * steps) {
          for (int j = 0; j < v.size(); ++j) deg[v[j]] = 0;
          for (int j = 0; j < v.size(); ++j) {
            for (int k = 0; k < v.size(); ++k) {
              if (adj[v[j]].test(v[k])) deg[v[j]]++;
            }
          }
          std::sort(v.begin(), v.end(),
                    [&](int x, int y) { return deg[x] > deg[y]; });
        }
        auto Cp = ColorSort(v);
        s[depth]++;
        steps++;
        MaxCliqueDyn(v, Cp, depth + 1);
      } else if (Q.count() > Qmax.count()) {
        Qmax = Q;
      }
      Q.reset(p);
    } else {
      return;
    }
  }
}

int main() {
  int n;
  scanf("%d", &n);
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      if (i != j) adj[i].set(j);
    }
  }
  int m;
  scanf("%d", &m);
  for (int i = 0; i < m; ++i) {
    int u, v;
    scanf("%d%d", &u, &v);
    adj[u].reset(v);
    adj[v].reset(u);
  }
  std::vector<int> R(n);
  std::iota(R.begin(), R.end(), 0);
  auto C = ColorSort(R);
  // for (int i = 0; i < n; ++i) printf("%d ", C[i]);
  // puts("");
  // for (int i = 0; i < n; ++i) printf("%d ", R[i]);
  // puts("");
  MaxCliqueDyn(R, C, 1);
  printf("%d\n", (int)Qmax.count());
}