test/misc/cf_gym103373_i.test.cpp

• View this file on GitHub
• Last update: 2025-08-12 22:13:25+09:00
• Problem: https://codeforces.com/gym/103373/problem/I

Depends on

• 二部グラフ (src/Graph/BipartiteGraph.hpp)
• グラフ (src/Graph/Graph.hpp)
• CSR 表現を用いた二次元配列 他 (src/Internal/ListRange.hpp)
• マトロイド交叉 (src/Optimization/matroid_intersection.hpp)
• 最大最小を指定するための列挙型 (src/Optimization/MinMaxEnum.hpp)

Code

// competitive-verifier: PROBLEM https://codeforces.com/gym/103373/problem/I
// competitive-verifier: TLE 0.5
// competitive-verifier: MLE 64

#include <iostream>
#include <vector>
#include <cmath>
#include "src/Graph/BipartiteGraph.hpp"
#include "src/Optimization/matroid_intersection.hpp"

using namespace std;
class TransversalMatroid {
 vector<vector<int>> l2r;
 std::vector<int8_t> use;
 int L, R;
public:
 TransversalMatroid(int L, int R): l2r(L), L(L), R(R) {}
 void add_edge(int l, int r) { l2r[l].push_back(r); }
 void build(const std::vector<int> &I) {
  use.assign(l2r.size(), 0);
  for (int i: I) use[i]= 1;
 }
 inline bool oracle(int e) {
  use[e]= 1;
  BipartiteGraph bg(L, R);
  int cnt= 0;
  for (int l= L; l--;)
   if (use[l]) {
    ++cnt;
    for (int r: l2r[l]) bg.add_edge(l, r + L);
   }
  use[e]= 0;
  auto [edge, _]= bipartite_matching(bg);
  return (int)edge.size() == cnt;
 }
 inline bool oracle(int e, int f) {
  use[e]= 0, use[f]= 1;
  BipartiteGraph bg(L, R);
  int cnt= 0;
  for (int l= L; l--;)
   if (use[l]) {
    ++cnt;
    for (int r: l2r[l]) bg.add_edge(l, r + L);
   }
  use[e]= 1, use[f]= 0;
  auto [edge, _]= bipartite_matching(bg);
  return (int)edge.size() == cnt;
 }
};
signed main() {
 cin.tie(0);
 ios::sync_with_stdio(false);
 int n, m;
 cin >> n >> m;
 long long a[n];
 for (int i= 0; i < n; ++i) cin >> a[i];
 GraphicMatroid g(n);
 vector<long long> cost(m);
 for (int i= 0; i < m; ++i) {
  int u, v;
  cin >> u >> v, --u, --v;
  g.add_edge(u, v);
  cost[i]= sqrt(a[u] + a[v]);
 }
 int w;
 cin >> w;
 TransversalMatroid M(m, w);
 for (int i= 0; i < w; ++i) {
  int x;
  cin >> x;
  for (int j= 0; j < x; ++j) {
   int b;
   cin >> b, --b;
   M.add_edge(b, i);
  }
 }
 auto S= weighted_matroid_intersection<MAXIMIZE>(m, g, M, cost);
 int K= S.size();
 vector<long long> ans(n - 1, -1);
 for (int i= 1; i < K; ++i) {
  ans[i - 1]= 0;
  for (auto x: S[i]) ans[i - 1]+= cost[x];
 }
 for (int i= 0; i < n - 1; ++i) cout << (i ? " " : "") << ans[i];
 cout << '\n';
 return 0;
}

#line 1 "test/misc/cf_gym103373_i.test.cpp"
// competitive-verifier: PROBLEM https://codeforces.com/gym/103373/problem/I
// competitive-verifier: TLE 0.5
// competitive-verifier: MLE 64

#include <iostream>
#include <vector>
#include <cmath>
#line 2 "src/Graph/BipartiteGraph.hpp"
#include <cassert>
#include <tuple>
#include <algorithm>
#line 4 "src/Internal/ListRange.hpp"
#include <iterator>
#include <type_traits>
#define _LR(name, IT, CT) \
 template <class T> struct name { \
  using Iterator= typename std::vector<T>::IT; \
  Iterator bg, ed; \
  Iterator begin() const { return bg; } \
  Iterator end() const { return ed; } \
  size_t size() const { return std::distance(bg, ed); } \
  CT &operator[](int i) const { return bg[i]; } \
 }
_LR(ListRange, iterator, T);
_LR(ConstListRange, const_iterator, const T);
#undef _LR
template <class T> struct CSRArray {
 std::vector<T> dat;
 std::vector<int> p;
 size_t size() const { return p.size() - 1; }
 ListRange<T> operator[](int i) { return {dat.begin() + p[i], dat.begin() + p[i + 1]}; }
 ConstListRange<T> operator[](int i) const { return {dat.cbegin() + p[i], dat.cbegin() + p[i + 1]}; }
};
template <template <class> class F, class T> std::enable_if_t<std::disjunction_v<std::is_same<F<T>, ListRange<T>>, std::is_same<F<T>, ConstListRange<T>>, std::is_same<F<T>, CSRArray<T>>>, std::ostream &> operator<<(std::ostream &os, const F<T> &r) {
 os << '[';
 for (int _= 0, __= r.size(); _ < __; ++_) os << (_ ? ", " : "") << r[_];
 return os << ']';
}
#line 3 "src/Graph/Graph.hpp"
struct Edge: std::pair<int, int> {
 using std::pair<int, int>::pair;
 Edge &operator--() { return --first, --second, *this; }
 int to(int v) const { return first ^ second ^ v; }
 friend std::istream &operator>>(std::istream &is, Edge &e) { return is >> e.first >> e.second, is; }
};
struct Graph: std::vector<Edge> {
 size_t n;
 Graph(size_t n= 0, size_t m= 0): vector(m), n(n) {}
 size_t vertex_size() const { return n; }
 size_t edge_size() const { return size(); }
 size_t add_vertex() { return n++; }
 size_t add_edge(int s, int d) { return emplace_back(s, d), size() - 1; }
 size_t add_edge(Edge e) { return emplace_back(e), size() - 1; }
#define _ADJ_FOR(a, b) \
 for (auto [u, v]: *this) a; \
 for (size_t i= 0; i < n; ++i) p[i + 1]+= p[i]; \
 for (int i= size(); i--;) { \
  auto [u, v]= (*this)[i]; \
  b; \
 }
#define _ADJ(a, b) \
 vector<int> p(n + 1), c(size() << !dir); \
 if (!dir) { \
  _ADJ_FOR((++p[u], ++p[v]), (c[--p[u]]= a, c[--p[v]]= b)) \
 } else if (dir > 0) { \
  _ADJ_FOR(++p[u], c[--p[u]]= a) \
 } else { \
  _ADJ_FOR(++p[v], c[--p[v]]= b) \
 } \
 return {c, p}
 CSRArray<int> adjacency_vertex(int dir) const { _ADJ(v, u); }
 CSRArray<int> adjacency_edge(int dir) const { _ADJ(i, i); }
#undef _ADJ
#undef _ADJ_FOR
};
#line 6 "src/Graph/BipartiteGraph.hpp"
// [0, L) is left, [L, n) is right
struct BipartiteGraph: Graph {
 size_t L;
 BipartiteGraph() {}
 BipartiteGraph(size_t L, size_t R, size_t m= 0): Graph(L + R, m), L(L) {}
 size_t left_size() const { return L; }
 size_t right_size() const { return this->n - L; }
};
std::vector<int> paint_two_colors(const CSRArray<int> &adj) {
 const int n= adj.size();
 std::vector<int> col(n, -1);
 for (int s= n; s--;)
  if (col[s] == -1) {
   std::vector<int> q= {s};
   for (int i= col[s]= 0, v; i < (int)q.size(); ++i)
    for (int u: adj[v= q[i]])
     if (int c= col[v]; col[u] == c) return {};
     else if (col[u] == -1) col[u]= c ^ 1, q.push_back(u);
  }
 return col;
}
std::vector<int> paint_two_colors(const Graph &g) { return paint_two_colors(g.adjacency_vertex(0)); }
// { BipartiteGraph , original to new, new to original }
// {{},{},{}} if not bipartite
std::tuple<BipartiteGraph, std::vector<int>, std::vector<int>> graph_to_bipartite(const Graph &g, std::vector<int> color= {}) {
 if (color.empty()) color= paint_two_colors(g);
 if (color.empty()) return {};
 const int n= g.vertex_size(), m= g.edge_size();
 std::vector<int> a(n), b(n);
 int l= 0, r= n;
 for (int i= n; i--;) b[a[i]= color[i] ? --r : l++]= i;
 BipartiteGraph bg(l, n - l, m);
 for (int i= m; i--;) {
  auto [u, v]= g[i];
  bg[i]= std::minmax(a[u], a[v]);
 }
 return {bg, a, b};
}
namespace _bg_internal {
std::vector<int> _bm(int L, const CSRArray<int> &adj, std::vector<int> &m) {
 std::vector<int> a, p, q(L);
 for (bool u= true; u;) {
  u= false, a.assign(L, -1), p.assign(L, -1);
  int t= 0;
  for (int l= L; l--;)
   if (m[l] == -1) q[t++]= a[l]= p[l]= l;
  for (int i= 0; i < t; ++i)
   if (int l= q[i], x; m[a[l]] == -1)
    for (int r: adj[l]) {
     if (x= m[r]; x == -1) {
      for (u= true; r != -1; l= p[l]) m[r]= l, std::swap(m[l], r);
      break;
     }
     if (p[x] == -1) a[q[t++]= x]= a[p[x]= l];
    }
 }
 return a;
}
}
template <bool lexical= false> std::pair<std::vector<int>, std::vector<int>> bipartite_matching(const BipartiteGraph &bg, std::vector<int> partner= {}) {
 const int L= bg.left_size(), M= bg.edge_size();
 if (partner.empty()) partner.assign(bg.vertex_size(), -1);
 assert(partner.size() == bg.vertex_size());
 {
  CSRArray<int> adj{std::vector<int>(M), std::vector<int>(L + 1)};
  for (auto [l, r]: bg) ++adj.p[l];
  for (int i= 0; i < L; ++i) adj.p[i + 1]+= adj.p[i];
  for (auto [l, r]: bg) adj.dat[--adj.p[l]]= r;
  if constexpr (lexical) {
   for (int l= L; l--;) std::sort(adj[l].begin(), adj[l].end());
   _bg_internal::_bm(L, adj, partner);
   std::vector<char> a(L, 1);
   for (int l= 0; l < L; ++l)
    if (int r= partner[l], v= l; r != -1) {
     std::vector<int> p(L, partner[v]= partner[r]= -1), c(adj.p.begin(), adj.p.begin() + L);
     for (p[v]= -2;;) {
      if (c[v] == adj.p[v + 1]) v= p[v];
      else if (int u= partner[r= adj.dat[c[v]++]]; u == -1) {
       for (; r != -1; v= p[v]) partner[r]= v, std::swap(partner[v], r);
       break;
      } else if (a[u] && p[u] == -1) p[u]= v, v= u;
     }
     a[l]= 0;
    }
  } else _bg_internal::_bm(L, adj, partner);
 }
 std::vector<int> c;
 std::vector<char> p(L);
 for (int i= 0; i < M; ++i)
  if (auto [l, r]= bg[i]; partner[l] == r && !p[l]) c.push_back(i), p[l]= 1;
 return {c, partner};
}
#line 4 "src/Optimization/matroid_intersection.hpp"
#include <limits>
#include <array>
#include <queue>
#line 2 "src/Optimization/MinMaxEnum.hpp"
enum MinMaxEnum { MAXIMIZE= -1, MINIMIZE= 1 };
#line 9 "src/Optimization/matroid_intersection.hpp"
template <typename Matroid1, typename Matroid2> std::vector<int> matroid_intersection(int n, Matroid1 M1, Matroid2 M2) {
 std::vector<int> b(n, false), pre(n), I[2];
 for (int e= 0; e < n; e++) I[0].push_back(e);
 M1.build(I[1]), M2.build(I[1]);
 for (bool converged= false; !converged;) {
  pre.assign(n, false);
  std::vector L(1, std::vector<int>());
  for (int u: I[0])
   if (M1.oracle(u)) pre[u]= true, L[0].push_back(u);
  int m= 0;
  for (; L.back().size(); m+= 2) {
   L.push_back({});
   for (int e: L[m]) {
    if (converged= M2.oracle(e)) break;
    for (int f: I[1])
     if (!pre[f] && M2.oracle(f, e)) L[m + 1].push_back(f), pre[f]= true;
   }
   if (converged) break;
   L.push_back({});
   for (int e: L[m + 1])
    for (int f: I[0])
     if (!pre[f] && M1.oracle(e, f)) L[m + 2].push_back(f), pre[f]= true;
  }
  if (!converged) break;
  std::vector<std::vector<int>> L2(m + 1);
  for (int e: L[m])
   if (M2.oracle(e)) L2[m].push_back(e);
  for (int i= m; i; i-= 2) {
   for (int e: L[i - 1])
    for (int f: L2[i])
     if (M1.oracle(e, f)) {
      L2[i - 1].push_back(e);
      break;
     }
   for (int e: L[i - 2])
    for (int f: L2[i - 1])
     if (M2.oracle(f, e)) {
      L2[i - 2].push_back(e);
      break;
     }
  }
  pre.assign(n, -1);
  for (int e: L2[0])
   if (M1.oracle(e)) {
    bool isok= false;
    if (m) {
     std::vector<size_t> ei(m);
     for (int i= 0; e != -1;) {
      if (ei[i] == L2[i + 1].size()) e= pre[e], ei[i--]= 0;
      else if (int f= L2[i + 1][ei[i]++]; pre[f] == -1 && (i & 1 ? M1.oracle(e, f) : M2.oracle(f, e)))
       if (pre[f]= e, e= f; ++i == m) {
        if (M2.oracle(e))
         for (isok= true; e != -1; e= pre[e]) b[e]= !b[e];
        else e= pre[e], --i;
       }
     }
    } else if (M2.oracle(e)) isok= true, b[e]= 1;
    if (isok) {
     converged= false, I[0].clear(), I[1].clear();
     for (int u= 0; u < n; u++) I[b[u]].push_back(u);
     M1.build(I[1]), M2.build(I[1]);
    }
   }
 }
 return I[1];
}
template <MinMaxEnum sgn, class Matroid1, class Matroid2, class cost_t> std::vector<std::vector<int>> weighted_matroid_intersection(int n, Matroid1 M1, Matroid2 M2, std::vector<cost_t> c) {
 assert(n == (int)c.size());
 bool b[n];
 std::fill_n(b, n, false);
 std::vector<int> I[2], p;
 std::vector<std::vector<int>> ret(1);
 for (int u= 0; u < n; u++) I[0].push_back(u);
 if constexpr (sgn == MAXIMIZE) {
  auto cmx= *std::max_element(c.begin(), c.end());
  for (auto &x: c) x-= cmx;
 } else {
  auto cmi= *std::min_element(c.begin(), c.end());
  for (auto &x: c) x-= cmi;
 }
 for (auto &x: c) x*= -sgn * (n + 1);
 for (bool converged= false; !converged;) {
  converged= true, M1.build(I[1]), M2.build(I[1]);
  std::priority_queue<std::pair<cost_t, int>> pq;
  std::vector<cost_t> dist(n, std::numeric_limits<cost_t>::lowest());
  for (int u: I[0])
   if (M1.oracle(u)) pq.emplace(dist[u]= c[u] - 1, u);
  for (p.assign(n, -1); pq.size();) {
   auto [d, u]= pq.top();
   if (pq.pop(); d != dist[u]) continue;
   if (b[u]) {
    for (int v: I[0])
     if (M1.oracle(u, v))
      if (cost_t cost= d + c[v] - 1; dist[v] < cost) pq.emplace(dist[v]= cost, v), p[v]= u;
   } else {
    if (M2.oracle(u)) {
     for (int v= u; v != -1; v= p[v]) b[v]= !b[v];
     I[0].clear(), I[1].clear(), converged= false;
     for (int u= 0; u < n; u++) I[b[u]].push_back(u);
     ret.emplace_back(I[1]);
     break;
    }
    for (int v: I[1])
     if (M2.oracle(v, u))
      if (cost_t cost= d - c[v] - 1; dist[v] < cost) pq.emplace(dist[v]= cost, v), p[v]= u;
   }
  }
 }
 return ret;
}
class GraphicMatroid {
 int n;
 std::vector<std::array<int, 2>> es;
 std::vector<int> g, pos, comp, in, out;
 inline bool is_ancestor(int u, int v) const { return in[u] <= in[v] && in[v] < out[u]; }
public:
 GraphicMatroid(int n_): n(n_), comp(n), in(n), out(n) {}
 int add_edge(int u, int v) { return es.push_back({u, v}), es.size() - 1; }
 void build(const std::vector<int> &I) {
  in.assign(n, -1), g.resize(I.size() * 2), pos.assign(n + 1, 0);
  for (int e: I) {
   auto [u, v]= es[e];
   ++pos[u], ++pos[v];
  }
  for (int i= 0; i < n; ++i) pos[i + 1]+= pos[i];
  for (int e: I) {
   auto [u, v]= es[e];
   g[--pos[u]]= v, g[--pos[v]]= u;
  }
  std::vector<int> ei(pos.begin(), pos.begin() + n), pre(n, -1);
  for (int u= 0, t= 0, p; u < n; u++)
   if (in[u] == -1)
    for (in [comp[u]= p= u]= t++; p >= 0;) {
     if (ei[p] == pos[p + 1]) out[p]= t, p= pre[p];
     else if (int v= g[ei[p]++]; in[v] == -1) comp[v]= comp[u], pre[v]= p, in[p= v]= t++;
    }
 }
 inline bool oracle(int e) const { return comp[es[e][0]] != comp[es[e][1]]; }
 inline bool oracle(int e, int f) const {
  if (oracle(f)) return true;
  return e= es[e][in[es[e][0]] < in[es[e][1]]], is_ancestor(e, es[f][0]) != is_ancestor(e, es[f][1]);
 }
};
struct PartitionMatroid {
 std::vector<int> belong, R, cnt;
 PartitionMatroid(int m_, const std::vector<std::vector<int>> &parts, const std::vector<int> &R_): belong(m_, -1), R(R_) {
  assert(parts.size() == R.size());
  for (int i= parts.size(); i--;)
   for (int e: parts[i]) belong[e]= i;
 }
 void build(const std::vector<int> &I) {
  cnt= R;
  for (int e: I)
   if (belong[e] != -1) cnt[belong[e]]--;
 }
 inline bool oracle(int e) const { return belong[e] == -1 || cnt[belong[e]] > 0; }
 inline bool oracle(int e, int f) const { return oracle(f) || belong[e] == belong[f]; }
};
#line 10 "test/misc/cf_gym103373_i.test.cpp"

