Use global vars on all subtasks

Author: marsenis

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

@@ -2,13 +2,6 @@
 #include <cassert>
 #include <vector>
 #include <cmath>
-// #define DEBUG
-
-#ifdef DEBUG
-#define debug(...) fprintf(stderr, __VA_ARGS__)
-#else
-#define debug(...) ((void)0)
-#endif
 
 using namespace std;
 
@@ -75,7 +68,8 @@ void compute_subtree_loop_opt(long u) {
 void compute_supertree_root_opt(long u) {
   supertree_root_opt[u] = 0;
 
-  if (parent[u] != -1)
+  // Αν η κορυφή `u` ΔΕΝ είναι ρίζα.
+  if (parent[u] != u)
     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];
@@ -96,7 +90,8 @@ void compute_supertree_root_opt(long u) {
 void compute_supertree_loop_opt(int u) {
   supertree_loop_opt[u] = 0;
 
-  if (parent[u] != -1)
+  // Αν η κορυφή `u` ΔΕΝ είναι ρίζα.
+  if (parent[u] != u)
     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]);
@@ -210,11 +205,13 @@ int main() {
   compute_pred(H);
 
   subtree_loop_opt.resize(n);
+  compute_subtree_loop_opt(0);
+
   supertree_loop_opt.resize(n);
+  compute_supertree_loop_opt(0);
+
   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;

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

@@ -24,8 +24,8 @@ int main() {
   }
 
   for (long i = 0; i < q; ++i) {
-    long src, dst;
-    scanf("%li%li", &src, &dst);
+    long L, R;
+    scanf("%li%li", &L, &R);
     printf("%lli\n", sol);
   }
 

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

@@ -5,20 +5,24 @@
 using namespace std;
 
 using ll = pair<long, long>;
+using vl = vector<long>;
 using vvll = vector<vector<ll>>;
 
+vvll tree;
+vl tip;
+
 long long positive_part(long long x) { return max(0LL, x); }
 
 // Επιστρέφει το κέρδος της βέλτιστης διαδρομή η οποία ξεκινάει
 // από την κορυφή `u`, καταλλήγει πίσω σε αυτή και παραμένει
 // εξ' ολοκλήρου μέσα στο υποδέντρο που ορίζει η `u` -- με άλλα λόγια,
 // η διαδρομή απαγορεύεται να διασχίσει το δρόμο `(u, parent)`.
-long long subtree_loop_opt(const vvll& tree, const vector<long>& tip, long u, long parent) {
+long long subtree_loop_opt(long u, long parent) {
   long long sol = tip[u];
 
   for (auto [v, w]: tree[u]) {
     if (v == parent) continue;
-    long long s = subtree_loop_opt(tree, tip, v, u);
+    long long s = subtree_loop_opt(v, u);
     sol += positive_part(s - 2*w);
   }
 
@@ -32,33 +36,29 @@ int main() {
 
   long n, q;
   scanf("%li%li", &n, &q);
-  assert(1 <= n && n <= 1'000);
-  assert(1 <= q && q <= 1'000);
 
-  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});
   }
 
   for (long i = 0; i < q; ++i) {
-    long src, dst;
-    scanf("%li%li", &src, &dst);
-    assert(src == dst);
+    long L, R;
+    scanf("%li%li", &L, &R);
+    assert(L == R);
 
-    printf("%lli\n", subtree_loop_opt(tree, tip, src-1, -1));
+    printf("%lli\n", subtree_loop_opt(L-1, L-1));
   }
 
   return 0;

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

@@ -5,8 +5,13 @@
 using namespace std;
 
 using ll = pair<long, long>;
+using vl = vector<long>;
 using vvll = vector<vector<ll>>;
 
+vvll tree;
+vl tip;
+vector<long long> subtree_loop_opt, supertree_root_opt;
+
 long long positive_part(long long x) { return max(0LL, x); }
 
 // Πρώτη διαπέραση η οποία υπολογίζει το `subtree_loop_opt` για την κορυφή `u`
@@ -16,13 +21,12 @@ long long positive_part(long long x) { return max(0LL, x); }
 // και καταλλήγει πάλι πίσω στο `u`, παραμένοντας στο υποδέντρο που ορίζει
 // η κορυφή `u` -- με άλλα λόγια, η διαδρομή απαγορεύεται να διασχίσει
 // τον δρόμο `(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, long parent) {
   subtree_loop_opt[u] = tip[u];
 
-  int x;
   for (auto [v, w]: tree[u]) {
     if (v == parent) continue;
-    compute_subtree_loop_opt(subtree_loop_opt, tree, tip, v, u);
+    compute_subtree_loop_opt(v, u);
     subtree_loop_opt[u] += positive_part(subtree_loop_opt[v] - 2*w);
   }
 }
@@ -35,18 +39,16 @@ void compute_subtree_loop_opt(vector<long long>& subtree_loop_opt, const vvll& t
 // από την κορυφή `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 long)tree.size());
-
+void compute_supertree_root_opt(long u, long parent, long w) {
   supertree_root_opt[u] = 0;
 
-  if (parent != -1)
+  // Αν η κορυφή `u` ΔΕΝ είναι ρίζα.
+  if (parent != u)
     supertree_root_opt[u] = subtree_loop_opt[parent] + supertree_root_opt[parent] - positive_part(subtree_loop_opt[u] - 2*w) - w;
 
   for (auto [v, w]: tree[u])
     if (v != parent)
-      compute_supertree_root_opt(supertree_root_opt, subtree_loop_opt, tree, v, u, w);
+      compute_supertree_root_opt(v, u, w);
 }
 
 int main() {
@@ -57,35 +59,35 @@ 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});
   }
 
+  subtree_loop_opt.resize(n);
+  supertree_root_opt.resize(n);
+
   for (long i = 0; i < q; ++i) {
-    long src, dst;
-    scanf("%li%li", &src, &dst);
-    src -= 1;
-    dst -= 1;
+    long L, R;
+    scanf("%li%li", &L, &R);
+    L -= 1;
+    R -= 1;
 
-    vector<long long> subtree_loop_opt(n), supertree_root_opt(n);
-    compute_subtree_loop_opt(subtree_loop_opt, tree, tip, dst, -1);
-    compute_supertree_root_opt(supertree_root_opt, subtree_loop_opt, tree, dst, -1, -1);
+    compute_subtree_loop_opt(R, R);
+    compute_supertree_root_opt(R, R, 0);
 
-    printf("%lli\n", subtree_loop_opt[src] + supertree_root_opt[src]);
+    printf("%lli\n", subtree_loop_opt[L] + supertree_root_opt[L]);
   }
 
   return 0;

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

@@ -5,8 +5,13 @@
 using namespace std;
 
 using ll = pair<long, long>;
+using vl = vector<long>;
 using vvll = vector<vector<ll>>;
 
+vvll tree;
+vl tip;
+vector<long long> subtree_loop_opt, supertree_loop_opt;
+
 long long positive_part(long long x) { return max(0LL, x); }
 
 // Πρώτη διαπέραση η οποία υπολογίζει το `subtree_loop_opt` για την κορυφή `u`
@@ -16,12 +21,12 @@ long long positive_part(long long x) { return max(0LL, x); }
 // και καταλλήγει πάλι πίσω στο `u`, παραμένοντας στο υποδέντρο που ορίζει
 // η κορυφή `u` -- με άλλα λόγια, η διαδρομή απαγορεύεται να διασχίσει
 // τον δρόμο `(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, long parent) {
   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);
+    compute_subtree_loop_opt(v, u);
     subtree_loop_opt[u] += positive_part(subtree_loop_opt[v] - 2*w);
   }
 }
