ac-library-rb 0.5.0

data/lib/two_sat.rb

@@ -0,0 +1,34 @@
+require_relative './scc.rb'
+
+# TwoSAT
+# Reference: https://github.com/atcoder/ac-library/blob/master/atcoder/twosat.hpp
+class TwoSAT
+  def initialize(n = 0)
+    @n = n
+    @answer = Array.new(n)
+    @scc = SCCGraph.new(2 * n)
+  end
+
+  attr_reader :answer
+
+  def add_clause(i, f, j, g)
+    raise RangeError unless (0...@n).cover?(i) && (0...@n).cover?(j)
+
+    @scc.add_edge(2 * i + (f ? 0 : 1), 2 * j + (g ? 1 : 0))
+    @scc.add_edge(2 * j + (g ? 0 : 1), 2 * i + (f ? 1 : 0))
+    nil
+  end
+
+  def satisfiable
+    id = @scc.send(:scc_ids)[1]
+    @n.times do |i|
+      return false if id[2 * i] == id[2 * i + 1]
+
+      @answer[i] = id[2 * i] < id[2 * i + 1]
+    end
+    true
+  end
+  alias satisfiable? satisfiable
+end
+
+TwoSat = TwoSAT

data/lib/z_algorithm.rb

@@ -0,0 +1,32 @@
+# this implementation is different from ACL because of calculation time
+# ref : https://snuke.hatenablog.com/entry/2014/12/03/214243
+# ACL  implementation : https://atcoder.jp/contests/abc135/submissions/18836384 (731ms)
+# this implementation : https://atcoder.jp/contests/abc135/submissions/18836378 (525ms)
+
+def z_algorithm(s)
+  n = s.size
+  return [] if n == 0
+
+  s = s.codepoints if s.is_a?(String)
+
+  z = [0] * n
+  z[0] = n
+  i, j = 1, 0
+  while i < n
+    j += 1 while i + j < n && s[j] == s[i + j]
+    z[i] = j
+    if j == 0
+      i += 1
+      next
+    end
+    k = 1
+    while i + k < n && k + z[k] < j
+      z[i + k] = z[k]
+      k += 1
+    end
+    i += k
+    j -= k
+  end
+
+  return z
+end

data/lib_helpers/ac-library-rb/all.rb

@@ -0,0 +1,22 @@
+require_relative "../../lib_lock/ac-library-rb/convolution"
+require_relative "../../lib_lock/ac-library-rb/crt"
+require_relative "../../lib_lock/ac-library-rb/dsu"
+require_relative "../../lib_lock/ac-library-rb/fenwick_tree"
+require_relative "../../lib_lock/ac-library-rb/floor_sum"
+require_relative "../../lib_lock/ac-library-rb/inv_mod"
+require_relative "../../lib_lock/ac-library-rb/lazy_segtree"
+require_relative "../../lib_lock/ac-library-rb/lcp_array"
+require_relative "../../lib_lock/ac-library-rb/max_flow"
+require_relative "../../lib_lock/ac-library-rb/min_cost_flow"
+require_relative "../../lib_lock/ac-library-rb/modint"
+require_relative "../../lib_lock/ac-library-rb/pow_mod"
+require_relative "../../lib_lock/ac-library-rb/priority_queue"
+require_relative "../../lib_lock/ac-library-rb/scc"
+require_relative "../../lib_lock/ac-library-rb/segtree"
+require_relative "../../lib_lock/ac-library-rb/suffix_array"
+require_relative "../../lib_lock/ac-library-rb/two_sat"
+require_relative "../../lib_lock/ac-library-rb/z_algorithm"
+
+# Usage:
+#   require 'ac-library-rb/all'
+#   include AcLibraryRb

data/lib_lock/ac-library-rb.rb

@@ -0,0 +1,22 @@
+module AcLibraryRb
+end
+include AcLibraryRb
+
+require_relative './ac-library-rb/convolution'
+require_relative './ac-library-rb/crt'
+require_relative './ac-library-rb/dsu'
+require_relative './ac-library-rb/fenwick_tree'
+require_relative './ac-library-rb/floor_sum'
+require_relative './ac-library-rb/inv_mod'
+require_relative './ac-library-rb/lazy_segtree'
+require_relative './ac-library-rb/lcp_array'
+require_relative './ac-library-rb/max_flow'
+require_relative './ac-library-rb/min_cost_flow'
+require_relative './ac-library-rb/modint'
+require_relative './ac-library-rb/pow_mod'
+require_relative './ac-library-rb/priority_queue'
+require_relative './ac-library-rb/scc'
+require_relative './ac-library-rb/segtree'
+require_relative './ac-library-rb/suffix_array'
+require_relative './ac-library-rb/two_sat'
+require_relative './ac-library-rb/z_algorithm'

data/lib_lock/ac-library-rb/convolution.rb

