hiogawa_playground 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 42915689772174d0f2719d0e4075864e2a2dad8f
+  data.tar.gz: ebaa52dd0daa36bd1db4b8b6706416112d549214
+SHA512:
+  metadata.gz: 62b06f1207f56b902a3447eb8b297770b8acda5648595d3033d8552a73fe91573b79018b21727c9218b4d77defe9610c0128dc4fa830eecba32ffdc5c711e7b8
+  data.tar.gz: 9a0f0bc53ff68305d9c5d141762d1f12f794d30811044c5603c5986bb00829051e87330b078cc7a479bf49fbdc8a44acc134c7515ae81109f74510a213029c86

data/lib/hiogawa_playground.rb

@@ -0,0 +1,2 @@
+module HiogawaPlayground
+end

data/lib/hiogawa_playground/mst.rb

@@ -0,0 +1,95 @@
+module HiogawaPlayground
+  module Mst
+    class << self
+      # points: array of nodes
+      # distance: distance function
+      def solve(points, distance) # O(n * n)
+        num_points = points.length
+        parents_relation = Array.new(num_points)
+        candidates = []
+
+        # Procedure:
+        #   1. init `candidates` based on `points[0]`
+        #   2. loop until there's no `candidates`
+        #     a. pick closest `candidates`
+        #     b. update `candidates` and `parents_relation` with picked one
+        #   3. return `parents_relation`
+
+        # 1
+        (1..(num_points - 1)).each do |idx|
+          candidates.push([idx, 0])
+        end
+
+        # 2
+        while !candidates.empty? # O(n)
+          # a
+          picked_pair, *rest_candidates = candidates
+          rest_candidates.each do |pair| # O(n)
+            if (
+              distance.call(pair[0], pair[1]) <
+              distance.call(picked_pair[0], picked_pair[1])
+            )
+              picked_pair = pair
+            end
+          end
+
+          # b
+          candidates.delete(picked_pair) # O(n)
+          parents_relation[picked_pair[0]] = picked_pair[1]
+          candidates.each do |pair| # O(n)
+            if (
+              distance.call(pair[0], picked_pair[0]) <
+              distance.call(pair[0], pair[1])
+            )
+              pair[1] = picked_pair[0]
+            end
+          end
+        end
+
+        # 3
+        parents_relation
+      end
+
+      def solve_edges(points, distance)
+        solve(points, distance)
+          .each_with_index
+          .select { |parent, _| parent != nil }
+          .map { |parent, i| [parent, i] }
+      end
+
+      # TODO: estimate time complexity
+      def solve_clustering(points, distance, threshold)
+        edges = solve_edges(points, distance).select { |i, j| distance.call(i, j) <= threshold }
+        adjacency_list = (0..(points.length - 1)).map { |i| [i] }
+        edges.each do |i, j|
+          adjacency_list[i].push(j)
+          adjacency_list[j].push(i)
+        end
+
+        connected_components(points.length, adjacency_list)
+      end
+
+      def connected_components(num_vs, adjacency_list)
+        visited = (0..(num_vs - 1)).map { false }
+
+        dfs = lambda do |i, current_cluster|
+          current_cluster.push(i)
+          visited[i] = true
+          adjacency_list[i].each do |j|
+            dfs.call(j, current_cluster) unless visited[j]
+          end
+        end
+
+        clusters = []
+        (0..(num_vs - 1)).each do |i|
+          unless visited[i]
+            cluster = []
+            dfs.call(i, cluster)
+            clusters.push(cluster)
+          end
+        end
+        clusters
+      end
+    end
+  end
+end

data/lib/hiogawa_playground/tsp.rb

@@ -0,0 +1,99 @@
+module HiogawaPlayground
+  module Tsp
+    class << self
+      def solve_tour(points, distance)
+        n = points.length
+        init_path = (0..(n - 1)).to_a.push(0)
+        two_opt(distance, init_path)
+      end
+
+      def solve_path(points, distance, st_idx, end_idx)
+        n = points.length
+        init_path = [st_idx] +
+                    (0..(n - 1)).to_a.select { |i| i != st_idx && i != end_idx } +
+                    [end_idx]
+        two_opt(distance, init_path)
+      end
+
+      def solve_arbitrary_path(points, distance)
+        path = solve_tour(points, distance)
+        n = points.length
+        longest_i = (0..(n - 1)).max_by { |i| distance.call(path[i], path[i + 1]) }
+        path[(longest_i + 1)..-2] + path[0..longest_i]
+      end
+
+      def solve_path_with_loose_end(points, distance, st_idx)
+        n = points.length
+        init_path = [st_idx] + (0..(n - 1)).to_a.select { |i| i != st_idx }
+        two_opt_with_loose_end(distance, init_path)
+      end
+
+      # 2-opt algorithm
+      def two_opt(distance, path)
+        loop do
+          opt = nil
+          candidate_index_pairs(path).each do |i, j|
+            before = distance.call(path[i], path[i + 1]) + distance.call(path[j], path[j + 1])
+            after = distance.call(path[i], path[j]) + distance.call(path[i + 1], path[j + 1])
+            if after < before
+              opt = [i, j]
+              break
+            end
+          end
+          break unless opt
+          path = two_swap(path, opt[0], opt[1])
+        end
+        path
+      end
+
+      # 2-opt algorithm extended to loose path end
+      def two_opt_with_loose_end(distance, path)
+        loop do
+          opt = nil
+          candidate_index_pairs_with_loose_end(path).each do |i, j|
+            if j + 1 == path.length
+              before = distance.call(path[i], path[i + 1])
+              after = distance.call(path[i], path[j])
+            else
+              before = distance.call(path[i], path[i + 1]) + distance.call(path[j], path[j + 1])
+              after = distance.call(path[i], path[j]) + distance.call(path[i + 1], path[j + 1])
+            end
+            if after < before
+              opt = [i, j]
+              break
+            end
+          end
+          break unless opt
+          path = two_swap(path, opt[0], opt[1])
+        end
+        path
+      end
+
+      # enumerate possible 2 points to swap
+      def candidate_index_pairs(path)
+        n = path.length
+        (2..(n - 2)).flat_map do |gap|
+          (0..(n - gap - 2)).map do |i|
+            [i, i + gap]
+          end
+        end
+      end
+
+      def candidate_index_pairs_with_loose_end(path)
+        n = path.length
+        (2..(n - 1)).flat_map do |gap|
+          (0..(n - gap - 1)).map do |i|
+            [i, i + gap]
+          end
+        end
+      end
+
+      # 2 points swap operation with assuming
+      #   - i + 2 <= j
+      #   - j < path.length
+      def two_swap(path, i, j)
+        path[0..i] + path[(i + 1)..j].reverse + path[(j + 1)..-1]
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: hiogawa_playground
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Hiroshi Ogawa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-10 00:00:00.000000000 Z
+dependencies: []
+description: hiroshi's playground
+email: hi.ogawa.zz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hiogawa_playground.rb
+- lib/hiogawa_playground/mst.rb
+- lib/hiogawa_playground/tsp.rb
+homepage: http://rubygems.org/gems/hiogawa_playground
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: playground
+test_files: []
+has_rdoc: