ac-library-rb 0.5.0

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

@@ -0,0 +1,172 @@
+module AcLibraryRb
+  require_relative './core_ext/modint.rb'
+
+  # ModInt
+  class ModInt < Numeric
+    class << self
+      def set_mod(mod)
+        raise ArgumentError unless mod.is_a? Integer and 1 <= mod
+
+        $_mod = mod
+        $_mod_is_prime = ModInt.prime?(mod)
+      end
+
+      def mod=(mod)
+        set_mod mod
+      end
+
+      def mod
+        $_mod
+      end
+
+      def raw(val)
+        x = allocate
+        x.val = val.to_i
+        x
+      end
+
+      def prime?(n)
+        return false if n <= 1
+        return true if n == 2 or n == 7 or n == 61
+        return false if (n & 1) == 0
+
+        d = n - 1
+        d >>= 1 while (d & 1) == 0
+        [2, 7, 61].each do |a|
+          t = d
+          y = a.pow(t, n)
+          while t != n - 1 and y != 1 and y != n - 1
+            y = y * y % n
+            t <<= 1
+          end
+          return false if y != n - 1 and (t & 1) == 0
+        end
+        true
+      end
+
+      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 / 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
+
+    attr_accessor :val
+
+    alias to_i val
+
+    def initialize(val = 0)
+      @val = val.to_i % $_mod
+    end
+
+    def inc!
+      @val += 1
+      @val = 0 if @val == $_mod
+      self
+    end
+
+    def dec!
+      @val = $_mod if @val == 0
+      @val -= 1
+      self
+    end
+
+    def add!(other)
+      @val = (@val + other.to_i) % $_mod
+      self
+    end
+
+    def sub!(other)
+      @val = (@val - other.to_i) % $_mod
+      self
+    end
+
+    def mul!(other)
+      @val = @val * other.to_i % $_mod
+      self
+    end
+
+    def div!(other)
+      mul! inv_internal(other.to_i)
+    end
+
+    def +@
+      self
+    end
+
+    def -@
+      ModInt.raw($_mod - @val)
+    end
+
+    def **(other)
+      $_mod == 1 ? 0 : ModInt.raw(@val.pow(other, $_mod))
+    end
+    alias pow **
+
+    def inv
+      ModInt.raw(inv_internal(@val) % $_mod)
+    end
+
+    def coerce(other)
+      [ModInt(other), self]
+    end
+
+    def +(other)
+      dup.add! other
+    end
+
+    def -(other)
+      dup.sub! other
+    end
+
+    def *(other)
+      dup.mul! other
+    end
+
+    def /(other)
+      dup.div! other
+    end
+
+    def ==(other)
+      @val == other.to_i
+    end
+
+    def dup
+      ModInt.raw(@val)
+    end
+
+    def to_int
+      @val
+    end
+
+    def to_s
+      @val.to_s
+    end
+
+    def inspect
+      "#{@val} mod #{$_mod}"
+    end
+
+    private
+
+    def inv_internal(a)
+      if $_mod_is_prime
+        a != 0 ? a.pow($_mod - 2, $_mod) : raise(RangeError, 'no inverse')
+      else
+        g, x = ModInt.inv_gcd(a, $_mod)
+        g == 1 ? x : raise(RangeError, 'no inverse')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module AcLibraryRb
+  # Use `Integer#pow` unless m == 1
+  def pow_mod(x, n, m)
+    return 0 if m == 1
+
+    r, y = 1, x % m
+    while n > 0
+      r = r * y % m if n.odd?
+      y = y * y % m
+      n >>= 1
+    end
+
+    r
+  end
+end

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

