Djikstras Algorithm in golang div-bargali#234

Djikstras Algorithm in golang

Author: div-bargali

Go/Algorithms/Graph-Algorithms/djikstras/Example/main.go

@@ -0,0 +1,172 @@
+package main
+
+import (
+"fmt"
+"math"
+
+"github.com/Data-Structures-and-Algorithms/Go/Algorithms/Graph-Algorithms/djikstras/minheapmap"
+)
+
+//Using a MinHeap with O(1) Lookup for an implementation of the Djikstras algo for minimum cost spanning path.
+type node struct {
+name string //ID of the node
+neighbours map[*node]int // indicates a directed edge from the node to the neighbour
+}
+
+func main() {
+//Build a graph representation..
+n1 := &node{
+name: "guitar",
+}
+n2 := &node{
+name: "book",
+}
+n3 := &node{
+name: "LP",
+}
+n4 := &node{
+name: "poster",
+}
+n5 := &node{
+name: "drums",
+}
+n6 := &node{
+name: "piano",
+}
+n1.neighbours = make(map[*node]int)
+n1.neighbours[n6] = 20
+n2.neighbours = make(map[*node]int)
+n2.neighbours[n4] = 0
+n2.neighbours[n3] = 5
+n3.neighbours = make(map[*node]int)
+n3.neighbours[n1] = 15
+n3.neighbours[n5] = 20
+n4.neighbours = make(map[*node]int)
+n4.neighbours[n5] = 10
+n4.neighbours[n1] = 30
+n5.neighbours = make(map[*node]int)
+n5.neighbours[n6] = 10
+src := n2
+// src: ok , adjList: ok
+mheap := minHeapMap{
+minHeap: make([]entry, 0),
+mapping: make(map[*node]int),
+}
+minheapmap.Push(&mheap, entry{
+n: n1,
+cost: math.MaxInt32,
+})
+minheapmap.Push(&mheap, entry{
+n: n3,
+cost: math.MaxInt32,
+})
+minheapmap.Push(&mheap, entry{
+n: n4,
+cost: math.MaxInt32,
+})
+minheapmap.Push(&mheap, entry{
+n: n5,
+cost: math.MaxInt32,
+})
+minheapmap.Push(&mheap, entry{
+n: n6,
+cost: math.MaxInt32,
+})
+minheapmap.Push(&mheap, entry{
+n: n2,
+cost: 0,
+})
+fmt.Println("created heap:", mheap.minHeap)
+srcMap := make(map[*node]*node)
+srcMap[src] = src
+costMap := make(map[*node]int)
+for len(mheap.minHeap) > 0 {
+top := minheapmap.Pop(&mheap).(entry)
+n := top.n
+fmt.Println("taking out", n.name)
+delete(mheap.mapping, n)
+c := top.cost
+fmt.Println("to reach", n.name, "cost:", c)
+costMap[n] = c
+for ngbr, cost := range n.neighbours {
+fmt.Println("at neighbr", ngbr.name, "edge cost:", cost)
+if mheap.contains(ngbr) {
+//current cost
+k := mheap.GetKey(ngbr)
+currCost := mheap.minHeap[k].cost
+fmt.Println("curr cost of reaching", ngbr.name, "-", currCost)
+//if current cost < c+cost
+if c+cost < currCost {
+mheap.minHeap[k].cost = c + cost
+fmt.Println("upgating", ngbr.name, "to", c+cost)
+minheapmap.Decrease(&mheap, ngbr)
+srcMap[ngbr] = n
+}
+// update cost of the ngbr in the heap
+}
+}
+
+}
+for n, c := range costMap {
+fmt.Println("node:", n.name, " cost:", c)
+}
+
+}
+
+//need to implement decrement() in log(n) and contains in O(1)
+type minHeapMap struct {
+minHeap []entry
+mapping map[(*node)]int
+}
+
+type entry struct {
+n *node
+cost int
+}
+
+func (m *minHeapMap) contains(n *node) bool {
+_, ok := m.mapping[n]
+return ok
+}
+
+func (m *minHeapMap) Remove(x interface{}) {
+delete((*m).mapping, x.(entry).n)
+}
+
+func (m *minHeapMap) Update(k, v interface{}) {
+(*m).mapping[k.(entry).n] = v.(int)
+}
+
+func (m minHeapMap) GetElem(x interface{}) interface{} {
+return (m).minHeap[x.(int)]
+}
+
+func (m *minHeapMap) GetKey(x interface{}) int {
+return (*m).mapping[x.(*node)]
+}
+
+func (m *minHeapMap) Len() int {
+return len((*m).minHeap)
+}
+
+func (m *minHeapMap) Less(i, j int) bool {
+return ((*m).minHeap)[i].cost < ((*m).minHeap)[j].cost
+}
+
+func (m *minHeapMap) Swap(i, j int) {
+(*m).minHeap[i], (*m).minHeap[j] = (*m).minHeap[j], (*m).minHeap[i]
+}
+
+func (m *minHeapMap) Push(x interface{}) {
+(*m).minHeap = append((*m).minHeap, x.(entry))
+(*m).mapping[x.(entry).n] = len((*m).minHeap) - 1
+}
+
+func (m *minHeapMap) Pop() interface{} {
+v := (*m).minHeap
+l := len(v)
+top := v[l-1]
+v = v[:l-1]
+(*m).minHeap = v
+return top
+}

