ac-library-rb 0.5.0

data/lib/lcp_array.rb

@@ -0,0 +1,23 @@
+# lcp array for array of integers or string
+def lcp_array(s, sa)
+  s = s.bytes if s.is_a?(String)
+
+  n = s.size
+  rnk = [0] * n
+  sa.each_with_index{ |sa, id|
+    rnk[sa] = id
+  }
+
+  lcp = [0] * (n - 1)
+  h = 0
+  n.times{ |i|
+    h -= 1 if h > 0
+    next if rnk[i] == 0
+
+    j = sa[rnk[i] - 1]
+    h += 1 while j + h < n && i + h < n && s[j + h] == s[i + h]
+    lcp[rnk[i] - 1] = h
+  }
+
+  return lcp
+end

data/lib/max_flow.rb

@@ -0,0 +1,137 @@
+# MaxFlowGraph
+class MaxFlow
+  def initialize(n = 0)
+    @n   = n
+    @pos = []
+    @g   = Array.new(n) { [] }
+  end
+
+  def add_edge(from, to, cap)
+    edge_number = @pos.size
+
+    @pos << [from, @g[from].size]
+
+    from_id = @g[from].size
+    to_id   = @g[to].size
+    to_id += 1 if from == to
+    @g[from] << [to,   to_id,   cap]
+    @g[to]   << [from, from_id, 0]
+
+    edge_number
+  end
+
+  def push(edge)
+    add_edge(*edge)
+  end
+  alias << push
+
+  # return edge = [from, to, cap, flow]
+  def [](i)
+    _e  = @g[@pos[i][0]][@pos[i][1]]
+    _re = @g[_e[0]][_e[1]]
+    [@pos[i][0], _e[0], _e[-1] + _re[-1], _re[-1]]
+  end
+  alias get_edge []
+  alias edge []
+
+  def edges
+    @pos.map do |(from, id)|
+      _e  = @g[from][id]
+      _re = @g[_e[0]][_e[1]]
+      [from, _e[0], _e[-1] + _re[-1], _re[-1]]
+    end
+  end
+
+  def change_edge(i, new_cap, new_flow)
+    _e  = @g[@pos[i][0]][@pos[i][1]]
+    _re = @g[_e[0]][_e[1]]
+    _e[2]  = new_cap - new_flow
+    _re[2] = new_flow
+  end
+
+  def flow(s, t, flow_limit = 1 << 64)
+    level = Array.new(@n)
+    iter  = Array.new(@n)
+    que   = []
+
+    flow = 0
+    while flow < flow_limit
+      bfs(s, t, level, que)
+      break if level[t] == -1
+
+      iter.fill(0)
+      while flow < flow_limit
+        f = dfs(t, flow_limit - flow, s, level, iter)
+        break if f == 0
+
+        flow += f
+      end
+    end
+
+    flow
+  end
+  alias max_flow flow
+
+  def min_cut(s)
+    visited = Array.new(@n, false)
+    que = [s]
+    while (q = que.shift)
+      visited[q] = true
+      @g[q].each do |(to, _rev, cap)|
+        if cap > 0 && !visited[to]
+          visited[to] = true
+          que << to
+        end
+      end
+    end
+    visited
+  end
+
+  private
+
+  def bfs(s, t, level, que)
+    level.fill(-1)
+    level[s] = 0
+    que.clear
+    que << s
+
+    while (v = que.shift)
+      @g[v].each do |e|
+        next if e[2] == 0 || level[e[0]] >= 0
+
+        level[e[0]] = level[v] + 1
+        return nil if e[0] == t
+
+        que << e[0]
+      end
+    end
+  end
+
+  def dfs(v, up, s, level, iter)
+    return up if v == s
+
+    res = 0
+    level_v = level[v]
+
+    while iter[v] < @g[v].size
+      i = iter[v]
+      e = @g[v][i]
+      cap = @g[e[0]][e[1]][2]
+      if level_v > level[e[0]] && cap > 0
+        d = dfs(e[0], (up - res < cap ? up - res : cap), s, level, iter)
+        if d > 0
+          @g[v][i][2] += d
+          @g[e[0]][e[1]][2] -= d
+          res += d
+          break if res == up
+        end
+      end
+      iter[v] += 1
+    end
+
+    res
+  end
+end
+
+MaxFlowGraph = MaxFlow
+MFGraph      = MaxFlow