@@ -0,0 +1,91 @@
+module AcLibraryRb
+  # Priority Queue
+  # Reference: https://github.com/python/cpython/blob/master/Lib/heapq.py
+  class PriorityQueue
+    # By default, the priority queue returns the maximum element first.
+    # If a block is given, the priority between the elements is determined with it.
+    # For example, the following block is given, the priority queue returns the minimum element first.
+    # `PriorityQueue.new { |x, y| x < y }`
+    #
+    # A heap is an array for which a[k] <= a[2*k+1] and a[k] <= a[2*k+2] for all k, counting elements from 0.
+    def initialize(array = [], &comp)
+      @heap = array
+      @comp = comp || proc { |x, y| x > y }
+      heapify
+    end
+
+    attr_reader :heap
+
+    # Push new element to the heap.
+    def push(item)
+      shift_down(0, @heap.push(item).size - 1)
+    end
+
+    alias << push
+    alias append push
+
+    # Pop the element with the highest priority.
+    def pop
+      latest = @heap.pop
+      return latest if empty?
+
+      ret_item = heap[0]
+      heap[0] = latest
+      shift_up(0)
+      ret_item
+    end
+
+    # Get the element with the highest priority.
+    def get
+      @heap[0]
+    end
+
+    alias top get
+
+    # Returns true if the heap is empty.
+    def empty?
+      @heap.empty?
+    end
+
+    private
+
+    def heapify
+      (@heap.size / 2 - 1).downto(0) { |i| shift_up(i) }
+    end
+
+    def shift_up(pos)
+      end_pos = @heap.size
+      start_pos = pos
+      new_item = @heap[pos]
+      left_child_pos = 2 * pos + 1
+
+      while left_child_pos < end_pos
+        right_child_pos = left_child_pos + 1
+        if right_child_pos < end_pos && @comp.call(@heap[right_child_pos], @heap[left_child_pos])
+          left_child_pos = right_child_pos
+        end
+        # Move the higher priority child up.
+        @heap[pos] = @heap[left_child_pos]
+        pos = left_child_pos
+        left_child_pos = 2 * pos + 1
+      end
+      @heap[pos] = new_item
+      shift_down(start_pos, pos)
+    end
+
+    def shift_down(star_pos, pos)
+      new_item = @heap[pos]
+      while pos > star_pos
+        parent_pos = (pos - 1) >> 1
+        parent = @heap[parent_pos]
+        break if @comp.call(parent, new_item)
+
+        @heap[pos] = parent
+        pos = parent_pos
+      end
+      @heap[pos] = new_item
+    end
+  end
+
+  HeapQueue = PriorityQueue
+end

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

@@ -0,0 +1,79 @@
+module AcLibraryRb
+  # Strongly Connected Components
+  class SCCGraph
+    # initialize graph with n vertices
+    def initialize(n = 0)
+      @n, @edges = n, []
+    end
+
+    # add directed edge
+    def add_edge(from, to)
+      raise "invalid params" unless (0...@n).include? from and (0...@n).include? to
+
+      @edges << [from, to]
+    end
+
+    # returns list of strongly connected components
+    # the components are sorted in topological order
+    # O(@n + @edges.size)
+    def scc
+      group_num, ids = scc_ids
+      counts = [0] * group_num
+      ids.each { |x| counts[x] += 1 }
+      groups = Array.new(group_num) { [] }
+      ids.each_with_index { |x, i| groups[x] << i }
+      groups
+    end
+
+    private
+
+    def scc_ids
+      start, elist = csr
+      now_ord = group_num = 0
+      visited, low, ord, ids = [], [], [-1] * @n, []
+      dfs = ->(v) {
+        low[v] = ord[v] = now_ord
+        now_ord += 1
+        visited << v
+        (start[v]...start[v + 1]).each do |i|
+          to = elist[i]
+          low[v] = if ord[to] == -1
+                     dfs.(to)
+                     [low[v], low[to]].min
+                   else
+                     [low[v], ord[to]].min
+                   end
+        end
+        if low[v] == ord[v]
+          loop do
+            u = visited.pop
+            ord[u] = @n
+            ids[u] = group_num
+            break if u == v
+          end
+          group_num += 1
+        end
+      }
+      @n.times { |i| dfs.(i) if ord[i] == -1 }
+      ids = ids.map { |x| group_num - 1 - x }
+      [group_num, ids]
+    end
+
+    def csr
+      start, elist = [0] * (@n + 1), [nil] * @edges.size
+      @edges.each { |(i, _)| start[i + 1] += 1 }
+      @n.times { |i| start[i + 1] += start[i] }
+      counter = start.dup
+      @edges.each do |(i, j)|
+        elist[counter[i]] = j
+        counter[i] += 1
+      end
+      [start, elist]
+    end
+  end
+
+  # class alias
+  StronglyConnectedComponents = SCCGraph
+  SCC  = SCCGraph
+  SCCG = SCCGraph
+end

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