using namespace std;
class TransversalMatroid {
 vector<vector<int>> l2r;
 std::vector<int8_t> use;
 int L, R;
public:
 TransversalMatroid(int L, int R): l2r(L), L(L), R(R) {}
 void add_edge(int l, int r) { l2r[l].push_back(r); }
 void build(const std::vector<int> &I) {
  use.assign(l2r.size(), 0);
  for (int i: I) use[i]= 1;
 }
 inline bool oracle(int e) {
  use[e]= 1;
  BipartiteGraph bg(L, R);
  int cnt= 0;
  for (int l= L; l--;)
   if (use[l]) {
    ++cnt;
    for (int r: l2r[l]) bg.add_edge(l, r + L);
   }
  use[e]= 0;
  auto [edge, _]= bipartite_matching(bg);
  return (int)edge.size() == cnt;
 }
 inline bool oracle(int e, int f) {
  use[e]= 0, use[f]= 1;
  BipartiteGraph bg(L, R);
  int cnt= 0;
  for (int l= L; l--;)
   if (use[l]) {
    ++cnt;
    for (int r: l2r[l]) bg.add_edge(l, r + L);
   }
  use[e]= 1, use[f]= 0;
  auto [edge, _]= bipartite_matching(bg);
  return (int)edge.size() == cnt;
 }
};
signed main() {
 cin.tie(0);
 ios::sync_with_stdio(false);
 int n, m;
 cin >> n >> m;
 long long a[n];
 for (int i= 0; i < n; ++i) cin >> a[i];
 GraphicMatroid g(n);
 vector<long long> cost(m);
 for (int i= 0; i < m; ++i) {
  int u, v;
  cin >> u >> v, --u, --v;
  g.add_edge(u, v);
  cost[i]= sqrt(a[u] + a[v]);
 }
 int w;
 cin >> w;
 TransversalMatroid M(m, w);
 for (int i= 0; i < w; ++i) {
  int x;
  cin >> x;
  for (int j= 0; j < x; ++j) {
   int b;
   cin >> b, --b;
   M.add_edge(b, i);
  }
 }
 auto S= weighted_matroid_intersection<MAXIMIZE>(m, g, M, cost);
 int K= S.size();
 vector<long long> ans(n - 1, -1);
 for (int i= 1; i < K; ++i) {
  ans[i - 1]= 0;
  for (auto x: S[i]) ans[i - 1]+= cost[x];
 }
 for (int i= 0; i < n - 1; ++i) cout << (i ? " " : "") << ans[i];
 cout << '\n';
 return 0;
}

