adding progress

Author: lrvideckis

library/trees/edge_cd.hpp

@@ -19,14 +19,14 @@
 //!   });
 //! @endcode
 //! handle single-edge-paths separately
-//! @time O(n log1.5 n)
+//! @time O(n logφ n)
 //! @space O(n)
-template<class F, class G> struct edge_cd {
+template <class F, class G>
+struct edge_cd {
   vector<G> adj;
   F f;
   vi sub_sz;
-  edge_cd(const vector<G>& adj, F f):
-    adj(adj), f(f), sub_sz(sz(adj)) {
+  edge_cd(const vector<G>& adj, F f) : adj(adj), f(f), sub_sz(sz(adj)) {
     dfs(0, sz(adj));
   }
   int find_cent(int v, int p, int siz) {
@@ -38,17 +38,16 @@ template<class F, class G> struct edge_cd {
         sub_sz[v] += sub_sz[u];
       }
     if (p == -1) return v;
-    return 2 * sub_sz[v] >= siz
-           ? sub_sz[p] = siz - sub_sz[v],
-             v : -1;
+    return 2 * sub_sz[v] >= siz ? sub_sz[p] = siz - sub_sz[v], v : -1;
   }
   void dfs(int v, int siz) {
     if (siz <= 2) return;
     v = find_cent(v, -1, siz);
     int sum = 0;
     auto it = partition(all(adj[v]), [&](int u) {
-      bool ret = 2 * sum + sub_sz[u] < siz - 1 &&
-        3 * (sum + sub_sz[u]) <= 2 * (siz - 1);
+      ll b = sum + sub_sz[u];
+      ll a = siz - 1 - b;
+      bool ret = (b * b <= a * (a + b));
       if (ret) sum += sub_sz[u];
       return ret;
     });

tests/library_checker_aizu_tests/edge_cd_asserts.hpp

@@ -1,6 +1,5 @@
 #pragma once
-void edge_cd_asserts(const vector<vi>& adj, int cent,
-  int split) {
+void edge_cd_asserts(const vector<vi>& adj, int cent, int split) {
   assert(0 < split && split < sz(adj[cent]));
   auto dfs = [&](auto&& self, int u, int p) -> int {
     int siz = 1;
@@ -11,12 +10,37 @@ void edge_cd_asserts(const vector<vi>& adj, int cent,
   int sz_all = dfs(dfs, cent, -1);
   assert(sz_all >= 3);
   array<int, 2> cnts = {0, 0};
+  array<int, 2> max_cnt = {0, 0};
   for (int i = 0; i < sz(adj[cent]); i++) {
     int sz_subtree = dfs(dfs, adj[cent][i], cent);
     assert(2 * sz_subtree <= sz_all);
     cnts[i < split] += sz_subtree;
+    max_cnt[i < split] = max(max_cnt[i < split], sz_subtree);
   }
   assert(cnts[0] + cnts[1] + 1 == sz_all);
-  for (int i = 0; i < 2; i++)
-    assert(0 < cnts[i] && cnts[i] <= 2 * cnts[!i]);
+
+  if (sz_all == 4) return;
+
+  // a is the number of edges in the smaller edge set
+  // b is the number of edges in the larger edge set
+  // so we know 1/2 <= b/(a+b)
+  // returns true iff b/(a+b) <= 1/phi
+  auto is_balanced = [&](ll a, ll b) -> bool {
+    assert(a <= b);
+    return b * b <= a * (a + b);
+  };
+
+  if (cnts[0] > cnts[1]) {
+    swap(cnts[0], cnts[1]);
+    swap(max_cnt[0], max_cnt[1]);
+  }
+
+  if (!is_balanced(cnts[0], cnts[1])) {
+    int a = max_cnt[1];
+    int b = cnts[1] - max_cnt[1];
+    assert(a > 0);
+    assert(b > 0);
+    if (a > b) swap(a, b);
+    assert(is_balanced(a, b));
+  }
 }