basic: update

Change-Id: I4aa9981ace72fa45481afa4a08735cdf5dfccfdd

Author: qieguo2016

go/basic/dp/dp.go

@@ -1,5 +1,11 @@
 package dp
 
+import (
+	"sort"
+
+	"github.com/qieguo2016/algorithm/go/basic/util"
+)
+
 /**
  * 求最大和子串，求给定整数数组中和最大的连续子串，输出最大和
  * arr: 输入整数数组，至少有一个元素
@@ -17,3 +23,34 @@ func GetMaxSum(arr []int) int {
 	}
 	return maxSum
 }
+
+// 给定金额用最少硬币数兑换
+// 求极值一般会考虑使用动态规划。用dp[i]表示i元的最少硬币兑换数，则状态转移方程：
+// dp[i]=min(dp[i-c])+1, for c in coins（遍历硬币组合）
+// dp[11] = min(dp[6], d[9], dp[10])+1
+// dp[1] = min(dp[-4], dp[-1], dp[0]) + 1
+// dp[0] = 0
+// dp[<0] invalid，用amount+1代替（硬币最小面值为1，最小有amount个，+1标识非法）
+// dp有两种模式，一种在迭代的时候增加记忆数组，另外一种是上来先算记忆数组
+// PS: 这个兑换有个特例，就是各种硬币是倍数关系的时候，这个时候退化成贪婪模式
+
+func coinChange(coins []int, amount int) int {
+	dp := make([]int, amount+1) // dp[0]为边界，需要amount+1个
+	for i := 0; i < amount+1; i++ {
+		dp[i] = amount + 1 // 默认都非法
+	}
+	sort.Ints(coins)
+	dp[0] = 0
+	for i := 1; i <= amount; i++ {
+		for j := 0; j < len(coins); j++ {
+			if coins[j] > i {
+				break
+			}
+			dp[i] = util.Min(dp[i], dp[i-coins[j]]+1)
+		}
+	}
+	if dp[amount] > amount {
+		return -1
+	}
+	return dp[amount]
+}

go/basic/heap/heap.go

@@ -2,6 +2,8 @@ package heap
 
 import (
 	"sort"
+
+	"github.com/qieguo2016/algorithm/go/basic/util"
 )
 
 // SmallRootDown 小根堆向下调整
@@ -23,7 +25,7 @@ func SmallRootDown(target []int, from int, to int) {
 	}
 
 	// 父节点取小节点
-	swap(target, smaller, parent)
+	util.Swap(target, smaller, parent)
 	SmallRootDown(target, parent, to)
 }
 

go/basic/heap/heap_example_test.go

@@ -0,0 +1,138 @@
+package heap_test
+
+import (
+	"container/heap"
+	"fmt"
+	"testing"
+)
+
+type myHeap []int
+
+func (h *myHeap) Less(i, j int) bool {
+	return (*h)[i] < (*h)[j]
+}
+
+func (h *myHeap) Swap(i, j int) {
+	(*h)[i], (*h)[j] = (*h)[j], (*h)[i]
+}
+
+func (h *myHeap) Len() int {
+	return len(*h)
+}
+
+func (h *myHeap) Pop() (v interface{}) {
+	*h, v = (*h)[:h.Len()-1], (*h)[h.Len()-1]
+	return
+}
+
+func (h *myHeap) Push(v interface{}) {
+	*h = append(*h, v.(int))
+}
+
+func TestHeap(t *testing.T) {
+	h := new(myHeap)
+
+	for i := 20; i > 10; i-- {
+		h.Push(i)
+	}
+	heap.Init(h)
+
+	for i := 10; i > 0; i-- {
+		heap.Push(h, i)
+	}
+
+	for i := 1; h.Len() > 0; i++ {
+		x := heap.Pop(h).(int)
+		if i < 20 {
+			heap.Push(h, 20+i)
+		}
+		fmt.Println(x)
+	}
+}
+
+// An Item is something we manage in a priority queue.
+type Item struct {
+	value    string // The value of the item; arbitrary.
+	priority int    // The priority of the item in the queue.
+	// The index is needed by update and is maintained by the heap.Interface methods.
+	index int // The index of the item in the heap.
+}
+
+// A PriorityQueue implements heap.Interface and holds Items.
+type PriorityQueue []*Item
+
+func (pq PriorityQueue) Len() int { return len(pq) }
+
+func (pq PriorityQueue) Less(i, j int) bool {
+	// We want Pop to give us the highest, not lowest, priority so we use greater than here.
+	return pq[i].priority > pq[j].priority
+}
+
+func (pq PriorityQueue) Swap(i, j int) {
+	pq[i], pq[j] = pq[j], pq[i]
+	pq[i].index = i
+	pq[j].index = j
+}
+
+func (pq *PriorityQueue) Push(x interface{}) {
+	n := len(*pq)
+	item := x.(*Item)
+	item.index = n
+	*pq = append(*pq, item)
+}
+
+func (pq *PriorityQueue) Pop() interface{} {
+	old := *pq
+	n := len(old)
+	item := old[n-1]
+	old[n-1] = nil  // avoid memory leak
+	item.index = -1 // for safety
+	*pq = old[0 : n-1]
+	return item
+}
+
+// update modifies the priority and value of an Item in the queue.
+func (pq *PriorityQueue) update(item *Item, value string, priority int) {
+	item.value = value
+	item.priority = priority
+	heap.Fix(pq, item.index)
+}
+
+// This example creates a PriorityQueue with some items, adds and manipulates an item,
+// and then removes the items in priority order.
+func Example_priorityQueue() {
+	// Some items and their priorities.
+	items := map[string]int{
+		"banana": 3, "apple": 2, "pear": 4,
+	}
+
+	// Create a priority queue, put the items in it, and
+	// establish the priority queue (heap) invariants.
+	pq := make(PriorityQueue, len(items))
+	i := 0
+	for value, priority := range items {
+		pq[i] = &Item{
+			value:    value,
+			priority: priority,
+			index:    i,
+		}
+		i++
+	}
+	heap.Init(&pq)
+
+	// Insert a new item and then modify its priority.
+	item := &Item{
+		value:    "orange",
+		priority: 1,
+	}
+	heap.Push(&pq, item)
+	pq.update(item, item.value, 5)
+
+	// Take the items out; they arrive in decreasing priority order.
+	for pq.Len() > 0 {
+		item := heap.Pop(&pq).(*Item)
+		fmt.Printf("%.2d:%s ", item.priority, item.value)
+	}
+	// Output:
+	// 05:orange 04:pear 03:banana 02:apple
+}

go/basic/heap/heap_test.go

@@ -3,6 +3,8 @@ package heap
 import (
 	"fmt"
 	"testing"
+
+	"github.com/qieguo2016/algorithm/go/basic/util"
 )
 
 func printHeap(arr []int) {
@@ -26,7 +28,7 @@ func printHeap(arr []int) {
 
 func TestSmallRootHeap(t *testing.T) {
 	for i := 0; i < 2; i++ {
-		arr := makeRandomArray(7)
+		arr := util.MakeRandomArray(7)
 		fmt.Printf("origin arr=%v\n", arr)
 		NewSmallRootHeap(arr)
 		fmt.Printf("heap arr=%v\n", arr)

go/basic/util.go

@@ -0,0 +1,33 @@
+package util
+
+import (
+	"math/rand"
+)
+
+func Swap(arr []int, i int, j int) {
+	tmp := arr[i]
+	arr[i] = arr[j]
+	arr[j] = tmp
+}
+
+func Min(i, j int) int {
+	if i < j {
+		return i
+	}
+	return j
+}
+
+func Max(i, j int) int {
+	if i > j {
+		return i
+	}
+	return j
+}
+
+func MakeRandomArray(n int) []int {
+	ret := make([]int, n)
+	for i := 0; i < n; i++ {
+		ret[i] = rand.Intn(n * 10)
+	}
+	return ret
+}