ac-library-rb 0.5.0 → 0.6.0

data/lib/floor_sum.rb

@@ -1,21 +1,44 @@
 def floor_sum(n, m, a, b)
+  raise ArgumentError if n < 0 || m < 1
+
   res = 0
 
-  if a >= m
-    res += (n - 1) * n * (a / m) / 2
-    a %= m
+  if a < 0
+    a2 = a % m
+    res -= n * (n - 1) / 2 * ((a2 - a) / m)
+    a = a2
   end
 
-  if b >= m
-    res += n * (b / m)
-    b %= m
+  if b < 0
+    b2 = b % m
+    res -= n * ((b2 - b) / m)
+    b = b2
   end
 
-  y_max = (a * n + b) / m
+  res + floor_sum_unsigned(n, m, a, b)
+end
+
+def floor_sum_unsigned(n, m, a, b)
+  res = 0
+
+  while true
+    if a >= m
+      res += n * (n - 1) / 2 * (a / m)
+      a %= m
+    end
+
+    if b >= m
+      res += n * (b / m)
+      b %= m
+    end
 
-  return res if y_max == 0
+    y_max = a * n + b
+    break if y_max < m
+
+    n = y_max / m
+    b = y_max % m
+    m, a = a, m
+  end
 
-  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/lazy_segtree.rb

@@ -1,17 +1,21 @@
 # Segment tree with Lazy propagation
 class LazySegtree
-  attr_reader   :d, :lz
+  attr_reader :d, :lz, :e, :id
   attr_accessor :op, :mapping, :composition
 
-  def initialize(v, e, id, op, mapping, composition)
-    v = Array.new(v, e) if v.is_a?(Integer)
+  # new(v, op, e, mapping, composition, id)
+  # new(v, e, id, op, mapping, composition)
+  # new(v, e, id){ |x, y|  }
+  def initialize(v, a1, a2, a3 = nil, a4 = nil, a5 = nil, &op_block)
+    if a1.is_a?(Proc)
+      @op, @e, @mapping, @composition, @id = a1, a2, a3, a4, a5
+    else
+      @e, @id, @op, @mapping, @composition = a1, a2, a3, a4, a5
+      @op ||= op_block
+    end
+    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
@@ -22,20 +26,41 @@ class LazySegtree
     (@size - 1).downto(1) { |i| update(i) }
   end
 
+  def set_mapping(&mapping)
+    @mapping = mapping
+  end
+
+  def set_composition(&composition)
+    @composition = composition
+  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
+  alias []= set
 
   def get(pos)
     pos += @size
     @log.downto(1) { |i| push(pos >> i) }
     @d[pos]
   end
+  alias [] get
+
+  def prod(l, r = nil)
+    if r.nil? # if 1st argument l is Range
+      if r = l.end
+        r += @n if r < 0
+        r += 1 unless l.exclude_end?
+      else
+        r = @n
+      end
+      l = l.begin
+      l += @n if l < 0
+    end
 
-  def prod(l, r)
     return @e if l == r
 
     l += @size
@@ -68,7 +93,24 @@ class LazySegtree
     @d[1]
   end
 
-  def apply(pos, f)
+  # apply(pos, f)
+  # apply(l, r, f)  -> range_apply(l, r, f)
+  # apply(l...r, f) -> range_apply(l, r, f)  ... [Experimental]
+  def apply(pos, f, fr = nil)
+    if fr
+      return range_apply(pos, f, fr)
+    elsif pos.is_a?(Range)
+      l = pos.begin
+      l += @n if l < 0
+      if r = pos.end
+        r += @n if r < 0
+        r += 1 unless pos.exclude_end?
+      else
+        r = @n
+      end
+      return range_apply(l, r, f)
+    end
+
     pos += @size
     @log.downto(1) { |i| push(pos >> i) }
     @d[pos] = @mapping.call(f, @d[pos])
@@ -132,6 +174,35 @@ class LazySegtree
     @n
   end
 
