ac-library-rb 0.5.0

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

@@ -0,0 +1,151 @@
+module AcLibraryRb
+  # Segment tree with Lazy propagation
+  class LazySegtree
+    attr_reader   :d, :lz
+    attr_accessor :op, :mapping, :composition
+
+    def initialize(v, e, id, op, mapping, composition)
+      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
+      @d    = Array.new(2 * @size, e)
+      @lz   = Array.new(@size, id)
+
+      @n.times { |i| @d[@size + i] = v[i] }
+      (@size - 1).downto(1) { |i| update(i) }
+    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
+
+    def get(pos)
+      pos += @size
+      @log.downto(1) { |i| push(pos >> i) }
+      @d[pos]
+    end
+
+    def prod(l, r)
+      return @e if l == r
+
+      l += @size
+      r += @size
+
+      @log.downto(1) do |i|
+        push(l >> i) if (l >> i) << i != l
+        push(r >> i) if (r >> i) << i != r
+      end
+
+      sml = @e
+      smr = @e
+      while l < r
+        if l.odd?
+          sml = @op.call(sml, @d[l])
+          l += 1
+        end
+        if r.odd?
+          r -= 1
+          smr = @op.call(@d[r], smr)
+        end
+        l >>= 1
+        r >>= 1
+      end
+
+      @op.call(sml, smr)
+    end
+
+    def all_prod
+      @d[1]
+    end
+
+    def apply(pos, f)
+      pos += @size
+      @log.downto(1) { |i| push(pos >> i) }
+      @d[pos] = @mapping.call(f, @d[pos])
+      1.upto(@log) { |i| update(pos >> i) }
+    end
+
+    def range_apply(l, r, f)
+      return if l == r
+
+      l += @size
+      r += @size
+
+      @log.downto(1) do |i|
+        push(l >> i) if (l >> i) << i != l
+        push((r - 1) >> i) if (r >> i) << i != r
+      end
+
+      l2 = l
+      r2 = r
+      while l < r
+        (all_apply(l, f); l += 1) if l.odd?
+        (r -= 1; all_apply(r, f)) if r.odd?
+        l >>= 1
+        r >>= 1
+      end
+      l = l2
+      r = r2
+
+      1.upto(@log) do |i|
+        update(l >> i)       if (l >> i) << i != l
+        update((r - 1) >> i) if (r >> i) << i != r
+      end
+    end
+
+    def max_right(l, &g)
+      return @n if l == @n
+
+      l += @size
+      @log.downto(1) { |i| push(l >> i) }
+      sm = @e
+
+      loop do
+        while l.even?
+          l >>= 1
+        end
+        unless g.call(@op.call(sm, @d[l]))
+          while l < @size
+            push(l)
+            l <<= 1
+            if g.call(@op.call(sm, @d[l]))
+              sm = @op.call(sm, @d[l])
+              l += 1
+            end
+          end
+          return l - @size
+        end
+        sm = @op.call(sm, @d[l])
+        l += 1
+        break if l & -l == l
+      end
+      @n
+    end
+
+    def update(k)
+      @d[k] = @op.call(@d[2 * k], @d[2 * k + 1])
+    end
+
+    def all_apply(k, f)
+      @d[k]  = @mapping.call(f, @d[k])
+      @lz[k] = @composition.call(f, @lz[k]) if k < @size
+    end
+
+    def push(k)
+      all_apply(2 * k,     @lz[k])
+      all_apply(2 * k + 1, @lz[k])
+      @lz[k] = @id
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module AcLibraryRb
+  # 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
+end

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

@@ -0,0 +1,139 @@
+module AcLibraryRb
+  # 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
+end

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

@@ -0,0 +1,145 @@
+module AcLibraryRb
+  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
+end