@@ -0,0 +1,126 @@
+module AcLibraryRb
+  # usage :
+  #
+  # conv = Convolution.new(mod, [primitive_root])
+  # conv.convolution(a, b) #=> convolution a and b modulo mod.
+  #
+  class Convolution
+    def initialize(mod = 998_244_353, primitive_root = nil)
+      @mod = mod
+
+      cnt2 = bsf(@mod - 1)
+      e = (primitive_root || calc_primitive_root(mod)).pow((@mod - 1) >> cnt2, @mod)
+      ie = e.pow(@mod - 2, @mod)
+
+      es = [0] * (cnt2 - 1)
+      ies = [0] * (cnt2 - 1)
+      cnt2.downto(2){ |i|
+        es[i - 2] = e
+        ies[i - 2] = ie
+        e = e * e % @mod
+        ie = ie * ie % @mod
+      }
+      now = inow = 1
+
+      @sum_e = [0] * cnt2
+      @sum_ie = [0] * cnt2
+      (cnt2 - 1).times{ |i|
+        @sum_e[i] = es[i] * now % @mod
+        now = now * ies[i] % @mod
+        @sum_ie[i] = ies[i] * inow % @mod
+        inow = inow * es[i] % @mod
+      }
+    end
+
+    def convolution(a, b)
+      n = a.size
+      m = b.size
+      return [] if n == 0 || m == 0
+
+      h = (n + m - 2).bit_length
+      raise ArgumentError if h > @sum_e.size
+
+      z = 1 << h
+
+      a = a + [0] * (z - n)
+      b = b + [0] * (z - m)
+
+      batterfly(a, h)
+      batterfly(b, h)
+
+      c = a.zip(b).map{ |a, b| a * b % @mod }
+
+      batterfly_inv(c, h)
+
+      iz = z.pow(@mod - 2, @mod)
+      return c[0, n + m - 1].map{ |c| c * iz % @mod }
+    end
+
+    def batterfly(a, h)
+      1.upto(h){ |ph|
+        w = 1 << (ph - 1)
+        p = 1 << (h - ph)
+        now = 1
+        w.times{ |s|
+          offset = s << (h - ph + 1)
+          offset.upto(offset + p - 1){ |i|
+            l = a[i]
+            r = a[i + p] * now % @mod
+            a[i] = l + r
+            a[i + p] = l - r
+          }
+          now = now * @sum_e[bsf(~s)] % @mod
+        }
+      }
+    end
+
+    def batterfly_inv(a, h)
+      h.downto(1){ |ph|
+        w = 1 << (ph - 1)
+        p = 1 << (h - ph)
+        inow = 1
+        w.times{ |s|
+          offset = s << (h - ph + 1)
+          offset.upto(offset + p - 1){ |i|
+            l = a[i]
+            r = a[i + p]
+            a[i] = l + r
+            a[i + p] = (l - r) * inow % @mod
+          }
+          inow = inow * @sum_ie[bsf(~s)] % @mod
+        }
+      }
+    end
+
+    def bsf(x)
+      (x & -x).bit_length - 1
+    end
+
+    def calc_primitive_root(mod)
+      return 1 if mod == 2
+      return 3 if mod == 998_244_353
+
+      divs = [2]
+      x = (mod - 1) / 2
+      x /= 2 while x.even?
+      i = 3
+      while i * i <= x
+        if x % i == 0
+          divs << i
+          x /= i while x % i == 0
+        end
+        i += 2
+      end
+      divs << x if x > 1
+
+      g = 2
+      loop{
+        return g if divs.none?{ |d| g.pow((mod - 1) / d, mod) == 1 }
+
+        g += 1
+      }
+    end
+
+    private :batterfly, :batterfly_inv, :bsf, :calc_primitive_root
+  end
+end

data/lib_lock/ac-library-rb/core_ext/modint.rb

@@ -0,0 +1,19 @@
+def ModInt(val)
+  ModInt.new(val)
+end
+
+# Integer
+class Integer
+  def to_modint
+    ModInt.new(self)
+  end
+  alias to_m to_modint
+end
+
+# String
+class String
+  def to_modint
+    ModInt.new(to_i)
+  end
+  alias to_m to_modint
+end

data/lib_lock/ac-library-rb/crt.rb

