Utilize global variables

Author: marsenis

_includes/source_code/code/37-PDP/tiphunting/optimal.cc

@@ -15,8 +15,14 @@ using namespace std;
 using ll = pair<long, long>;
 using lll = tuple<long, long, long>;
 using vvll = vector<vector<ll>>;
+using vl = vector<long>;
 using vvl = vector<vector<long>>;
 
+vvll tree;
+vl tip, depth, parent, parent_weight;
+vvl pred;
+vector<long long> subtree_loop_opt, supertree_loop_opt, supertree_root_opt;
+
 long long positive_part(long long x) { return max(0LL, x); }
 
 // Διασχίζει το δέντρο `tree` ξεκινώντας από την κορυφή `u` και υπολογίζει
@@ -29,109 +35,93 @@ long long positive_part(long long x) { return max(0LL, x); }
 // της ρίζας είναι 0.
 // `parent[u]`: Ο γονέας του `u`.
 // `parent_weight[u]`: Κόστος του δρόμου που συνδέει τον `u` με τον γονέα του.
-void compute_auxiliary(const vvll& tree, int u, vector<long>& depth, vector<long>& parent, vector<long>& parent_weight) {
-  const long n = tree.size();
-  assert(depth.size() >= n);
-  assert(parent.size() >= n);
-  assert(parent_weight.size() >= n);
-  assert(0 <= u && u < n);
-
+void compute_auxiliary(int u) {
   for (auto [v, w]: tree[u]) {
     if (v == parent[u]) continue;
-    assert(0 <= v && v < n);
-
     parent[v] = u;
     parent_weight[v] = w;
     depth[v] = depth[u] + 1;
 
-    compute_auxiliary(tree, v, depth, parent, parent_weight);
+    compute_auxiliary(v);
   }
 }
 
 // Διασχίζει το δέντρο `tree` και υπολογίζει αναδρομικά τις τιμές
-// `subtree_loop_opt` για την κορυφή `u` κι όλους τους απογόνους της. Η τιμή της
-// `parent` είναι ο γονέας της `u`.
+// `subtree_loop_opt` για την κορυφή `u` κι όλους τους απογόνους της.
 //
 // `subtree_loop_opt[u]`: Το κέρδος της βέλτιστης διαδρομής η οποία ξεκινάει
 // και καταλήγει πάλι πίσω στο `u`, παραμένοντας στο υποδέντρο που ορίζει
 // η κορυφή `u`. Mε άλλα λόγια, η διαδρομή απαγορεύεται να διασχίσει
 // τον δρόμο `(u, parent)`.
-void compute_subtree_loop_opt(vector<long long> &subtree_loop_opt, const vvll &tree, const vector<long> &tip, long u, long parent) {
+void compute_subtree_loop_opt(long u) {
   subtree_loop_opt[u] = tip[u];
 
   for (auto [v, w]: tree[u]) {
-    if (v == parent) continue;
-    compute_subtree_loop_opt(subtree_loop_opt, tree, tip, v, u);
+    if (v == parent[u]) continue;
+    compute_subtree_loop_opt(v);
     subtree_loop_opt[u] += positive_part(subtree_loop_opt[v] - 2*w);
   }
 }
 
 // Διασχίζει το δέντρο `tree` και υπολογίζει αναδρομικά τις τιμές
 // `subtree_root_opt` για την κορυφή `u` κι όλους τους απογόνους της,
 // χρησιμοποιώντας τις τιμές `subtree_loop_opt` που υπολογίσαμε ήδη στην
-// προηγούμενη διάσχιση. Η τιμή της `parent` είναι ο γονέας της `u`.
+// προηγούμενη διάσχιση.
 //
 // `supertree_root_opt[u]`: Το κέρδος της βέλτιστης διαδρομής η οποία ξεκινάει
 // από την κορυφή `u`, καταλήγει στη ρίζα του δέντρου και
 // μένει πάντα ΕΚΤΟΣ του υποδέντρου που ορίζει η `u`. Το φιλοδώρημα της κορυφής
 // `u` ΔΕΝ προσμετράται.
-void compute_supertree_root_opt(vector<long long>& supertree_root_opt, const vector<long long>& subtree_loop_opt, const vvll& tree, long u, long parent, long w) {
-  assert(0 <= u && u < tree.size());
-  assert(-1 <= parent && parent < (long)tree.size());
-
+void compute_supertree_root_opt(long u) {
   supertree_root_opt[u] = 0;
 
-  if (parent != -1)
-    supertree_root_opt[u] = subtree_loop_opt[parent] + supertree_root_opt[parent] - positive_part(subtree_loop_opt[u] - 2*w) - w;
+  if (parent[u] != -1)
+    supertree_root_opt[u] =
+      subtree_loop_opt[parent[u]] + supertree_root_opt[parent[u]]
+    - positive_part(subtree_loop_opt[u] - 2*parent_weight[u]) - parent_weight[u];
 
   for (auto [v, w]: tree[u])
-    if (v != parent)
-      compute_supertree_root_opt(supertree_root_opt, subtree_loop_opt, tree, v, u, w);
+    if (v != parent[u])
+      compute_supertree_root_opt(v);
 }
 
 // Διασχίζει το δέντρο `tree` και υπολογίζει αναδρομικά τις τιμές
 // `subtree_loop_opt` για την κορυφή `u` κι όλους τους απογόνους της,
 // χρησιμοποιώντας τις τιμές `subtree_loop_opt` που υπολογίσαμε ήδη στην
-// προηγούμενη διάσχιση. Η τιμή της `parent` είναι ο γονέας της `u`.
+// προηγούμενη διάσχιση.
 //
 // supertree_loop_opt[u] = κέρδος της βέλτιστης διαδρομής η οποία ξεκινάει αλλά
 // ΚΑΙ καταλήγει στην κορυφή `u`, και μένει πάντα ΕΚΤΟΣ του υποδέντρου που
 // ορίζει η `u`. Το φιλοδώρημα της κορυφής `u` ΔΕΝ προσμετράται.
-void compute_supertree_loop_opt(vector<long long>& supertree_loop_opt, const vector<long long>& subtree_loop_opt, const vvll& tree, int u, int parent, int w) {
-  assert(0 <= u && u < tree.size());
-  assert(-1 <= parent && parent < (long)tree.size());
-
+void compute_supertree_loop_opt(int u) {
   supertree_loop_opt[u] = 0;
 
-  if (parent != -1)
-    supertree_loop_opt[u] = positive_part(subtree_loop_opt[parent] + supertree_loop_opt[parent] - positive_part(subtree_loop_opt[u] - 2*w) - 2*w);
+  if (parent[u] != -1)
+    supertree_loop_opt[u] =
+      positive_part(subtree_loop_opt[parent[u]] + supertree_loop_opt[parent[u]]
+    - positive_part(subtree_loop_opt[u] - 2*parent_weight[u]) - 2*parent_weight[u]);
 
   for (auto [v, w]: tree[u])
-    if (v != parent)
-      compute_supertree_loop_opt(supertree_loop_opt, subtree_loop_opt, tree, v, u, w);
+    if (v != parent[u])
+      compute_supertree_loop_opt(v);
 }
 
-// Υπολογίζει τον πίνακα `pred` έτσι ώστε:
+// Υπολογίζει τον πίνακα `pred` έτσι ώστε για κάθε 0 <= h <= H, 0 <= u < N:
 // `pred[h][u] == v` αν και μόνο αν ο `v` είναι ο `2^h`-πρόγονος του `u`.
 // Για παράδειγμα `pred[0][u] == parent[u]` γιατί ο γονέας του $u$
 // είναι ο `2^0 = 1`-ος πρόγονός του.
-// Ο πίνακας εισόδου `parent` θα πρέπει για κάθε κορυφή να περιέχει
-// τον γονέα της, εκτός από την ρίζα `r` για την οποία θα πρέπει να ισχύει
-// `parent[r] == r`.
-void compute_pred(const vector<long> &parent, vvl &pred)
-{
-  const long H = pred.size() - 1;
+// O caller θα πρέπει να έχει ήδη υπολογίσει τον πίνακα parent
+// (δες `compute_auxiliary`) έτσι ώστε η τιμή `parent[u]` να είναι
+// ο γονέας της `u`, εκτός από την ρίζα `r` για την οποία `r == parent[r]`.
+void compute_pred(long H) {
   const long n = parent.size();
 
   for (long u = 0; u < n; ++u)
     pred[0][u] = parent[u];
 
   for (long h = 1; h <= H; ++h)
     for (long u = 0; u < n; ++u)
-    {
-      assert(0 <= pred[h - 1][u] && pred[h - 1][u] < n);
       pred[h][u] = pred[h - 1][pred[h - 1][u]];
-    }
 }
 
 // Υπολογίζει τρεις τιμές `(z, a, b)` όπου `z` είναι ο Ελάχιστος Κοινός Πρόγονος
@@ -140,44 +130,38 @@ void compute_pred(const vector<long> &parent, vvl &pred)
 // αντίστοιχα `b` είναι η μοναδική κορυφή στο μονοπάτι από `z` προς `v` τέτοια
 // ώστε `parent[v] == z` (ή `b == -1` αν τέτοια κορυφή δεν υπάρχει).
 // 
-// Η συνάρτηση λαμβάνει ως είσοδο και τον πίνακα `pred` που υπολόγισε νωρίτερα η
+// Η συνάρτηση χρησιμοποιεί τον πίνακα `pred` που υπολόγισε νωρίτερα η
 // συνάρτηση `compute_pred` καθώς και τον πίνακα `depth` που υπολόγισε νωρίτερα
 // η συνάρτηση `compute_auxiliary`.
-lll lca(const vector<vector<long>> &pred, const vector<long> &depth, long u, long v) {
+lll lca(long u, long v) {
   const long H = pred.size() - 1;
 
   if (u == v)
     return {u, -1, -1};
 
   if (depth[u] < depth[v]) {
-    auto [w, i, j] = lca(pred, depth, v, u);
+    auto [w, i, j] = lca(v, u);
     return {w, j, i};
   }
 
   if (depth[u] != depth[v]) {
     for (long h = H; h >= 0; h--)
       if (depth[ pred[h][u] ] > depth[v])
         u = pred[h][u];
-    
-    assert(depth[pred[0][u]] == depth[v]);
 
     if (pred[0][u] == v)
       return { v,  u, -1 };
 
     u =pred[0][u];
   }
 
-  assert(depth[u] == depth[v]);
-  assert(u != v);
-
   for (long h = H; h >= 0; --h) {
     if (pred[h][u] != pred[h][v]) {
       u = pred[h][u];
       v = pred[h][v];
     }
   }
 
-  assert(pred[0][u] == pred[0][v]);
   return { pred[0][u], u, v };
 }
 
@@ -188,19 +172,17 @@ int main() {
   long n, q;
   scanf("%li%li", &n, &q);
 
-  vector<long> tip(n);
+  tip.resize(n);
   for (long i = 0; i < n; ++i)
     scanf("%li", &tip[i]);
 
   // Αναπαράσταση του δέντρου με adjacency list:
   // To `tree[u]` περιέχει ένα vector με pairs `(v, w)` για κάθε κορυφή `v` που
   // συνδέεται με τη `u` με κόστός `w`.
-  vvll tree(n);
+  tree.resize(n);
   for (long i = 0; i < n-1; ++i) {
     long u, v, w;
     scanf("%li%li%li", &u, &v, &w);
-    assert(1 <= u && u <= n);
-    assert(1 <= v && v <= n);
 
     tree[u-1].push_back({v-1, w});
     tree[v-1].push_back({u-1, w});
@@ -209,8 +191,10 @@ int main() {
   // Αρχικοποιώντας `depth[0] = 0`, `parent[0] = 0` θέτουμε την κορυφή
   // 0 ως ρίζα του δέντρου. Η συνάρτηση `compute_auxiliary` συμπληρώνει
   // τις τιμές και για τους υπόλοιπους κόμβους.
-  vector<long> depth(n, 0), parent(n, 0), parent_weight(n, 0);
-  compute_auxiliary(tree, 0, depth, parent, parent_weight);
+  depth.resize(n, 0);
+  parent.resize(n, 0);
+  parent_weight.resize(n, 0);
+  compute_auxiliary(0);
 
   // Θα χρειαστούμε το μέγιστο βάθος ώστε να υπολογίσουμε τις διαστάσεις
   // πίνακα `pred` παρακάτω.
@@ -222,13 +206,15 @@ int main() {
   // Το δέντρο έχει ύψος `max_depth` επομένως θα χρειαστούμε τους
   // απογόνους (predecessors) το πολύ μέχρι `max_depth <= 2^H` επίπεδα παραπάνω.
   const long H = long(ceil(log2(max_depth)));
-  vector<vector<long>> pred(H+1, vector<long>(n, 0));
-  compute_pred(parent, pred);
+  pred.resize(H+1, vector<long>(n, 0));
+  compute_pred(H);
 
-  vector<long long> subtree_loop_opt(n), supertree_root_opt(n), supertree_loop_opt(n);
-  compute_subtree_loop_opt(subtree_loop_opt, tree, tip, 0, -1);
-  compute_supertree_root_opt(supertree_root_opt, subtree_loop_opt, tree, 0, -1, -1);
-  compute_supertree_loop_opt(supertree_loop_opt, subtree_loop_opt, tree, 0, -1, -1);
+  subtree_loop_opt.resize(n);
+  supertree_loop_opt.resize(n);
+  supertree_root_opt.resize(n);
+  compute_subtree_loop_opt(0);
+  compute_supertree_root_opt(0);
+  compute_supertree_loop_opt(0);
 
   for (long i = 0; i < q; ++i) {
     long L, R;
@@ -241,7 +227,7 @@ int main() {
       continue;
     }
 
-    auto [z, u, v] = lca(pred, depth, L, R);
+    auto [z, u, v] = lca(L, R);
     assert(u != -1 || v != -1);
 
     long long sol = 0;