Test cases

Env	Name	Status	Elapsed	Memory
g++-13	001	AC	6 ms	4 MB
g++-13	002	AC	5 ms	4 MB
g++-13	003	AC	5 ms	4 MB
g++-13	004	AC	5 ms	4 MB
g++-13	005	AC	5 ms	4 MB
g++-13	006	AC	5 ms	4 MB
g++-13	007	AC	5 ms	4 MB
g++-13	008	AC	5 ms	4 MB
g++-13	009	AC	5 ms	4 MB
g++-13	010	AC	5 ms	4 MB
g++-13	011	AC	5 ms	4 MB
g++-13	012	AC	5 ms	4 MB
g++-13	013	AC	5 ms	4 MB
g++-13	014	AC	5 ms	4 MB
g++-13	015	AC	5 ms	4 MB
g++-13	016	AC	5 ms	4 MB
g++-13	017	AC	5 ms	4 MB
g++-13	018	AC	5 ms	4 MB
g++-13	019	AC	5 ms	4 MB
g++-13	020	AC	5 ms	4 MB
g++-13	021	AC	5 ms	4 MB
g++-13	022	AC	5 ms	4 MB
g++-13	023	AC	5 ms	4 MB
g++-13	024	AC	5 ms	4 MB
g++-13	025	AC	5 ms	4 MB
g++-13	026	AC	5 ms	4 MB
g++-13	027	AC	5 ms	4 MB
g++-13	028	AC	5 ms	4 MB
g++-13	029	AC	5 ms	4 MB
g++-13	030	AC	5 ms	4 MB
g++-13	031	AC	5 ms	4 MB
g++-13	032	AC	5 ms	4 MB
g++-13	033	AC	5 ms	4 MB
g++-13	034	AC	5 ms	4 MB
g++-13	035	AC	5 ms	4 MB
g++-13	036	AC	5 ms	4 MB
g++-13	037	AC	5 ms	4 MB
g++-13	038	AC	5 ms	4 MB
g++-13	039	AC	5 ms	4 MB
g++-13	040	AC	5 ms	4 MB
g++-13	041	AC	5 ms	4 MB
g++-13	042	AC	5 ms	4 MB
g++-13	043	AC	5 ms	4 MB
g++-13	044	AC	6 ms	4 MB
g++-13	045	AC	5 ms	4 MB
g++-13	046	AC	5 ms	4 MB
g++-13	047	AC	6 ms	4 MB
g++-13	048	AC	5 ms	4 MB
g++-13	049	AC	5 ms	4 MB
g++-13	050	AC	5 ms	4 MB
g++-13	051	AC	5 ms	4 MB
g++-13	052	AC	5 ms	4 MB
g++-13	053	AC	5 ms	4 MB
g++-13	054	AC	5 ms	4 MB
g++-13	055	AC	5 ms	4 MB
g++-13	056	AC	5 ms	4 MB
g++-13	057	AC	5 ms	4 MB
g++-13	058	AC	5 ms	4 MB
g++-13	059	AC	5 ms	4 MB
g++-13	060	AC	6 ms	4 MB
g++-13	061	AC	5 ms	4 MB
g++-13	062	AC	5 ms	4 MB
g++-13	063	AC	5 ms	4 MB
g++-13	064	AC	5 ms	4 MB
g++-13	065	AC	5 ms	4 MB
g++-13	066	AC	5 ms	4 MB
g++-13	067	AC	14 ms	4 MB
g++-13	068	AC	5 ms	4 MB
g++-13	069	AC	5 ms	4 MB
g++-13	070	AC	11 ms	4 MB
g++-13	071	AC	6 ms	4 MB
g++-13	072	AC	6 ms	4 MB
g++-13	073	AC	6 ms	4 MB
g++-13	074	AC	6 ms	4 MB
g++-13	075	AC	6 ms	4 MB
g++-13	076	AC	5 ms	4 MB
g++-13	077	AC	5 ms	4 MB
g++-13	078	AC	8 ms	4 MB
g++-13	079	AC	5 ms	4 MB
g++-13	080	AC	19 ms	4 MB
g++-13	081	AC	5 ms	4 MB
g++-13	082	AC	5 ms	4 MB
g++-13	083	AC	5 ms	4 MB
g++-13	084	AC	13 ms	4 MB
g++-13	085	AC	5 ms	4 MB
g++-13	086	AC	5 ms	4 MB
g++-13	087	AC	5 ms	4 MB
g++-13	088	AC	16 ms	4 MB
g++-13	089	AC	5 ms	4 MB
g++-13	090	AC	5 ms	4 MB
g++-13	091	AC	6 ms	4 MB
g++-13	092	AC	6 ms	4 MB
g++-13	093	AC	7 ms	4 MB
g++-13	094	AC	7 ms	4 MB
g++-13	095	AC	6 ms	4 MB
g++-13	096	AC	6 ms	4 MB
g++-13	097	AC	6 ms	4 MB
g++-13	098	AC	6 ms	4 MB
g++-13	099	AC	6 ms	4 MB
g++-13	1	AC	5 ms	4 MB
g++-13	100	AC	6 ms	4 MB
g++-13	101	AC	12 ms	4 MB
g++-13	102	AC	7 ms	4 MB
g++-13	103	AC	7 ms	4 MB
g++-13	104	AC	12 ms	4 MB
g++-13	105	AC	22 ms	4 MB
g++-13	106	AC	8 ms	4 MB
g++-13	107	AC	13 ms	4 MB
g++-13	108	AC	12 ms	4 MB
g++-13	109	AC	21 ms	4 MB
g++-13	110	AC	13 ms	4 MB
g++-13	111	AC	5 ms	4 MB
g++-13	112	AC	5 ms	4 MB
g++-13	113	AC	5 ms	4 MB
g++-13	114	AC	5 ms	4 MB
g++-13	115	AC	5 ms	4 MB
g++-13	116	AC	5 ms	4 MB
g++-13	117	AC	5 ms	4 MB
g++-13	118	AC	5 ms	4 MB
g++-13	119	AC	5 ms	4 MB
g++-13	120	AC	5 ms	4 MB
g++-13	121	AC	57 ms	4 MB
g++-13	122	AC	52 ms	4 MB
g++-13	123	AC	35 ms	4 MB
g++-13	124	AC	57 ms	4 MB
g++-13	125	AC	41 ms	4 MB
g++-13	126	AC	60 ms	4 MB
g++-13	127	AC	53 ms	4 MB
g++-13	128	AC	50 ms	4 MB
g++-13	129	AC	49 ms	4 MB
g++-13	130	AC	56 ms	4 MB
g++-13	131	AC	9 ms	4 MB
g++-13	132	AC	13 ms	4 MB
g++-13	133	AC	5 ms	4 MB
g++-13	134	AC	5 ms	4 MB
g++-13	135	AC	5 ms	4 MB
g++-13	136	AC	7 ms	4 MB
g++-13	137	AC	7 ms	4 MB
g++-13	138	AC	8 ms	4 MB
g++-13	139	AC	8 ms	4 MB
g++-13	140	AC	5 ms	4 MB
g++-13	141	AC	5 ms	4 MB
g++-13	142	AC	5 ms	4 MB
g++-13	143	AC	5 ms	4 MB
g++-13	144	AC	5 ms	4 MB
g++-13	145	AC	5 ms	4 MB
g++-13	146	AC	5 ms	4 MB
g++-13	147	AC	5 ms	4 MB
g++-13	148	AC	5 ms	4 MB
g++-13	149	AC	5 ms	4 MB
g++-13	150	AC	5 ms	4 MB
g++-13	151	AC	5 ms	4 MB
g++-13	152	AC	5 ms	4 MB
g++-13	153	AC	5 ms	4 MB
g++-13	154	AC	5 ms	4 MB
g++-13	155	AC	5 ms	4 MB
g++-13	156	AC	5 ms	4 MB
g++-13	157	AC	5 ms	4 MB
g++-13	158	AC	5 ms	4 MB
g++-13	159	AC	5 ms	4 MB
g++-13	160	AC	5 ms	4 MB
g++-13	161	AC	5 ms	4 MB
g++-13	162	AC	5 ms	4 MB
clang++-18	001	AC	5 ms	4 MB
clang++-18	002	AC	5 ms	4 MB
clang++-18	003	AC	5 ms	4 MB
clang++-18	004	AC	5 ms	4 MB
clang++-18	005	AC	5 ms	4 MB
clang++-18	006	AC	5 ms	4 MB
clang++-18	007	AC	5 ms	4 MB
clang++-18	008	AC	5 ms	4 MB
clang++-18	009	AC	5 ms	4 MB
clang++-18	010	AC	5 ms	4 MB
clang++-18	011	AC	5 ms	4 MB
clang++-18	012	AC	5 ms	4 MB
clang++-18	013	AC	5 ms	4 MB
clang++-18	014	AC	5 ms	4 MB
clang++-18	015	AC	5 ms	4 MB
clang++-18	016	AC	5 ms	4 MB
clang++-18	017	AC	5 ms	4 MB
clang++-18	018	AC	5 ms	4 MB
clang++-18	019	AC	5 ms	4 MB
clang++-18	020	AC	5 ms	4 MB
clang++-18	021	AC	5 ms	4 MB
clang++-18	022	AC	5 ms	4 MB
clang++-18	023	AC	5 ms	4 MB
clang++-18	024	AC	5 ms	4 MB
clang++-18	025	AC	5 ms	4 MB
clang++-18	026	AC	5 ms	4 MB
clang++-18	027	AC	5 ms	4 MB
clang++-18	028	AC	5 ms	4 MB
clang++-18	029	AC	5 ms	4 MB
clang++-18	030	AC	5 ms	4 MB
clang++-18	031	AC	5 ms	4 MB
clang++-18	032	AC	5 ms	4 MB
clang++-18	033	AC	5 ms	4 MB
clang++-18	034	AC	5 ms	4 MB
clang++-18	035	AC	5 ms	4 MB
clang++-18	036	AC	5 ms	4 MB
clang++-18	037	AC	5 ms	4 MB
clang++-18	038	AC	5 ms	4 MB
clang++-18	039	AC	5 ms	4 MB
clang++-18	040	AC	5 ms	4 MB
clang++-18	041	AC	5 ms	4 MB
clang++-18	042	AC	6 ms	4 MB
clang++-18	043	AC	5 ms	4 MB
clang++-18	044	AC	6 ms	4 MB
clang++-18	045	AC	5 ms	4 MB
clang++-18	046	AC	6 ms	4 MB
clang++-18	047	AC	6 ms	4 MB
clang++-18	048	AC	5 ms	4 MB
clang++-18	049	AC	5 ms	4 MB
clang++-18	050	AC	5 ms	4 MB
clang++-18	051	AC	5 ms	4 MB
clang++-18	052	AC	5 ms	4 MB
clang++-18	053	AC	5 ms	4 MB
clang++-18	054	AC	5 ms	4 MB
clang++-18	055	AC	5 ms	4 MB
clang++-18	056	AC	5 ms	4 MB
clang++-18	057	AC	5 ms	4 MB
clang++-18	058	AC	6 ms	4 MB
clang++-18	059	AC	6 ms	4 MB
clang++-18	060	AC	5 ms	4 MB
clang++-18	061	AC	5 ms	4 MB
clang++-18	062	AC	5 ms	4 MB
clang++-18	063	AC	5 ms	4 MB
clang++-18	064	AC	5 ms	4 MB
clang++-18	065	AC	5 ms	4 MB
clang++-18	066	AC	5 ms	4 MB
clang++-18	067	AC	13 ms	4 MB
clang++-18	068	AC	6 ms	4 MB
clang++-18	069	AC	5 ms	4 MB
clang++-18	070	AC	10 ms	4 MB
clang++-18	071	AC	6 ms	4 MB
clang++-18	072	AC	6 ms	4 MB
clang++-18	073	AC	6 ms	4 MB
clang++-18	074	AC	6 ms	4 MB
clang++-18	075	AC	6 ms	4 MB
clang++-18	076	AC	5 ms	4 MB
clang++-18	077	AC	5 ms	4 MB
clang++-18	078	AC	8 ms	4 MB
clang++-18	079	AC	5 ms	4 MB
clang++-18	080	AC	16 ms	4 MB
clang++-18	081	AC	5 ms	4 MB
clang++-18	082	AC	5 ms	4 MB
clang++-18	083	AC	5 ms	4 MB
clang++-18	084	AC	11 ms	4 MB
clang++-18	085	AC	5 ms	4 MB
clang++-18	086	AC	5 ms	4 MB
clang++-18	087	AC	5 ms	4 MB
clang++-18	088	AC	14 ms	4 MB
clang++-18	089	AC	5 ms	4 MB
clang++-18	090	AC	5 ms	4 MB
clang++-18	091	AC	6 ms	4 MB
clang++-18	092	AC	6 ms	4 MB
clang++-18	093	AC	6 ms	4 MB
clang++-18	094	AC	6 ms	4 MB
clang++-18	095	AC	6 ms	4 MB
clang++-18	096	AC	6 ms	4 MB
clang++-18	097	AC	6 ms	4 MB
clang++-18	098	AC	6 ms	4 MB
clang++-18	099	AC	6 ms	4 MB
clang++-18	1	AC	5 ms	4 MB
clang++-18	100	AC	6 ms	4 MB
clang++-18	101	AC	10 ms	4 MB
clang++-18	102	AC	7 ms	4 MB
clang++-18	103	AC	7 ms	4 MB
clang++-18	104	AC	11 ms	4 MB
clang++-18	105	AC	19 ms	4 MB
clang++-18	106	AC	7 ms	4 MB
clang++-18	107	AC	12 ms	4 MB
clang++-18	108	AC	11 ms	4 MB
clang++-18	109	AC	18 ms	4 MB
clang++-18	110	AC	11 ms	4 MB
clang++-18	111	AC	5 ms	4 MB
clang++-18	112	AC	5 ms	4 MB
clang++-18	113	AC	5 ms	4 MB
clang++-18	114	AC	5 ms	4 MB
clang++-18	115	AC	5 ms	4 MB
clang++-18	116	AC	5 ms	4 MB
clang++-18	117	AC	5 ms	4 MB
clang++-18	118	AC	5 ms	4 MB
clang++-18	119	AC	5 ms	4 MB
clang++-18	120	AC	5 ms	4 MB
clang++-18	121	AC	49 ms	4 MB
clang++-18	122	AC	44 ms	4 MB
clang++-18	123	AC	30 ms	4 MB
clang++-18	124	AC	48 ms	4 MB
clang++-18	125	AC	36 ms	4 MB
clang++-18	126	AC	51 ms	4 MB
clang++-18	127	AC	44 ms	4 MB
clang++-18	128	AC	41 ms	4 MB
clang++-18	129	AC	41 ms	4 MB
clang++-18	130	AC	46 ms	4 MB
clang++-18	131	AC	8 ms	4 MB
clang++-18	132	AC	12 ms	4 MB
clang++-18	133	AC	5 ms	4 MB
clang++-18	134	AC	5 ms	4 MB
clang++-18	135	AC	5 ms	4 MB
clang++-18	136	AC	7 ms	4 MB
clang++-18	137	AC	7 ms	4 MB
clang++-18	138	AC	7 ms	4 MB
clang++-18	139	AC	8 ms	4 MB
clang++-18	140	AC	5 ms	4 MB
clang++-18	141	AC	5 ms	4 MB
clang++-18	142	AC	5 ms	4 MB
clang++-18	143	AC	5 ms	4 MB
clang++-18	144	AC	5 ms	4 MB
clang++-18	145	AC	5 ms	4 MB
clang++-18	146	AC	5 ms	4 MB
clang++-18	147	AC	5 ms	4 MB
clang++-18	148	AC	5 ms	4 MB
clang++-18	149	AC	5 ms	4 MB
clang++-18	150	AC	5 ms	4 MB
clang++-18	151	AC	5 ms	4 MB
clang++-18	152	AC	5 ms	4 MB
clang++-18	153	AC	5 ms	4 MB
clang++-18	154	AC	5 ms	4 MB
clang++-18	155	AC	5 ms	4 MB
clang++-18	156	AC	5 ms	4 MB
clang++-18	157	AC	5 ms	4 MB
clang++-18	158	AC	5 ms	4 MB
clang++-18	159	AC	5 ms	4 MB
clang++-18	160	AC	5 ms	4 MB
clang++-18	161	AC	5 ms	3 MB
clang++-18	162	AC	5 ms	4 MB

Back to top page