@@ -0,0 +1,54 @@
+module AcLibraryRb
+  # return [rem, mod] or [0, 0] (if no solution)
+  def crt(r, m)
+    raise ArgumentError if r.size != m.size
+
+    n = r.size
+    r0, m0 = 0, 1
+    n.times do |i|
+      raise ArgumentError if m[i] < 1
+
+      r1, m1 = r[i] % m[i], m[i]
+      if m0 < m1
+        r0, r1 = r1, r0
+        m0, m1 = m1, m0
+      end
+
+      if m0 % m1 == 0
+        return [0, 0] if r0 % m1 != r1
+
+        next
+      end
+
+      g, im = inv_gcd(m0, m1)
+      u1 = m1 / g
+      return [0, 0] if (r1 - r0) % g != 0
+
+      x = (r1 - r0) / g * im % u1
+      r0 += x * m0
+      m0 *= u1
+      r0 += m0 if r0 < 0
+    end
+
+    return [r0, m0]
+  end
+
+  # internal method
+  # return [g, x] s.t. g = gcd(a, b), x*a = g (mod b), 0 <= x < b/g
+  def inv_gcd(a, b)
+    a %= b
+    return [b, 0] if a == 0
+
+    s, t = b, a
+    m0, m1 = 0, 1
+    while t > 0
+      u, s = s.divmod(t)
+      m0 -= m1 * u
+      s, t = t, s
+      m0, m1 = m1, m0
+    end
+    m0 += b / s if m0 < 0
+
+    return [s, m0]
+  end
+end

data/lib_lock/ac-library-rb/dsu.rb

@@ -0,0 +1,46 @@
+module AcLibraryRb
+  # Disjoint Set Union
+  class DSU
+    def initialize(n = 0)
+      # root node: -1 * component size
+      # otherwise: parent
+      @parent_or_size = Array.new(n, -1)
+    end
+
+    attr_accessor :parent_or_size
+
+    def merge(a, b)
+      x = leader(a)
+      y = leader(b)
+      return x if x == y
+
+      x, y = y, x if -@parent_or_size[x] < -@parent_or_size[y]
+      @parent_or_size[x] += @parent_or_size[y]
+      @parent_or_size[y] = x
+    end
+    alias unite merge
+
+    def same(a, b)
+      leader(a) == leader(b)
+    end
+    alias same? same
+
+    def leader(a)
+      @parent_or_size[a] < 0 ? a : (@parent_or_size[a] = leader(@parent_or_size[a]))
+    end
+    alias root leader
+    alias find leader
+
+    def size(a)
+      -@parent_or_size[leader(a)]
+    end
+
+    def groups
+      (0 ... @parent_or_size.size).group_by{ |i| leader(i) }.values
+    end
+  end
+
+  UnionFind        = DSU
+  UnionFindTree    = DSU
+  DisjointSetUnion = DSU
+end

data/lib_lock/ac-library-rb/fenwick_tree.rb

@@ -0,0 +1,50 @@
+module AcLibraryRb
+  # Fenwick Tree
+  class FenwickTree
+    attr_reader :data, :size
+
+    def initialize(arg = 0)
+      case arg
+      when Array
+        @size = arg.size
+        @data = [0].concat(arg)
+        (1 ... @size).each do |i|
+          up = i + (i & -i)
+          next if up > @size
+
+          @data[up] += @data[i]
+        end
+      when Integer
+        @size = arg
+        @data = Array.new(@size + 1, 0)
+      else
+        raise ArgumentError
+      end
+    end
+
+    def add(i, x)
+      i += 1
+      while i <= @size
+        @data[i] += x
+        i += (i & -i)
+      end
+    end
+
+    def sum(l, r)
+      _sum(r) - _sum(l)
+    end
+
+    def _sum(i)
+      res = 0
+      while i > 0
+        res += @data[i]
+        i &= i - 1
+      end
+      res
+    end
+  end
+
+  FeTree            = FenwickTree
+  Fetree            = FenwickTree
+  BinaryIndexedTree = FenwickTree
+end

data/lib_lock/ac-library-rb/floor_sum.rb

@@ -0,0 +1,23 @@
+module AcLibraryRb
+  def floor_sum(n, m, a, b)
+    res = 0
+
+    if a >= m
+      res += (n - 1) * n * (a / m) / 2
+      a %= m
+    end
+
+    if b >= m
+      res += n * (b / m)
+      b %= m
+    end
+
+    y_max = (a * n + b) / m
+
+    return res if y_max == 0
+
+    x_max = (m * y_max - b + a - 1) / a
+    res += (n - x_max) * y_max + floor_sum(y_max, a, m, a * x_max - m * y_max + b)
+    res
+  end
+end

data/lib_lock/ac-library-rb/inv_mod.rb

@@ -0,0 +1,28 @@
+module AcLibraryRb
+  # Use `x.pow(m - 2, m)` instead of `inv_mod(x, m)` if m is a prime number.
+  def inv_mod(x, m)
+    z = _inv_gcd(x, m)
+    raise ArgumentError unless z.first == 1
+
+    z[1]
+  end
+
+  def _inv_gcd(a, b)
+    a %= b # safe_mod
+
+    s, t = b, a
+    m0, m1 = 0, 1
+
+    while t > 0
+      u = s / t
+      s -= t * u
+      m0 -= m1 * u
+
+      s, t = t, s
+      m0, m1 = m1, m0
+    end
+
+    m0 += b / s if m0 < 0
+    [s, m0]
+  end
+end