data/lib/min_cost_flow.rb

@@ -0,0 +1,143 @@
+require_relative './priority_queue.rb'
+
+# Min Cost Flow Grapsh
+class MinCostFlow
+  def initialize(n)
+    @n      = n
+    @pos    = []
+    @g_to   = Array.new(n) { [] }
+    @g_rev  = Array.new(n) { [] }
+    @g_cap  = Array.new(n) { [] }
+    @g_cost = Array.new(n) { [] }
+    @pv     = Array.new(n)
+    @pe     = Array.new(n)
+    @dual   = Array.new(n) { 0 }
+  end
+
+  def add_edge(from, to, cap, cost)
+    edge_number = @pos.size
+
+    @pos << [from, @g_to[from].size]
+
+    from_id = @g_to[from].size
+    to_id   = @g_to[to].size
+    to_id += 1 if from == to
+
+    @g_to[from]   << to
+    @g_rev[from]  << to_id
+    @g_cap[from]  << cap
+    @g_cost[from] << cost
+
+    @g_to[to]     << from
+    @g_rev[to]    << from_id
+    @g_cap[to]    << 0
+    @g_cost[to]   << -cost
+
+    edge_number
+  end
+
+  def get_edge(i)
+    from, id = @pos[i]
+    to = @g_to[from][id]
+    rid = @g_rev[from][id]
+    [from, to, @g_cap[from][id] + @g_cap[to][rid], @g_cap[to][rid], @g_cost[from][id]]
+  end
+  alias edge get_edge
+  alias [] get_edge
+
+  def edges
+    @pos.map do |(from, id)|
+      to = @g_to[from][id]
+      rid = @g_rev[from][id]
+      [from, to, @g_cap[from][id] + @g_cap[to][rid], @g_cap[to][rid], @g_cost[from][id]]
+    end
+  end
+
+  def flow(s, t, flow_limit = Float::MAX)
+    slope(s, t, flow_limit).last
+  end
+  alias min_cost_max_flow flow
+
+  def dual_ref(s, t)
+    dist = Array.new(@n, Float::MAX)
+    @pv.fill(-1)
+    @pe.fill(-1)
+    vis = Array.new(@n, false)
+
+    que = PriorityQueue.new { |par, chi| par[0] < chi[0] }
+    dist[s] = 0
+    que.push([0, s])
+
+    while (v = que.pop)
+      v = v[1]
+
+      next if vis[v]
+
+      vis[v] = true
+      break if v == t
+
+      @g_to[v].size.times do |i|
+        to = @g_to[v][i]
+        next if vis[to] || @g_cap[v][i] == 0
+
+        cost = @g_cost[v][i] - @dual[to] + @dual[v]
+        next unless dist[to] - dist[v] > cost
+
+        dist[to] = dist[v] + cost
+        @pv[to] = v
+        @pe[to] = i
+        que.push([dist[to], to])
+      end
+    end
+
+    return false unless vis[t]
+
+    @n.times do |i|
+      next unless vis[i]
+
+      @dual[i] -= dist[t] - dist[i]
+    end
+
+    true
+  end
+
+  def slope(s, t, flow_limit = Float::MAX)
+    flow = 0
+    cost = 0
+    prev_cost = -1
+    result = [[flow, cost]]
+
+    while flow < flow_limit
+      break unless dual_ref(s, t)
+
+      c = flow_limit - flow
+      v = t
+      while v != s
+        c = @g_cap[@pv[v]][@pe[v]] if c > @g_cap[@pv[v]][@pe[v]]
+        v = @pv[v]
+      end
+
+      v = t
+      while v != s
+        nv = @pv[v]
+        id = @pe[v]
+        @g_cap[nv][id] -= c
+        @g_cap[v][@g_rev[nv][id]] += c
+        v = nv
+      end
+
+      d = -@dual[s]
+      flow += c
+      cost += c * d
+      result.pop if prev_cost == d
+      result << [flow, cost]
+      prev_cost = d
+    end
+
+    result
+  end
+  alias min_cost_slop slope
+end
+
+MCF      = MinCostFlow
+MCFGraph = MinCostFlow

data/lib/modint.rb

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