+  def min_left(r, &g)
+    return 0 if r == 0
+
+    r += @size
+    @log.downto(1) { |i| push((r - 1) >> i) }
+    sm = @e
+
+    loop do
+      r -= 1
+      while r > 1 && r.odd?
+        r /= 2
+      end
+      unless g.call(@op.call(@d[r], sm))
+        while r < @size
+          push(r)
+          r = r * 2 + 1
+          if g.call(@op.call(@d[r], sm))
+            sm = @op.call(@d[r], sm)
+            r -= 1
+          end
+        end
+        return r + 1 - @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
@@ -147,3 +218,5 @@ class LazySegtree
     @lz[k] = @id
   end
 end
+
+LazySegTree = LazySegtree

data/lib/max_flow.rb

@@ -1,6 +1,6 @@
 # MaxFlowGraph
 class MaxFlow
-  def initialize(n = 0)
+  def initialize(n)
     @n   = n
     @pos = []
     @g   = Array.new(n) { [] }
@@ -20,6 +20,15 @@ class MaxFlow
     edge_number
   end
 
+  def add_edges(edges)
+    edges.each{ |from, to, cap| add_edge(from, to, cap) }
+    self
+  end
+
+  def add(x, to = nil, cap = nil)
+    cap ? add_edge(x, to, cap) : add_edges(x)
+  end
+
   def push(edge)
     add_edge(*edge)
   end
@@ -132,6 +141,3 @@ class MaxFlow
     res
   end
 end
-
-MaxFlowGraph = MaxFlow
-MFGraph      = MaxFlow

data/lib/min_cost_flow.rb

@@ -11,7 +11,7 @@ class MinCostFlow
     @g_cost = Array.new(n) { [] }
     @pv     = Array.new(n)
     @pe     = Array.new(n)
-    @dual   = Array.new(n) { 0 }
+    @dual   = Array.new(n, 0)
   end
 
   def add_edge(from, to, cap, cost)
@@ -36,6 +36,15 @@ class MinCostFlow
     edge_number
   end
 
+  def add_edges(edges)
+    edges.each{ |from, to, cap, cost| add_edge(from, to, cap, cost) }
+    self
+  end
+
+  def add(x, to = nil, cap = nil, cost = nil)
+    cost ? add_edge(x, to, cap, cost) : add_edges(x)
+  end
+
   def get_edge(i)
     from, id = @pos[i]
     to = @g_to[from][id]
@@ -104,7 +113,7 @@ class MinCostFlow
   def slope(s, t, flow_limit = Float::MAX)
     flow = 0
     cost = 0
-    prev_cost = -1
+    prev_cost_per_flow = -1
     result = [[flow, cost]]
 
     while flow < flow_limit
@@ -129,15 +138,12 @@ class MinCostFlow
       d = -@dual[s]
       flow += c
       cost += c * d
-      result.pop if prev_cost == d
+      result.pop if prev_cost_per_flow == d
       result << [flow, cost]
-      prev_cost = d
+      prev_cost_per_flow = d
     end
 
     result
   end
   alias min_cost_slop slope
 end
-
-MCF      = MinCostFlow
-MCFGraph = MinCostFlow

data/lib/modint.rb

@@ -161,7 +161,9 @@ class ModInt < Numeric
 
   def inv_internal(a)
     if $_mod_is_prime
-      a != 0 ? a.pow($_mod - 2, $_mod) : raise(RangeError, 'no inverse')
+      raise(RangeError, 'no inverse') if a == 0
+
+      a.pow($_mod - 2, $_mod)
     else
       g, x = ModInt.inv_gcd(a, $_mod)
       g == 1 ? x : raise(RangeError, 'no inverse')

data/lib/scc.rb

@@ -1,15 +1,29 @@
 # Strongly Connected Components
-class SCCGraph
+class SCC
   # initialize graph with n vertices
