ac-library-rb 0.5.0

data/lib/pow_mod.rb

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

data/lib/priority_queue.rb

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

data/lib/scc.rb

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

data/lib/segtree.rb

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

data/lib/suffix_array.rb

@@ -0,0 +1,128 @@
+# induce sort (internal method)
+def sa_is_induce(s, ls, sum_l, sum_s, lms)
+  n = s.size
+  sa = [-1] * n
+
+  buf = sum_s.dup
+  lms.each{ |lms|
+    if lms != n
+      sa[buf[s[lms]]] = lms
+      buf[s[lms]] += 1
+    end
+  }
+
+  buf = sum_l.dup
+  sa[buf[s[-1]]] = n - 1
+  buf[s[-1]] += 1
+  sa.each{ |v|
+    if v >= 1 && !ls[v - 1]
+      sa[buf[s[v - 1]]] = v - 1
+      buf[s[v - 1]] += 1
+    end
+  }
+
+  buf = sum_l.dup
+  sa.reverse_each{ |v|
+    if v >= 1 && ls[v - 1]
+      buf[s[v - 1] + 1] -= 1
+      sa[buf[s[v - 1] + 1]] = v - 1
+    end
+  }
+
+  return sa
+end
+
+# SA-IS (internal method)
+def sa_is(s, upper)
+  n = s.size
+
+  return [] if n == 0
+  return [0] if n == 1
+
+  ls = [false] * n
+  (n - 2).downto(0){ |i|
+    ls[i] = (s[i] == s[i + 1] ? ls[i + 1] : s[i] < s[i + 1])
+  }
+
+  sum_l = [0] * (upper + 1)
+  sum_s = [0] * (upper + 1)
+  n.times{ |i|
+    if ls[i]
+      sum_l[s[i] + 1] += 1
+    else
+      sum_s[s[i]] += 1
+    end
+  }
+  0.upto(upper){ |i|
+    sum_s[i] += sum_l[i]
+    sum_l[i + 1] += sum_s[i] if i < upper
+  }
+
+  lms = (1 ... n).select{ |i| !ls[i - 1] && ls[i] }
+  m = lms.size
+  lms_map = [-1] * (n + 1)
+  lms.each_with_index{ |lms, id| lms_map[lms] = id }
+
+  sa = sa_is_induce(s, ls, sum_l, sum_s, lms)
+
+  return sa if m == 0
+
+  sorted_lms = sa.select{ |sa| lms_map[sa] != -1 }
+  rec_s = [0] * m
+  rec_upper = 0
+  rec_s[lms_map[sorted_lms[0]]] = 0
+  1.upto(m - 1) do |i|
+    l, r = sorted_lms[i - 1, 2]
+    end_l = lms[lms_map[l] + 1] || n
+    end_r = lms[lms_map[r] + 1] || n
+    same = true
+    if end_l - l != end_r - r
+      same = false
+    else
+      while l < end_l
+        break if s[l] != s[r]
+
+        l += 1
+        r += 1
+      end
+      same = false if l == n || s[l] != s[r]
+    end
+    rec_upper += 1 if not same
+    rec_s[lms_map[sorted_lms[i]]] = rec_upper
+  end
+
+  sa_is(rec_s, rec_upper).each_with_index{ |rec_sa, id|
+    sorted_lms[id] = lms[rec_sa]
+  }
+
+  return sa_is_induce(s, ls, sum_l, sum_s, sorted_lms)
+end
+
+# suffix array for array of integers or string
+def suffix_array(s, upper = nil)
+  if not upper
+    case s
+    when Array
+      # compression
+      n = s.size
+      idx = (0 ... n).sort_by{ |i| s[i] }
+      t = [0] * n
+      upper = 0
+      t[idx[0]] = 0
+      1.upto(n - 1){ |i|
+        upper += 1 if s[idx[i - 1]] != s[idx[i]]
+        t[idx[i]] = upper
+      }
+      s = t
+    when String
+      upper = 255
+      s = s.bytes
+    end
+  else
+    s.each{ |s|
+      raise ArgumentError if s < 0 || upper < s
+    }
+  end
+
+  return sa_is(s, upper)
+end