Go/Algorithms/Graph-Algorithms/djikstras/minheapmap/minheapmap.go

@@ -0,0 +1,82 @@
+package minheapmap
+
+import "container/heap"
+
+// The Interface type describes the requirements
+// for a type using the routines in this package.
+// Any type that implements it may be used as a
+// min-heap with the keys stored in a map
+
+type Interface interface {
+heap.Interface
+//Remove an element from the corresponding Map for the heap entries
+Remove(x interface{})
+//Update a particular value of an entry in the heap and re-evaluate the heap invariance
+Update(k, v interface{})
+//Get the elem present at a particular index in the heap array
+GetElem(x interface{}) interface{}
+//Get the correspinding value to a key in the Map for the heap entries
+GetKey(x interface{}) int
+}
+
+//Decrease the value associated with the key in the <key,value> tuple
+func Decrease(h Interface, k interface{}) {
+p := h.GetKey(k)
+if !down(h, p, h.Len()) {
+up(h, p)
+}
+}
+
+// Push pushes the element x onto the heap.
+// The complexity is O(log n) where n = h.Len().
+// Push() is for the interface to call and should be used to add keys to the heap
+func Push(h Interface, x interface{}) {
+h.Push(x)
+up(h, h.Len()-1)
+}
+
+// Pop removes and returns the minimum element (according to Less) from the heap.
+func Pop(h Interface) interface{} {
+n := h.Len() - 1
+h.Remove(h.GetElem(0))
+h.Update(h.GetElem(n), 0)
+h.Swap(0, n)
+down(h, 0, n)
+return h.Pop()
+}
+
+func up(h Interface, j int) {
+for {
+i := (j - 1) / 2 // parent
+if i == j || !h.Less(j, i) {
+break
+}
+h.Update(h.GetElem(i), j)
+h.Update(h.GetElem(j), i)
+h.Swap(i, j)
+j = i
+}
+return
+}
+
+func down(h Interface, i0, n int) bool {
+i := i0
+for {
+j1 := 2*i + 1
+if j1 >= n || j1 < 0 { // j1 < 0 after int overflow
+break
+}
+j := j1 // left child
+if j2 := j1 + 1; j2 < n && h.Less(j2, j1) {
+j = j2 // = 2*i + 2 // right child
+}
+if !h.Less(j, i) {
+break
+}
+h.Update(h.GetElem(i), j)
+h.Update(h.GetElem(j), i)
+h.Swap(i, j)
+i = j
+}
+return i > i0
+}