-  def initialize(n = 0)
-    @n, @edges = n, []
+  def initialize(n)
+    @n = n
+    @edges = []
   end
 
   # add directed edge
   def add_edge(from, to)
-    raise "invalid params" unless (0...@n).include? from and (0...@n).include? to
+    unless 0 <= from && from < @n and 0 <= to && to < @n
+      msg = "Wrong params: from=#{from} and to=#{to} must be in 0...#{@n}"
+      raise ArgumentError.new(msg)
+    end
 
     @edges << [from, to]
+    self
+  end
+
+  def add_edges(edges)
+    edges.each{ |from, to| add_edge(from, to) }
+    self
+  end
+
+  def add(x, to = nil)
+    to ? add_edge(x, to) : add_edges(x)
   end
 
   # returns list of strongly connected components
@@ -17,10 +31,8 @@ class SCCGraph
   # 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 }
+    ids.each_with_index { |id, i| groups[id] << i }
     groups
   end
 
@@ -59,7 +71,8 @@ class SCCGraph
   end
 
   def csr
-    start, elist = [0] * (@n + 1), [nil] * @edges.size
+    start = [0] * (@n + 1)
+    elist = [nil] * @edges.size
     @edges.each { |(i, _)| start[i + 1] += 1 }
     @n.times { |i| start[i + 1] += start[i] }
     counter = start.dup
@@ -70,8 +83,3 @@ class SCCGraph
     [start, elist]
   end
 end
-
-# class alias
-StronglyConnectedComponents = SCCGraph
-SCC  = SCCGraph
-SCCG = SCCGraph

data/lib/segtree.rb

@@ -2,21 +2,21 @@
 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
+  # new(v, e){ |x, y|  }
+  # new(v, op, e)
+  def initialize(a0, a1, a2 = nil, &block)
+    if a2.nil?
+      @e, @op = a1, proc(&block)
+      v = (a0.is_a?(Array) ? a0 : [@e] * a0)
+    else
+      @op, @e = a1, a2
+      v = (a0.is_a?(Array) ? a0 : [@e] * a0)
     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 }
+    @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
@@ -26,12 +26,25 @@ class Segtree
     @d[q] = x
     1.upto(@log) { |i| update(q >> i) }
   end
+  alias []= set
 
   def get(pos)
     @d[@leaf_size + pos]
   end
+  alias [] get
+
+  def prod(l, r = nil)
+    if r.nil? # if 1st argument l is Range
+      if r = l.end
+        r += @n if r < 0
+        r += 1 unless l.exclude_end?
+      else
+        r = @n
+      end
+      l = l.begin
+      l += @n if l < 0
+    end
 
-  def prod(l, r)
     return @e if l == r
 
     sml = @e
@@ -121,20 +134,19 @@ class Segtree
     @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
+  # def inspect # for debug
+  #   t = 0
+  #   res = "Segtree @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
+SegTree = Segtree

data/lib/suffix_array.rb

@@ -76,9 +76,7 @@ def sa_is(s, upper)
     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
+    if end_l - l == end_r - r
       while l < end_l
         break if s[l] != s[r]
 
@@ -86,6 +84,8 @@ def sa_is(s, upper)
         r += 1
       end
       same = false if l == n || s[l] != s[r]
+    else
+      same = false
     end
     rec_upper += 1 if not same
     rec_s[lms_map[sorted_lms[i]]] = rec_upper
@@ -100,7 +100,11 @@ end
 
 # suffix array for array of integers or string
 def suffix_array(s, upper = nil)
-  if not upper
+  if upper
+    s.each{ |s|
+      raise ArgumentError if s < 0 || upper < s
+    }
+  else
     case s
     when Array
       # compression
@@ -118,10 +122,6 @@ def suffix_array(s, upper = nil)
       upper = 255
       s = s.bytes
     end
-  else
-    s.each{ |s|
-      raise ArgumentError if s < 0 || upper < s
-    }
   end
 
   return sa_is(s, upper)