@@ -0,0 +1,142 @@
+module AcLibraryRb
+  # Segment Tree
+  class Segtree
+    attr_reader :d, :op, :n, :leaf_size, :log
+
+    def initialize(arg = 0, e, &block)
+      case arg
+      when Integer
+        v = Array.new(arg) { e }
+      when Array
+        v = arg
+      end
+
+      @e  = e
+      @op = proc(&block)
+
+      @n = v.size
+      @log = (@n - 1).bit_length
+      @leaf_size = 1 << @log
+      @d = Array.new(@leaf_size * 2) { e }
+      v.each_with_index { |v_i, i| @d[@leaf_size + i] = v_i }
+      (@leaf_size - 1).downto(1) { |i| update(i) }
+    end
+
+    def set(q, x)
+      q += @leaf_size
+      @d[q] = x
+      1.upto(@log) { |i| update(q >> i) }
+    end
+
+    def get(pos)
+      @d[@leaf_size + pos]
+    end
+
+    def prod(l, r)
+      return @e if l == r
+
+      sml = @e
+      smr = @e
+      l += @leaf_size
+      r += @leaf_size
+
+      while l < r
+        if l[0] == 1
+          sml = @op.call(sml, @d[l])
+          l += 1
+        end
+        if r[0] == 1
+          r -= 1
+          smr = @op.call(@d[r], smr)
+        end
+        l /= 2
+        r /= 2
+      end
+
+      @op.call(sml, smr)
+    end
+
+    def all_prod
+      @d[1]
+    end
+
+    def max_right(l, &block)
+      return @n if l == @n
+
+      f = proc(&block)
+
+      l += @leaf_size
+      sm = @e
+      loop do
+        l /= 2 while l.even?
+        unless f.call(@op.call(sm, @d[l]))
+          while l < @leaf_size
+            l *= 2
+            if f.call(@op.call(sm, @d[l]))
+              sm = @op.call(sm, @d[l])
+              l += 1
+            end
+          end
+
+          return l - @leaf_size
+        end
+
+        sm = @op.call(sm, @d[l])
+        l += 1
+        break if (l & -l) == l
+      end
+
+      @n
+    end
+
+    def min_left(r, &block)
+      return 0 if r == 0
+
+      f = proc(&block)
+
+      r += @leaf_size
+      sm = @e
+      loop do
+        r -= 1
+        r /= 2 while r > 1 && r.odd?
+        unless f.call(@op.call(@d[r], sm))
+          while r < @leaf_size
+            r = r * 2 + 1
+            if f.call(@op.call(@d[r], sm))
+              sm = @op.call(@d[r], sm)
+              r -= 1
+            end
+          end
+
+          return r + 1 - @leaf_size
+        end
+
+        sm = @op.call(@d[r], sm)
+        break if (r & -r) == r
+      end
+
+      0
+    end
+
+    def update(k)
+      @d[k] = @op.call(@d[2 * k], @d[2 * k + 1])
+    end
+
+    def inspect
+      t = 0
+      res = "SegmentTree @e = #{@e}, @n = #{@n}, @leaf_size = #{@leaf_size} @op = #{@op}\n  "
+      a = @d[1, @d.size - 1]
+      a.each_with_index do |e, i|
+        res << e.to_s << ' '
+        if t == i && i < @leaf_size
+          res << "\n  "
+          t = t * 2 + 2
+        end
+      end
+      res
+    end
+  end
+
+  SegTree     = Segtree
+  SegmentTree = Segtree
+end