@@ -33,18 +38,16 @@ void compute_subtree_loop_opt(vector<long long>& subtree_loop_opt, const vvll& t
 // 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, long u, long parent, long w) {
-  assert(0 <= u && u < tree.size());
-  assert(-1 <= parent && parent < (long long)tree.size());
-
+void compute_supertree_loop_opt(long u, long parent, long w) {
   supertree_loop_opt[u] = 0;
 
-  if (parent != -1)
+  // Αν η κορυφή `u` ΔΕΝ είναι ρίζα.
+  if (parent != u)
     supertree_loop_opt[u] = positive_part(subtree_loop_opt[parent] + supertree_loop_opt[parent] - positive_part(subtree_loop_opt[u] - 2*w) - 2*w);
 
   for (auto [v, w]: tree[u])
     if (v != parent)
-      compute_supertree_loop_opt(supertree_loop_opt, subtree_loop_opt, tree, v, u, w);
+      compute_supertree_loop_opt(v, u, w);
 }
 
 int main() {
@@ -55,35 +58,34 @@ 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});
   }
 
-  vector<long long> subtree_loop_opt(n);
-  vector<long long> supertree_loop_opt(n);
-  compute_subtree_loop_opt(subtree_loop_opt, tree, tip, 0, -1);
-  compute_supertree_loop_opt(supertree_loop_opt, subtree_loop_opt, tree, 0, -1, -1);
+  subtree_loop_opt.resize(n);
+  compute_subtree_loop_opt(0, 0);
+
+  supertree_loop_opt.resize(n);
+  compute_supertree_loop_opt(0, 0, 0);
 
   for (long i = 0; i < q; ++i) {
-    long src, dst;
-    scanf("%li%li", &src, &dst);
-    assert(src == dst);
+    long L, R;
+    scanf("%li%li", &L, &R);
+    assert(L == R);
 
-    printf("%lli\n", subtree_loop_opt[src-1] + supertree_loop_opt[src-1]);
+    printf("%lli\n", subtree_loop_opt[L-1] + supertree_loop_opt[L-1]);
   }
 
   return 0;