Add dijkstra algorithm with naive priority queue implementation and

corresponding tests
Add parallel reduce and scan with corresponding tests and benchmarks

Author: zhaih

bench/benchParaReduce_test.go

@@ -0,0 +1,31 @@
+package bench
+
+import (
+	"algo/parallel"
+	"testhelper"
+	"testing"
+)
+
+func BenchmarkSeqReduce(b *testing.B) {
+	input := testhelper.BigInput(1000000)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		reduce(input, testhelper.Plus)
+	}
+}
+
+func BenchmarkParaReduce(b *testing.B) {
+	input := testhelper.BigInput(1000000)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		parallel.Reduce(input, testhelper.Plus, 0)
+	}
+}
+
+func reduce(in []int, f func(int, int) int) int {
+	ans := in[0]
+	for i := 1; i < len(in); i++ {
+		ans = f(ans, in[i])
+	}
+	return ans
+}

bench/benchParaScan_test.go

@@ -0,0 +1,56 @@
+package bench
+
+import (
+	"algo/parallel"
+	"testhelper"
+	"testing"
+)
+
+func BenchmarkSeqScan(b *testing.B) {
+	input := testhelper.BigInput(1000000)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		scan(input, testhelper.Plus)
+	}
+}
+
+func BenchmarkParaScan(b *testing.B) {
+	input := testhelper.BigInput(1000000)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		parallel.Scan(input, testhelper.Plus, 0)
+	}
+}
+
+func BenchmarkParaScan2(b *testing.B) {
+	input := testhelper.BigInput(1000000)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		parallel.Scan2(input, testhelper.Plus, 0)
+	}
+}
+
+func BenchmarkParaScan3(b *testing.B) {
+	input := testhelper.BigInput(1000000)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		parallel.Scan3(input, testhelper.Plus, 0, 4)
+	}
+}
+
+func BenchmarkParaScan4(b *testing.B) {
+	input := testhelper.BigInput(1000000)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		parallel.Scan4(input, testhelper.Plus, 0, 4)
+	}
+}
+
+func scan(in []int, f func(int, int) int) []int {
+	ret := make([]int, len(in))
+	copy(ret, in)
+	for i := 1; i < len(ret); i++ {
+		ret[i] = f(ret[i-1], ret[i])
+	}
+	return ret
+}

src/algo/dijkstra/dijkstra.go

@@ -0,0 +1,42 @@
+package dijkstra
+
+import (
+	"algo/union_find"
+	"data"
+)
+
+func Dijkstra(g [][]data.Edge, s int) []int {
+	ret := make([]int, len(g))
+	for i := 0; i < len(g); i++ {
+		if i != s {
+			ret[i] = 1 << 31
+		}
+	}
+	uf := union_find.UnionFind{}
+	uf.Init(len(g))
+	next := s
+	for next != -1 {
+		u := next
+		uf.Union(u, s)
+		for _, e := range g[u] {
+			// relaxing
+			if ret[e.To] > ret[e.From]+e.W {
+				ret[e.To] = ret[e.From] + e.W
+			}
+		}
+		// should use fibonacci heap here, but not intend to implement that
+		// use linear search instead
+		next = -1
+		min := 1 << 31
+		for i := 0; i < len(g); i++ {
+			if uf.IsUnion(i, s) {
+				continue
+			}
+			if ret[i] < min {
+				min = ret[i]
+				next = i
+			}
+		}
+	}
+	return ret
+}