fix: reduce PalindromicTree memory consumption

Fixes #1

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: mdonaka

Library/String/PalindromicTree.hpp

@@ -1,203 +1,153 @@
 #pragma once
-#include <iostream>
-#include <list>
-#include <memory>
+#include <algorithm>
 #include <queue>
 #include <stack>
 #include <string>
-#include <unordered_map>
 #include <vector>
 
 namespace mtd {
-  auto nullLambda = [](int, const std::list<int>&) {};
   class PalindromicTree {
-    // static constexpr auto nullLambda = [](int, const std::list<int>&) {};//
-    // c++17
-
-    class Node : public std::enable_shared_from_this<Node> {
-      // 回文の右端itr
-      std::list<int> m_itrs;
-      // 回文サイズ
-      const int m_size;
-
-      // 最大の回文接尾辞
-      std::weak_ptr<Node> m_suffixLink;
-      // 次サイズの回文(囲む文字, 次のNode)
-      std::unordered_map<char, std::shared_ptr<Node>> m_edges;
-
-      // xAxとなるAを探す(x=str[itr])
-      auto find(int itr, const std::string& s) {
-        auto p = this->weak_from_this();
-        while (true) {
-          auto size = p.lock()->m_size;
-          // rootにたどり着いた
-          if (size == -1) { return p; }
-          // 現在地"A"において"xAx"となる
-          if (itr - size - 1 >= 0 && s[itr] == s[itr - size - 1]) { return p; }
-          p = p.lock()->m_suffixLink;
+    struct Node {
+      int size;
+      int suffix_link;
+      int first_itr = -1;
+      std::vector<std::pair<char, int>> edges;
+      std::vector<int> rest_itrs;
+
+      Node(int s, int sl) : size(s), suffix_link(sl) {}
+
+      auto find_edge(char c) const -> int {
+        for (const auto& [ch, idx] : edges) {
+          if (ch == c) { return idx; }
         }
+        return -1;
       }
 
-      // 新しい回文Nodeを作成する
-      auto create(int itr, const std::string& s) {
-        // suffixLinkの探索
-        auto suffixLinkFrom =
-            m_suffixLink.lock() /*->m_suffixLink.lock()*/->find(itr, s).lock();
-        // 新Nodeの作成
-        auto newNode = std::make_shared<Node>(
-            m_size + 2, (suffixLinkFrom->m_edges.find(s[itr]) ==
-                         suffixLinkFrom->m_edges.end())
-                            ? suffixLinkFrom->m_edges.find(' ')->second
-                            : suffixLinkFrom->m_edges.find(s[itr])->second);
-        m_edges.emplace(s[itr], newNode);
-        return std::weak_ptr<Node>(newNode);
-      }
-
-    public:
-      // constructor
-      Node(int size, const std::weak_ptr<Node>& suffixLink)
-          : m_size(size), m_suffixLink(suffixLink) {}
-      Node() : m_size(-1) {}
-
-      // 次サイズの回文を追加
-      auto add(int itr, const std::string& s) {
-        auto addRoot = find(itr, s).lock();
-        auto nextNode =
-            (addRoot->m_edges.find(s[itr]) == addRoot->m_edges.end())
-                ? addRoot->create(itr, s)
-                : std::weak_ptr<Node>(addRoot->m_edges.find(s[itr])->second);
-        nextNode.lock()->m_itrs.emplace_back(itr);
-        return nextNode;
-      }
+      auto add_edge(char c, int idx) -> void { edges.emplace_back(c, idx); }
 
-      // debug用
-      auto outputTree(const std::string& s) const -> void {
-        if (m_size <= 0) {
-          std::cerr << "root";
+      auto add_itr(int itr) -> void {
+        if (first_itr == -1) {
+          first_itr = itr;
         } else {
-          // 段
-          for (int i = 0; (i < (m_size + 1) / 2); ++i) { std::cerr << " |"; }
-          std::cerr << "- " << s.substr(*m_itrs.begin() - m_size + 1, m_size);
-          // 右itr
-          std::cerr << " [ ";
-          for (const auto& itr : m_itrs) { std::cerr << itr << " "; }
-          std::cerr << "] ";
-          // suffix link
-          // auto p = m_suffixLink.lock();
-          // std::cerr << "{" << s.substr(*p->m_itrs.begin() - p->m_size + 1,
-          // p->m_size) << "} ";
-        }
-        std::cerr << "\n";
-        for (const auto& edge : m_edges) {
-          if (m_size == -1 && edge.first == ' ') { continue; }
-          edge.second->outputTree(s);
+          rest_itrs.push_back(itr);
         }
       }
 
-      // rootを決定
-      auto isOddRoot(const std::weak_ptr<Node>& evenRoot) {
-        m_suffixLink = weak_from_this();
-        m_edges.emplace(' ', evenRoot);
+      auto get_itrs() const -> std::vector<int> {
+        if (first_itr == -1) { return {}; }
+        std::vector<int> result;
+        result.reserve(1 + rest_itrs.size());
+        result.push_back(first_itr);
+        result.insert(result.end(), rest_itrs.begin(), rest_itrs.end());
+        return result;
       }
+    };
 
-      // ラムダ式の実行
-      template <class Lambda>
-      auto runLambda(const Lambda& lambda) {
-        if (m_size > 0) { lambda(m_size, m_itrs); }
+    const std::string m_s;
+    std::vector<Node> m_nodes;
+    static constexpr int ROOT_ODD = 0;
+    static constexpr int ROOT_EVEN = 1;
+
+    auto find(int node_idx, int itr) const -> int {
+      while (true) {
+        int size = m_nodes[node_idx].size;
+        if (size == -1) { return node_idx; }
+        if (itr - size - 1 >= 0 && m_s[itr] == m_s[itr - size - 1]) {
+          return node_idx;
+        }
+        node_idx = m_nodes[node_idx].suffix_link;
       }
+    }
 
-      /*
-       * lambda: (int size, list<int> rItr) -> void
-       */
-      template <class Lambda, class SuffixLinkLambda = decltype(nullLambda)>
-      auto dfs_edges(const Lambda& lambda,
-                     const SuffixLinkLambda& slLambda = nullLambda) -> void {
-        std::stack<std::shared_ptr<Node>, std::vector<std::shared_ptr<Node>>>
-            stk;
-        stk.emplace(this->weak_from_this().lock());
-        while (!stk.empty()) {
-          auto p = stk.top();
-          stk.pop();
-          p->runLambda(lambda);
-          p->m_suffixLink.lock()->runLambda(slLambda);
-          for (const auto& [_, next_p] : p->m_edges) {
-            // std::cerr << p->m_size << " -> " << next_p->m_size << std::endl;
-            stk.emplace(next_p);
-          }
-        }
+    auto add(int node_idx, int itr) -> int {
+      int add_root = find(node_idx, itr);
+      char c = m_s[itr];
+
+      int existing = m_nodes[add_root].find_edge(c);
+      if (existing != -1) {
+        m_nodes[existing].add_itr(itr);
+        return existing;
       }
-    };
 
-    // 対象となる文字列
-    const std::string m_s;
+      int new_size = m_nodes[add_root].size + 2;
+      int suffix_link_from = find(m_nodes[add_root].suffix_link, itr);
+
+      int new_suffix_link = m_nodes[suffix_link_from].find_edge(c);
+      if (new_suffix_link == -1) { new_suffix_link = ROOT_EVEN; }
 
-    // 偶数長，奇数長のPalindromicTreeの根(0, -1)
-    std::shared_ptr<Node> m_rootOdd;
-    std::shared_ptr<Node> m_rootEven;
+      int new_idx = static_cast<int>(m_nodes.size());
+      m_nodes.emplace_back(new_size, new_suffix_link);
+      m_nodes[new_idx].add_itr(itr);
+      m_nodes[add_root].add_edge(c, new_idx);
+
+      return new_idx;
+    }
 
   public:
-    // constructor
-    PalindromicTree(const std::string& s)
-        : m_s(s),
-          m_rootOdd(std::make_shared<Node>()),
-          m_rootEven(std::make_shared<Node>(0, m_rootOdd)) {
-      m_rootOdd->isOddRoot(m_rootEven);
-      auto root = m_rootOdd;
-      for (int r = 0; r < static_cast<int>(s.size()); ++r) {
-        root = root->add(r, s).lock();
+    PalindromicTree(const std::string& s) : m_s(s) {
+      m_nodes.reserve(s.size() + 2);
+      m_nodes.emplace_back(-1, ROOT_ODD);
+      m_nodes.emplace_back(0, ROOT_ODD);
+
+      int cur = ROOT_ODD;
+      for (int i = 0; i < static_cast<int>(s.size()); ++i) { cur = add(cur, i); }
+
+      m_nodes.shrink_to_fit();
+      for (auto& node : m_nodes) {
+        node.edges.shrink_to_fit();
+        node.rest_itrs.shrink_to_fit();
       }
     }
 
-    /*
-     * lambda: (int size, list<int> rItr) -> void
-     */
     template <class Lambda>
-    auto dfs_edges(const Lambda& lambda) {
-      m_rootOdd->dfs_edges(lambda);
+    auto dfs_edges(const Lambda& lambda) const -> void {
+      std::stack<int, std::vector<int>> stk;
+      stk.push(ROOT_ODD);
+      stk.push(ROOT_EVEN);
+
+      while (!stk.empty()) {
+        int idx = stk.top();
+        stk.pop();
+
+        const auto& node = m_nodes[idx];
+        if (node.size > 0) { lambda(node.size, node.get_itrs()); }
+
+        for (const auto& [_, next_idx] : node.edges) { stk.push(next_idx); }
+      }
     }
 
-    /*
-     * かなり強引な実装
-     * lambda: (int from, int to) -> void
-     */
     template <class Lambda>
-    auto dp_suffixLink(const Lambda& lambda) {
-      // 森の生成，探索順序の決定
-      int from;
-      std::unordered_map<int, int> graph;
-      std::vector<int> orderCount(m_s.size());
-      m_rootOdd->dfs_edges(
-          [&](int, const std::list<int>& rItrs) { from = rItrs.front(); },
-          [&](int, const std::list<int>& rItrs) {
-            int to = rItrs.front();
-            graph.emplace(from, to);
-            ++orderCount[to];
-          });
-      // 探索順序に従って処理
-      std::queue<int, std::list<int>> q;
+    auto dp_suffixLink(const Lambda& lambda) const -> void {
+      std::vector<int> order_count(m_s.size(), 0);
+      std::vector<std::vector<int>> graph(m_s.size());
+
+      for (int idx = 2; idx < static_cast<int>(m_nodes.size()); ++idx) {
+        const auto& node = m_nodes[idx];
+        if (node.first_itr == -1) { continue; }
+
+        int from = node.first_itr;
+        int sl_idx = node.suffix_link;
+        if (sl_idx >= 2 && m_nodes[sl_idx].first_itr != -1) {
+          int to = m_nodes[sl_idx].first_itr;
+          graph[from].push_back(to);
+          ++order_count[to];
+        }
+      }
+
+      std::queue<int> q;
       for (int i = 0; i < static_cast<int>(m_s.size()); ++i) {
-        if (orderCount[i] == 0) { q.emplace(i); }
+        if (order_count[i] == 0) { q.push(i); }
       }
+
       while (!q.empty()) {
         int f = q.front();
         q.pop();
-        auto range = graph.equal_range(f);
-        for (auto itr = range.first; itr != range.second; ++itr) {
-          int t = itr->second;
-          --orderCount[t];
+        for (int t : graph[f]) {
+          --order_count[t];
           lambda(f, t);
-          if (orderCount[t] == 0) { q.emplace(t); }
+          if (order_count[t] == 0) { q.push(t); }
         }
       }
     }
-
-    // debug用
-    auto outputTree() {
-      std::cerr << m_s << std::endl;
-      std::cerr << "-- even --\n";
-      m_rootEven->outputTree(m_s);
-      std::cerr << "-- odd --\n";
-      m_rootOdd->outputTree(m_s);
-    }
   };
 }  // namespace mtd

Test/String/PalindromicTree_large.test.cpp

@@ -25,7 +25,7 @@ signed main() {
 
   ll an = a.size();
   std::vector<std::pair<ll, ll>> dp(s.size());
-  tree.dfs_edges([&](int size, const std::list<int>& ritr) {
+  tree.dfs_edges([&](int size, const std::vector<int>& ritr) {
     ll l = 0, r = 0;
     for (const auto& x : ritr)
       if (x != an && x != an + 1) { ++((x < an) ? l : r); }