Redesign tree/euler-tour

aoj/GRL/GRL5D/main.cpp

@@ -1,45 +1,49 @@
-#include <vector>
-#include <stack>
+//https://onlinejudge.u-aizu.ac.jp/problems/GRL_5_D
 
-class EulerTrour {
-    int N;
-    std::vector<std::vector<int>> adj;
+#include <bits/stdc++.h>
+
+class EulerTour {
+private:
+    size_t N;
+    std::vector<std::vector<size_t>> adj;
 
 public:
-    // O(V)
-    EulerTrour(int size): N(size), adj(size) {}
-    // O(1)
-    int size() {
+    // Time: O(V)
+    EulerTour(size_t const N = 0): N(N), adj(N) {}
+    // Time: O(1)
+    size_t size() const {
         return N;
     }
-    // O(1)
-    void add_edge(int u, int v) {
-        throw_if_invalid_index(u);
-        throw_if_invalid_index(v);
+    // u = [0,N), v = [0,N)
+    // Time: O(1)
+    void add_edge(size_t const u, size_t const v) {
+        if (u >= N) throw std::out_of_range("u");
+        if (v >= N) throw std::out_of_range("v");
         adj[u].push_back(v);
         adj[v].push_back(u);
     }
-    // O(E)
-    void solve(int r, std::vector<int>& tour, std::vector<int>& tin, std::vector<int>& tout) {
-        throw_if_invalid_index(r);
+    // r = [0,N)
+    // Time: O(E)
+    void solve(size_t r, std::vector<size_t>& tour, std::vector<size_t>& tin, std::vector<size_t>& tout) const {
+        if (r >= N) throw std::out_of_range("r");
 
-        std::stack<std::pair<int,int>> S;
+        std::stack<std::pair<size_t,int>> S;
         std::vector<bool> visited(N, false);
 
         tour.clear();
-        tin.assign(N, -1);
-        tout.assign(N, -1);
+        tin.assign(N, 2 * N);
+        tout.assign(N, 2 * N);
 
         S.push({r,-1});
         while (S.size()) {
-            int v = S.top().first;
+            size_t v = S.top().first;
             int& i = S.top().second;
             if (i < 0) {
                 visited[v] = true;
                 tour.push_back(v);
                 tin[v] = tour.size() - 1;
-            } else if (i < adj[v].size()) {
-                int u = adj[v][i];
+            } else if (size_t(i) < adj[v].size()) {
+                auto u = adj[v][i];
                 if (!visited[u]) S.push({u,-1});
             } else {
                 tour.push_back(v);
@@ -49,20 +53,8 @@ class EulerTrour {
             i++;
         }
     }
-
-private:
-    void throw_if_invalid_index(int index) {
-        if (index < 0 || index >= N) throw "index out of range";
-    }
 };
 
-#include <vector>
-#include <functional>
-
-// BinaryIndexedTree
-// Memory O(N)
-// Query O(logN)
-// Update O(logN)
 template <class T = long long>
 class BinaryIndexedTree {
 public:
@@ -132,8 +124,6 @@ class BinaryIndexedTree {
 };
 
 
-#include <iostream>
-
 using namespace std;
 
 int main() {
@@ -143,7 +133,7 @@ int main() {
     int N, Q;
 
     cin >> N;
-    EulerTrour euler_tour(N);
+    EulerTour euler_tour(N);
     for (int i = 0; i < N; ++i) {
         int K, c;
         cin >> K;
@@ -153,7 +143,7 @@ int main() {
         }
     }
 
-    vector<int> tour, tin, tout;
+    vector<size_t> tour, tin, tout;
     euler_tour.solve(0, tour, tin, tout);
     BinaryIndexedTree<long long> bit(2*N);
 

aoj/GRL/GRL5D/sample1.txt

@@ -0,0 +1,15 @@
+6
+2 1 2
+2 3 5
+0
+0
+0
+1 4
+7
+1 1
+0 3 10
+1 2
+0 4 20
+1 3
+0 5 40
+1 4

aoj/GRL/GRL5D/sample2.txt

@@ -0,0 +1,12 @@
+4
+1 1
+1 2
+1 3
+0
+6
+0 3 1000
+0 2 1000
+0 1 1000
+1 1
+1 2
+1 3

aoj/GRL/GRL5D/sample3.txt

@@ -0,0 +1,8 @@
+2
+1 1
+0
+4
+0 1 1
+1 1
+0 1 1
+1 1

lib/cpalgo/tree/euler_tour.hpp

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <stack>
+#include <stdexcept>
+#include <vector>
+
+
+// Euler Tour in Tree
+//
+// Space: O(V + E)
+//
+// NOTE:
+//  - undirected
+//  - non-loop
+//  - non-multi-edge
+//  - it can handle a forest
+//
+// Verified:
+//  - https://onlinejudge.u-aizu.ac.jp/problems/GRL_5_D
+//
+class EulerTour {
+private:
+    size_t N;
+    std::vector<std::vector<size_t>> adj;
+
+public:
+    // Time: O(V)
+    EulerTour(size_t const N = 0): N(N), adj(N) {}
+    // Time: O(1)
+    size_t size() const {
+        return N;
+    }
+    // u = [0,N), v = [0,N)
+    // Time: O(1)
+    void add_edge(size_t const u, size_t const v) {
+        if (u >= N) throw std::out_of_range("u");
+        if (v >= N) throw std::out_of_range("v");
+        adj[u].push_back(v);
+        adj[v].push_back(u);
+    }
+    // r = [0,N)
+    // Time: O(E)
+    void solve(size_t r, std::vector<size_t>& tour, std::vector<size_t>& tin, std::vector<size_t>& tout) const {
+        if (r >= N) throw std::out_of_range("r");
+
+        std::stack<std::pair<size_t,int>> S;
+        std::vector<bool> visited(N, false);
+
+        tour.clear();
+        tin.assign(N, 2 * N);
+        tout.assign(N, 2 * N);
+
+        S.push({r,-1});
+        while (S.size()) {
+            size_t v = S.top().first;
+            int& i = S.top().second;
+            if (i < 0) {
+                visited[v] = true;
+                tour.push_back(v);
+                tin[v] = tour.size() - 1;
+            } else if (size_t(i) < adj[v].size()) {
+                auto u = adj[v][i];
+                if (!visited[u]) S.push({u,-1});
+            } else {
+                tour.push_back(v);
+                tout[v] = tour.size() - 1;
+                S.pop();
+            }
+            i++;
+        }
+    }
+};

lib/cpalgo/tree/tests/euler_touer_test.cpp

@@ -0,0 +1,53 @@
+#include <bits/stdc++.h>
+#include "gtest/gtest.h"
+#include "cpalgo/tree/euler_tour.hpp"
+
+using namespace std;
+
+
+TEST(EulerTourTest, IsEmptyInitially) {
+    EulerTour solver;
+    EXPECT_EQ(0ULL, solver.size());
+}
+
+TEST(EulerTourTest, ShouldComputeEulerTour) {
+    EulerTour solver(7);
+    EXPECT_EQ(7ULL, solver.size());
+
+    solver.add_edge(0, 1);
+    solver.add_edge(1, 2);
+    solver.add_edge(1, 3);
+    solver.add_edge(0, 4);
+    solver.add_edge(0, 5);
+    solver.add_edge(5, 6);
+
+    vector<size_t> tour, tin, tout;
+    solver.solve(0, tour, tin, tout);
+
+    vector<size_t> expected_tour = { 0, 1, 2, 2, 3, 3, 1, 4, 4, 5, 6, 6, 5, 0 };
+    vector<size_t> expected_tin = { 0, 1, 2, 4, 7, 9, 10 };
+    vector<size_t> expected_tout = { 13, 6, 3, 5, 8, 12, 11 };
+    EXPECT_EQ(expected_tour, tour);
+    EXPECT_EQ(expected_tin, tin);
+    EXPECT_EQ(expected_tout, tout);
+}
+
+TEST(EulerTourTest, ShouldHandleAForest) {
+    EulerTour solver(7);
+    EXPECT_EQ(7ULL, solver.size());
+
+    solver.add_edge(0, 1);
+    solver.add_edge(1, 2);
+    solver.add_edge(1, 3);
+    solver.add_edge(5, 6);
+
+    vector<size_t> tour, tin, tout;
+    solver.solve(0, tour, tin, tout);
+
+    vector<size_t> expected_tour = { 0, 1, 2, 2, 3, 3, 1, 0 };
+    vector<size_t> expected_tin = { 0, 1, 2, 4, 14, 14, 14 };
+    vector<size_t> expected_tout = { 7, 6, 3, 5, 14, 14, 14 };
+    EXPECT_EQ(expected_tour, tour);
+    EXPECT_EQ(expected_tin, tin);
+    EXPECT_EQ(expected_tout, tout);
+}