ac-library-rb 1.0.0 → 1.2.0

data/document_ja/min_cost_flow.md

@@ -79,8 +79,8 @@ graph.edges
 ## 参考リンク
 
 - 当ライブラリ
-  - [当ライブラリの実装コード min_cost_flow.rb](https://github.com/universato/ac-library-rb/blob/master/lib/min_cost_flow.rb)
-  - [当ライブラリのテストコード min_cost_flow_test.rb](https://github.com/universato/ac-library-rb/blob/master/test/min_cost_flow_test.rb)
+  - [当ライブラリの実装コード min_cost_flow.rb](https://github.com/universato/ac-library-rb/blob/main/lib/min_cost_flow.rb)
+  - [当ライブラリのテストコード min_cost_flow_test.rb](https://github.com/universato/ac-library-rb/blob/main/test/min_cost_flow_test.rb)
 - 本家ライブラリ
   - [本家ライブラリのドキュメント mincostflow.md(GitHub)](https://github.com/atcoder/ac-library/blob/master/document_ja/mincostflow.md)
   - [本家ライブラリの実装コード mincostflow.hpp(GitHub)](https://github.com/atcoder/ac-library/blob/master/atcoder/mincostflow.hpp)

data/document_ja/modint.md

@@ -212,8 +212,8 @@ p 12.to_m == 1 #=> true
 ## 参考リンク
 
 - 当ライブラリ
-  - [当ライブラリのコード modint.rb(GitHub)](https://github.com/universato/ac-library-rb/blob/master/lib/modint.rb)
-  - [当ライブラリのコード modint_test.rb(GitHub)](https://github.com/universato/ac-library-rb/blob/master/lib/modint.rb)
+  - [当ライブラリのコード modint.rb(GitHub)](https://github.com/universato/ac-library-rb/blob/main/lib/modint.rb)
+  - [当ライブラリのコード modint_test.rb(GitHub)](https://github.com/universato/ac-library-rb/blob/main/lib/modint.rb)
 - 本家ライブラリ
   - [本家の実装コード modint.hpp(GitHub)](https://github.com/atcoder/ac-library/blob/master/atcoder/modint.hpp)
   - [本家のテストコード modint_test.cpp(GitHub)](https://github.com/atcoder/ac-library/blob/master/atcoder/modint.hpp)
@@ -223,7 +223,7 @@ p 12.to_m == 1 #=> true
 - その他
   - [modint 構造体を使ってみませんか？ \(C\+\+\) - noshi91のメモ](https://noshi91.hatenablog.com/entry/2019/03/31/174006)(2019/3/31)
   - [Pythonでmodintを実装してみた - Qiita](https://qiita.com/wotsushi/items/c936838df992b706084c)(2019/4/1)
-  - [C#版のModIntのドキュメント](https://github.com/key-moon/ac-library-cs/blob/master/document_ja/modint.md)
+  - [C#版のModIntのドキュメント](https://github.com/key-moon/ac-library-cs/blob/main/document_ja/modint.md)
   
 
 ## Q&A

data/document_ja/priority_queue.md

@@ -100,4 +100,4 @@ pq.heap
 
 ## 参考
 
-- [cpython/heapq.py at master - python/cpython](https://github.com/python/cpython/blob/master/Lib/heapq.py)
+- [cpython/heapq.py at main - python/cpython](https://github.com/python/cpython/blob/main/Lib/heapq.py)

data/document_ja/scc.md

@@ -58,8 +58,8 @@ graph.scc
 # 参考リンク
 
 - 当ライブラリ
-  - [当ライブラリの実装コード scc.rb](https://github.com/universato/ac-library-rb/blob/master/lib/scc.rb)
-  - [当ライブラリの実装コード scc_test.rb](https://github.com/universato/ac-library-rb/blob/master/test/scc_test.rb)
+  - [当ライブラリの実装コード scc.rb](https://github.com/universato/ac-library-rb/blob/main/lib/scc.rb)
+  - [当ライブラリの実装コード scc_test.rb](https://github.com/universato/ac-library-rb/blob/main/test/scc_test.rb)
 - 本家ライブラリ
   - [本家ライブラリの実装コード scc.hpp](https://github.com/atcoder/ac-library/blob/master/atcoder/scc.hpp)
   - [本家ライブラリのドキュメント scc.md](https://github.com/atcoder/ac-library/blob/master/document_ja/scc.md)

data/document_ja/segtree.md

@@ -153,8 +153,8 @@ Segtree上で`0 <= l <= r`の範囲で、`f(prod(l, r))`の結果を二分探索
 ## 参考リンク
 
 - 当ライブラリ
-  - [当ライブラリの実装コード segtree.rb](https://github.com/universato/ac-library-rb/blob/master/lib/segtree.rb)
-  - [当ライブラリのテストコード segtree.rb](https://github.com/universato/ac-library-rb/blob/master/test/segtree_test.rb)
+  - [当ライブラリの実装コード segtree.rb](https://github.com/universato/ac-library-rb/blob/main/lib/segtree.rb)
+  - [当ライブラリのテストコード segtree.rb](https://github.com/universato/ac-library-rb/blob/main/test/segtree_test.rb)
     - テストコードも具体的な使い方として役に立つかもしれまん。
 - 本家ライブラリ
   - [本家ライブラリのドキュメント segtree.md(GitHub)](https://github.com/atcoder/ac-library/blob/master/document_ja/segtree.md)

data/lib/ac-library-rb/version.rb

@@ -1,3 +1,3 @@
 module AcLibraryRb
-  VERSION = "1.0.0".freeze
+  VERSION = "1.2.0".freeze
 end

data/lib/core_ext/integer.rb

@@ -0,0 +1,31 @@
+require "prime"
+
+class Integer
+  # Returns the positive divisors of +self+ if +self+ is positive.
+  #
+  # == Example
+  #   6.divisors   #=> [1, 2, 3, 6]
+  #   7.divisors   #=> [1, 7]
+  #   8.divisors   #=> [1, 2, 4, 8]
+  def divisors
+    if prime?
+      [1, self]
+    elsif self == 1
+      [1]
+    else
+      xs = prime_division.map{ |p, n| Array.new(n + 1){ |e| p**e } }
+      x = xs.pop
+      x.product(*xs).map{ |t| t.inject(:*) }.sort
+    end
+  end
+
+  # Iterates the given block for each divisor of +self+.
+  #
+  # == Example
+  #   ds = []
+  #   10.divisors{ |d| ds << d }
+  #   ds  #=> [1, 2, 5, 10]
+  def each_divisor(&block)
+    block_given? ? divisors.each(&block) : enum_for(:each_divisor)
+  end
+end

data/lib/deque.rb

@@ -0,0 +1,306 @@
+class Deque
+  include Enumerable
+
+  def self.[](*args)
+    new(args)
+  end
+
+  def initialize(arg = [], value = nil, initial_capacity: 0)
+    ary = arg
+    ary = Array.new(arg, value) if arg.is_a?(Integer)
+    @n = [initial_capacity, ary.size].max + 1
+    @buf = ary + [nil] * (@n - ary.size)
+    @head = 0
+    @tail = ary.size
+    @reverse_count = 0
+  end
+
+  def empty?
+    size == 0
+  end
+
+  def size
+    (@tail - @head) % @n
+  end
+  alias length size
+
+  def <<(x)
+    reversed? ? __unshift(x) : __push(x)
+  end
+
+  def push(*args)
+    args.each{ |x| self << x }
+    self
+  end
+  alias append push
+
+  def unshift(*args)
+    if reversed?
+      args.reverse_each{ |e|  __push(e) }
+    else
+      args.reverse_each{ |e| __unshift(e) }
+    end
+    self
+  end
+  alias prepend unshift
+
+  def pop
+    reversed? ? __shift : __pop
+  end
+
+  def shift
+    reversed? ? __pop : __shift
+  end
+
+  def last
+    self[-1]
+  end
+
+  def slice(idx)
+    sz = size
+    return nil if idx < -sz || sz <= idx
+
+    @buf[__index(idx)]
+  end
+
+  def [](a, b = nil)
+    if b
+      slice2(a, b)
+    elsif a.is_a?(Range)
+      s = a.begin
+      t = a.end
+      t -= 1 if a.exclude_end?
+      slice2(s, t - s + 1)
+    else
+      slice1(a)
+    end
+  end
+
+  def at(idx)
+    slice1(idx)
+  end
+
+  private def slice1(idx)
+    sz = size
+    return nil if idx < -sz || sz <= idx
+
+    @buf[__index(idx)]
+  end
+
+  private def slice2(i, t)
+    sz = size
+    return nil if t < 0 || i > sz
+
+    if i == sz
+      Deque[]
+    else
+      j = [i + t - 1, sz].min
+      slice_indexes(i, j)
+    end
+  end
+
+  private def slice_indexes(i, j)
+    i, j = j, i if reversed?
+    s = __index(i)
+    t = __index(j) + 1
+    Deque.new(__to_a(s, t))
+  end
+
+  def []=(idx, value)
+    @buf[__index(idx)] = value
+  end
+
+  def ==(other)
+    return false unless size == other.size
+
+    to_a == other.to_a
+  end
+
+  def hash
+    to_a.hash
+  end
+
+  def reverse
+    dup.reverse!
+  end
+
+  def reverse!
+    @reverse_count += 1
+    self
+  end
+
+  def reversed?
+    @reverse_count & 1 == 1
+  end
+
+  def dig(*args)
+    case args.size
+    when 0
+      raise ArgumentError.new("wrong number of arguments (given 0, expected 1+)")
+    when 1
+      self[args[0].to_int]
+    else
+      i = args.shift.to_int
+      self[i]&.dig(*args)
+    end
+  end
+
+  def each(&block)
+    return enum_for(:each) unless block_given?
+
+    if @head <= @tail
+      if reversed?
+        @buf[@head...@tail].reverse_each(&block)
+      else
+        @buf[@head...@tail].each(&block)
+      end
+    elsif reversed?
+      @buf[0...@tail].reverse_each(&block)
+      @buf[@head..-1].reverse_each(&block)
+    else
+      @buf[@head..-1].each(&block)
+      @buf[0...@tail].each(&block)
+    end
+  end
+
+  def clear
+    @n = 1
+    @buf = []
+    @head = 0
+    @tail = 0
+    @reverse_count = 0
+    self
+  end
+
+  def join(sep = $OFS)
+    to_a.join(sep)
+  end
+
+  def rotate!(cnt = 1)
+    return self if cnt == 0
+
+    cnt %= size if cnt < 0 || size > cnt
+
+    cnt.times{ push(shift) }
+    self
+  end
+
+  def rotate(cnt = 1)
+    return self if cnt == 0
+
+    cnt %= size if cnt < 0 || size > cnt
+
+    ret = dup
+    @buf = @buf.dup
+    cnt.times{ ret.push(ret.shift) }
+    ret
+  end
+
+  def sample
+    return nil if empty?
+
+    self[rand(size)]
+  end
+
+  def shuffle
+    Deque.new(to_a.shuffle)
+  end
+
+  def replace(other)
+    ary = other.to_a
+    @n = ary.size + 1
+    @buf = ary + [nil] * (@n - ary.size)
+    @head = 0
+    @tail = ary.size
+    @reverse_count = 0
+    self
+  end
+
+  def swap(i, j)
+    i = __index(i)
+    j = __index(j)
+    @buf[i], @buf[j] = @buf[j], @buf[i]
+    self
+  end
+
+  def to_a
+    __to_a
+  end
+  # alias to_ary to_a
+
+  private def __to_a(s = @head, t = @tail)
+    res = s <= t ? @buf[s...t] : @buf[s..-1].concat(@buf[0...t])
+    reversed? ? res.reverse : res
+  end
+
+  def to_s
+    "#{self.class}#{to_a}"
+  end
+
+  def inspect
+    "Deque#{to_a}"
+    # "Deque#{to_a}(@n=#{@n}, @buf=#{@buf}, @head=#{@head}, @tail=#{@tail}, "\
+    # "size #{size}#{' full' if __full?}#{' rev' if reversed?})"
+  end
+
+  private def __push(x)
+    __extend if __full?
+    @buf[@tail] = x
+    @tail += 1
+    @tail %= @n
+    self
+  end
+
+  private def __unshift(x)
+    __extend if __full?
+    @buf[(@head - 1) % @n] = x
+    @head -= 1
+    @head %= @n
+    self
+  end
+
+  private def __pop
+    return nil if empty?
+
+    ret = @buf[(@tail - 1) % @n]
+    @tail -= 1
+    @tail %= @n
+    ret
+  end
+
+  private def __shift
+    return nil if empty?
+
+    ret = @buf[@head]
+    @head += 1
+    @head %= @n
+    ret
+  end
+
+  private def __full?
+    size >= @n - 1
+  end
+
+  private def __index(i)
+    l = size
+    raise IndexError, "index out of range: #{i}" unless -l <= i && i < l
+
+    i = -(i + 1) if reversed?
+    i += l if i < 0
+    (@head + i) % @n
+  end
+
+  private def __extend
+    if @tail + 1 == @head
+      tail = @buf.shift(@tail + 1)
+      @buf.concat(tail).concat([nil] * @n)
+      @head = 0
+      @tail = @n - 1
+      @n = @buf.size
+    else
+      @buf[(@tail + 1)..(@tail + 1)] = [nil] * @n
+      @n = @buf.size
+      @head += @n if @head > 0
+    end
+  end
+end

data/lib/modint.rb

@@ -141,6 +141,18 @@ class ModInt < Numeric
     @val == other.to_i
   end
 
+  def pred
+    dup.add!(-1)
+  end
+
+  def succ
+    dup.add! 1
+  end
+
+  def zero?
+    @val == 0
+  end
+
   def dup
     ModInt.raw(@val)
   end

data/lib/priority_queue.rb

@@ -1,5 +1,5 @@
 # Priority Queue
-# Reference: https://github.com/python/cpython/blob/master/Lib/heapq.py
+# Reference: https://github.com/python/cpython/blob/main/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.
@@ -13,6 +13,14 @@ class PriorityQueue
     heapify
   end
 
+  def self.max(array)
+    new(array)
+  end
+
+  def self.min(array)
+    new(array){ |x, y| x < y }
+  end
+
   def self.[](*array, &comp)
     new(array, &comp)
   end
@@ -46,6 +54,7 @@ class PriorityQueue
   end
 
   alias top get
+  alias first get
 
   # Returns true if the heap is empty.
   def empty?

data/lib_helpers/ac-library-rb/all.rb

@@ -1,5 +1,6 @@
 require_relative "../../lib_lock/ac-library-rb/convolution"
 require_relative "../../lib_lock/ac-library-rb/crt"
+require_relative "../../lib_lock/ac-library-rb/deque"
 require_relative "../../lib_lock/ac-library-rb/dsu"
 require_relative "../../lib_lock/ac-library-rb/fenwick_tree"
 require_relative "../../lib_lock/ac-library-rb/floor_sum"

data/lib_helpers/ac-library-rb.rb

@@ -6,6 +6,7 @@ require_relative '../lib_lock/ac-library-rb/core_ext/all.rb'
 
 require_relative '../lib_lock/ac-library-rb/convolution'
 require_relative '../lib_lock/ac-library-rb/crt'
+require_relative '../lib_lock/ac-library-rb/dequex'
 require_relative '../lib_lock/ac-library-rb/dsu'
 require_relative '../lib_lock/ac-library-rb/fenwick_tree'
 require_relative '../lib_lock/ac-library-rb/floor_sum'

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

@@ -0,0 +1,31 @@
+require "prime"
+
+class Integer
+  # Returns the positive divisors of +self+ if +self+ is positive.
+  #
+  # == Example
+  #   6.divisors   #=> [1, 2, 3, 6]
+  #   7.divisors   #=> [1, 7]
+  #   8.divisors   #=> [1, 2, 4, 8]
+  def divisors
+    if prime?
+      [1, self]
+    elsif self == 1
+      [1]
+    else
+      xs = prime_division.map{ |p, n| Array.new(n + 1){ |e| p**e } }
+      x = xs.pop
+      x.product(*xs).map{ |t| t.inject(:*) }.sort
+    end
+  end
+
+  # Iterates the given block for each divisor of +self+.
+  #
+  # == Example
+  #   ds = []
+  #   10.divisors{ |d| ds << d }
+  #   ds  #=> [1, 2, 5, 10]
+  def each_divisor(&block)
+    block_given? ? divisors.each(&block) : enum_for(:each_divisor)
+  end
+end