ac-library-rb 0.5.0

data/lib/ac-library-rb/version.rb

@@ -0,0 +1,3 @@
+module AcLibraryRb
+  VERSION = "0.5.0".freeze
+end

data/lib/convolution.rb

@@ -0,0 +1,124 @@
+# 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

data/lib/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/crt.rb

@@ -0,0 +1,52 @@
+# 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

data/lib/dsu.rb

@@ -0,0 +1,44 @@
+# 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

data/lib/fenwick_tree.rb

@@ -0,0 +1,48 @@
+# 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

data/lib/floor_sum.rb

@@ -0,0 +1,21 @@
+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

data/lib/inv_mod.rb

@@ -0,0 +1,26 @@
+# 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

data/lib/lazy_segtree.rb

@@ -0,0 +1,149 @@
+# Segment tree with Lazy propagation
+class LazySegtree
+  attr_reader   :d, :lz
+  attr_accessor :op, :mapping, :composition
+
+  def initialize(v, e, id, op, mapping, composition)
+    v = Array.new(v, e) if v.is_a?(Integer)
+
+    @n  = v.size
+    @e  = e
+    @id = id
+    @op = op
+    @mapping = mapping
+    @composition = composition
+
+    @log  = (@n - 1).bit_length
+    @size = 1 << @log
+    @d    = Array.new(2 * @size, e)
+    @lz   = Array.new(@size, id)
+
+    @n.times { |i| @d[@size + i] = v[i] }
+    (@size - 1).downto(1) { |i| update(i) }
+  end
+
+  def set(pos, x)
+    pos += @size
+    @log.downto(1) { |i| push(pos >> i) }
+    @d[pos] = x
+    1.upto(@log) { |i| update(pos >> i) }
+  end
+
+  def get(pos)
+    pos += @size
+    @log.downto(1) { |i| push(pos >> i) }
+    @d[pos]
+  end
+
+  def prod(l, r)
+    return @e if l == r
+
+    l += @size
+    r += @size
+
+    @log.downto(1) do |i|
+      push(l >> i) if (l >> i) << i != l
+      push(r >> i) if (r >> i) << i != r
+    end
+
+    sml = @e
+    smr = @e
+    while l < r
+      if l.odd?
+        sml = @op.call(sml, @d[l])
+        l += 1
+      end
+      if r.odd?
+        r -= 1
+        smr = @op.call(@d[r], smr)
+      end
+      l >>= 1
+      r >>= 1
+    end
+
+    @op.call(sml, smr)
+  end
+
+  def all_prod
+    @d[1]
+  end
+
+  def apply(pos, f)
+    pos += @size
+    @log.downto(1) { |i| push(pos >> i) }
+    @d[pos] = @mapping.call(f, @d[pos])
+    1.upto(@log) { |i| update(pos >> i) }
+  end
+
+  def range_apply(l, r, f)
+    return if l == r
+
+    l += @size
+    r += @size
+
+    @log.downto(1) do |i|
+      push(l >> i) if (l >> i) << i != l
+      push((r - 1) >> i) if (r >> i) << i != r
+    end
+
+    l2 = l
+    r2 = r
+    while l < r
+      (all_apply(l, f); l += 1) if l.odd?
+      (r -= 1; all_apply(r, f)) if r.odd?
+      l >>= 1
+      r >>= 1
+    end
+    l = l2
+    r = r2
+
+    1.upto(@log) do |i|
+      update(l >> i)       if (l >> i) << i != l
+      update((r - 1) >> i) if (r >> i) << i != r
+    end
+  end
+
+  def max_right(l, &g)
+    return @n if l == @n
+
+    l += @size
+    @log.downto(1) { |i| push(l >> i) }
+    sm = @e
+
+    loop do
+      while l.even?
+        l >>= 1
+      end
+      unless g.call(@op.call(sm, @d[l]))
+        while l < @size
+          push(l)
+          l <<= 1
+          if g.call(@op.call(sm, @d[l]))
+            sm = @op.call(sm, @d[l])
+            l += 1
+          end
+        end
+        return l - @size
+      end
+      sm = @op.call(sm, @d[l])
+      l += 1
+      break if l & -l == l
+    end
+    @n
+  end
+
+  def update(k)
+    @d[k] = @op.call(@d[2 * k], @d[2 * k + 1])
+  end
+
+  def all_apply(k, f)
+    @d[k]  = @mapping.call(f, @d[k])
+    @lz[k] = @composition.call(f, @lz[k]) if k < @size
+  end
+
+  def push(k)
+    all_apply(2 * k,     @lz[k])
+    all_apply(2 * k + 1, @lz[k])
+    @lz[k] = @id
+  end
+end