ac-library-rb 0.5.0 → 0.6.0

data/lib/two_sat.rb

@@ -3,16 +3,18 @@ require_relative './scc.rb'
 # TwoSAT
 # Reference: https://github.com/atcoder/ac-library/blob/master/atcoder/twosat.hpp
 class TwoSAT
-  def initialize(n = 0)
+  def initialize(n)
     @n = n
     @answer = Array.new(n)
-    @scc = SCCGraph.new(2 * n)
+    @scc = SCC.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)
+    unless 0 <= i && i < @n and 0 <= j && j < @n
+      raise RangeError.new
+    end
 
     @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))

data/lib_lock/ac-library-rb.rb

@@ -2,6 +2,8 @@ module AcLibraryRb
 end
 include AcLibraryRb
 
+require_relative './lib_lock/ac-library-rb/all.rb'
+
 require_relative './ac-library-rb/convolution'
 require_relative './ac-library-rb/crt'
 require_relative './ac-library-rb/dsu'

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

@@ -123,4 +123,25 @@ module AcLibraryRb
 
     private :batterfly, :batterfly_inv, :bsf, :calc_primitive_root
   end
+
+  # [EXPERIMENTAL]
+  def convolution(a, b, mod: 998244353, k: 35, z: 99)
+    n = a.size
+    m = b.size
+    return [] if n == 0 || m == 0
+
+    raise ArgumentError if a.min < 0 || b.min < 0
+
+    format = "%0#{k}x" # "%024x"
+    sa = ""
+    sb = ""
+    a.each{ |x| sa << (format % x) }
+    b.each{ |x| sb << (format % x) }
+
+    zero = '0'
+    s = zero * z + ("%x" % (sa.hex * sb.hex))
+    i = -(n + m - 1) * k - 1
+
+    Array.new(n + m - 1){ (s[i + 1..i += k] || zero).hex % mod }
+  end
 end

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

@@ -0,0 +1,11 @@
+class Array
+  def to_fenwick_tree
+    AcLibraryRb::FenwickTree.new(self)
+  end
+  alias to_fetree to_fenwick_tree
+
+  def to_priority_queue
+    AcLibraryRb::PriorityQueue.new(self)
+  end
+  alias to_pq to_priority_queue
+end

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

@@ -1,11 +1,11 @@
 def ModInt(val)
-  ModInt.new(val)
+  AcLibraryRb::ModInt.new(val)
 end
 
 # Integer
 class Integer
   def to_modint
-    ModInt.new(self)
+    AcLibraryRb::ModInt.new(self)
   end
   alias to_m to_modint
 end
@@ -13,7 +13,7 @@ end
 # String
 class String
   def to_modint
-    ModInt.new(to_i)
+    AcLibraryRb::ModInt.new(to_i)
   end
   alias to_m to_modint
 end

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

@@ -1,13 +1,14 @@
 module AcLibraryRb
   # Disjoint Set Union
   class DSU
-    def initialize(n = 0)
+    def initialize(n)
+      @n = n
+      @parent_or_size = Array.new(n, -1)
       # root node: -1 * component size
       # otherwise: parent
-      @parent_or_size = Array.new(n, -1)
     end
 
-    attr_accessor :parent_or_size
+    attr_reader :parent_or_size, :n
 
     def merge(a, b)
       x = leader(a)
@@ -26,6 +27,10 @@ module AcLibraryRb
     alias same? same
 
     def leader(a)
+      unless 0 <= a && a < @n
+        raise ArgumentError.new, "#{a} is out of range (0...#{@n})"
+      end
+
       @parent_or_size[a] < 0 ? a : (@parent_or_size[a] = leader(@parent_or_size[a]))
     end
     alias root leader
@@ -40,7 +45,5 @@ module AcLibraryRb
     end
   end
 
-  UnionFind        = DSU
-  UnionFindTree    = DSU
-  DisjointSetUnion = DSU
+  UnionFind = DSU
 end

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

@@ -3,7 +3,7 @@ module AcLibraryRb
   class FenwickTree
     attr_reader :data, :size
 
-    def initialize(arg = 0)
+    def initialize(arg = nil)
       case arg
       when Array
         @size = arg.size
@@ -18,7 +18,7 @@ module AcLibraryRb
         @size = arg
         @data = Array.new(@size + 1, 0)
       else
-        raise ArgumentError
+        raise ArgumentError.new("wrong argument. type is Array or Integer")
       end
     end
 
@@ -30,8 +30,25 @@ module AcLibraryRb
       end
     end
 
-    def sum(l, r)
-      _sum(r) - _sum(l)
+    # .sum(l, r)  # [l, r)  <- Original
+    # .sum(r)     # [0, r)  <- [Experimental]
+    # .sum(l..r)  # [l, r]  <- [Experimental]
+    def sum(a, b = nil)
+      if b
+        _sum(b) - _sum(a)
+      elsif a.is_a?(Range)
+        l = a.begin
+        l += @size if l < 0
+        if r = a.end
+          r += @size if r < 0
+          r += 1 unless a.exclude_end?
+        else
+          r = @size
+        end
+        _sum(r) - _sum(l)
+      else
+        _sum(a)
+      end
     end
 
     def _sum(i)
@@ -42,9 +59,6 @@ module AcLibraryRb
       end
       res
     end
+    alias left_sum _sum
   end
-
-  FeTree            = FenwickTree
-  Fetree            = FenwickTree
-  BinaryIndexedTree = FenwickTree
 end

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

@@ -1,23 +1,46 @@
 module AcLibraryRb
   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
 end

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

@@ -1,18 +1,22 @@
 module AcLibraryRb
   # 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
@@ -23,20 +27,41 @@ module AcLibraryRb
       (@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
@@ -69,7 +94,24 @@ module AcLibraryRb
       @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])
@@ -133,6 +175,35 @@ module AcLibraryRb
       @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
@@ -148,4 +219,6 @@ module AcLibraryRb
       @lz[k] = @id
     end
   end
+
+  LazySegTree = LazySegtree
 end

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

@@ -1,7 +1,7 @@
 module AcLibraryRb
   # MaxFlowGraph
   class MaxFlow
-    def initialize(n = 0)
+    def initialize(n)
       @n   = n
       @pos = []
       @g   = Array.new(n) { [] }
@@ -21,6 +21,15 @@ module AcLibraryRb
       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
@@ -133,7 +142,4 @@ module AcLibraryRb
       res
     end
   end
-
-  MaxFlowGraph = MaxFlow
-  MFGraph      = MaxFlow
 end

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

@@ -12,7 +12,7 @@ module AcLibraryRb
       @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)
@@ -37,6 +37,15 @@ module AcLibraryRb
       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]
@@ -105,7 +114,7 @@ module AcLibraryRb
     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
@@ -130,16 +139,13 @@ module AcLibraryRb
         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
 end