Submission #569096

#	Time	Username	Problem	Language	Result	Execution time	Memory
569096		SSRS	Duathlon (APIO18_duathlon)	C++14	100 / 100	327 ms	46736 KiB

count_triplets

#include <bits/stdc++.h>
using namespace std;
struct biconnected_components{
  int cnt;
  vector<int> bcc;
  biconnected_components(vector<vector<pair<int, int>>> &E){
    int N = E.size();
    vector<int> next(N, -1);
    vector<int> d(N, -1);
    vector<int> imos(N, 0);
    for (int i = 0; i < N; i++){
      if (d[i] == -1){
        d[i] = 0;
        dfs1(E, next, d, imos, i);
      }
    }
    int M = 0;
    for (int i = 0; i < N; i++){
      M += E[i].size();
    }
    M /= 2;
    bcc = vector<int>(M, -1);
    cnt = 0;
    for (int i = 0; i < N; i++){
      if (d[i] == 0){
        dfs2(E, d, imos, cnt, i);
      }
    }
  }
  void dfs1(vector<vector<pair<int, int>>> &E, vector<int> &next, vector<int> &d, vector<int> &imos, int v){
    for (auto P : E[v]){
      int w = P.second;
      if (d[w] == -1){
        d[w] = d[v] + 1;
        next[v] = w;
        dfs1(E, next, d, imos, w);
        imos[v] += imos[w];
      } else if (d[w] < d[v] - 1){
        imos[v]++;
        imos[next[w]]--;
      }
    }
  }
  void dfs2(vector<vector<pair<int, int>>> &E, vector<int> &d, vector<int> &imos, int b, int v){
    for (auto P : E[v]){
      int x = P.first;
      int w = P.second;
      if (d[w] < d[v]){
        bcc[x] = b;
      } else if (d[w] == d[v] + 1 && bcc[x] == -1){
        if (imos[w] > 0){
          bcc[x] = b;
        } else {
          bcc[x] = cnt;
          cnt++;
        }
        dfs2(E, d, imos, bcc[x], w);
      }
    }
  }
  int operator [](int k){
    return bcc[k];
  }
  int count(){
    return cnt;
  }
};
struct block_cut_tree{
  int V;
  vector<bool> cut;
  vector<vector<int>> G;
  vector<vector<int>> node;
  block_cut_tree(vector<vector<int>> &E){
    int N = E.size();
    int M = 0;
    vector<vector<pair<int, int>>> E2(N);
    for (int i = 0; i < N; i++){
      for (int j : E[i]){
        if (j > i){
          E2[i].push_back(make_pair(M, j));
          E2[j].push_back(make_pair(M, i));
          M++;
        }
      }
    }
    biconnected_components B(E2);
    vector<bool> art(N, false);
    int cnt = 0;
    for (int i = 0; i < N; i++){
      for (auto P : E2[i]){
        if (B[P.first] != B[E2[i][0].first]){
          art[i] = true;
        }
      }
      if (E2[i].empty()){
        art[i] = true;
      }
      if (art[i]){
        cnt++;
      }
    }
    V = cnt + B.count();
    cut = vector<bool>(V, false);
    G.resize(V);
    node.resize(V);
    int cnt2 = 0;
    vector<bool> used(B.count(), false);
    for (int i = 0; i < N; i++){
      if (art[i]){
        cut[cnt2] = true;
        node[cnt2].push_back(i);
        for (auto P : E2[i]){
          int b = B[P.first];
          if (!used[b]){
            used[b] = true;
            G[cnt + b].push_back(cnt2);
            G[cnt2].push_back(cnt + b);
            node[cnt + b].push_back(i);
          }
        }
        for (auto P : E2[i]){
          int b = B[P.first];
          used[b] = false;
        }
        cnt2++;
      } else {
        if (!E2[i].empty()){
          int b = B[E2[i][0].first];
          node[cnt + b].push_back(i);
        }
      }
    }
  }
};
int main(){
  int n, m;
  cin >> n >> m;
  vector<vector<int>> E(n);
  for (int i = 0; i < m; i++){
    int u, v;
    cin >> u >> v;
    u--;
    v--;
    E[u].push_back(v);
    E[v].push_back(u);
  }
  block_cut_tree T(E);
  vector<int> id(n, -1);
  for (int i = 0; i < T.V; i++){
    for (int j : T.node[i]){
      if (id[j] == -1){
        id[j] = i;
      }
    }
  }
  vector<int> p(T.V, -1);
  vector<vector<int>> c(T.V);
  vector<int> r(T.V);
  vector<int> bfs;
  for (int i = 0; i < T.V; i++){
    if (p[i] == -1){
      queue<int> Q;
      Q.push(i);
      while (!Q.empty()){
        int v = Q.front();
        Q.pop();
        r[v] = i;
        bfs.push_back(v);
        for (int w : T.G[v]){
          if (w != p[v]){
            p[w] = v;
            c[v].push_back(w);
           Q.push(w);
          }
        }
      }
    }
  }
  reverse(bfs.begin(), bfs.end());
  vector<int> dp(T.V, 0);
  for (int i = 0; i < n; i++){
    dp[id[i]]++;
  }
  for (int v : bfs){
    for (int w : c[v]){
      dp[v] += dp[w];
    }
  }
  vector<long long> sum(T.V, 0);
  for (int i = 0; i < T.V; i++){
    for (int w : c[i]){
      sum[i] += (long long) dp[w] * (dp[w] - 1);
    }
  }
  long long ans = 0;
  for (int i = 0; i < T.V; i++){
    if (p[i] == -1){
      ans += (long long) dp[i] * (dp[i] - 1) * (dp[i] - 2);
    }
  }
  for (int i = 0; i < n; i++){
    if (!T.cut[id[i]]){
      ans -= sum[id[i]];
      ans -= (long long) (dp[r[id[i]]] - dp[id[i]]) * (dp[r[id[i]]] - dp[id[i]]  - 1);
    } else {
      for (int j : c[id[i]]){
        ans -= sum[j];
      }
      if (p[id[i]] != -1){
        ans -= sum[p[id[i]]];
        ans += (long long) dp[id[i]] * (dp[id[i]] -  1);
        ans -= (long long) (dp[r[id[i]]] - dp[p[id[i]]]) * (dp[r[id[i]]] - dp[p[id[i]]] - 1);
      }
    }
  }
  cout << ans << endl;
}

• Subtask 1: 5 / 5
• Subtask 2: 11 / 11
• Subtask 3: 8 / 8
• Subtask 4: 10 / 10
• Subtask 5: 13 / 13
• Subtask 6: 15 / 15
• Subtask 7: 20 / 20
• Subtask 8: 8 / 8
• Subtask 9: 10 / 10