add depthFirst && breadthFirst

Author: eruca

breadthFirst/breadthFirst.go

@@ -0,0 +1,80 @@
+package main
+
+import (
+	"fmt"
+)
+
+type node struct {
+	x int
+	y int
+	f int
+	s int
+}
+
+func main() {
+	var que [2501]node
+	var a, book [51][51]int
+	var next = [4][2]int{{0, 1},
+		{1, 0},
+		{0, -1},
+		{-1, 0},
+	}
+
+	var head, tail int
+
+	var n, m int
+	fmt.Println("input the n×m")
+	fmt.Scanf("%d %d", &n, &m)
+	for i := 1; i <= n; i++ {
+		for j := 1; j <= m; j++ {
+			fmt.Scanf("%d", &a[i][j])
+		}
+	}
+
+	var startX, startY, p, q int
+	fmt.Scanf("%d %d %d %d", &startX, &startY, &p, &q)
+
+	head = 1
+	tail = 1
+
+	que[tail].x = startX
+	que[tail].y = startY
+	que[tail].f = 0
+	que[tail].s = 0
+	tail++
+	book[startX][startY] = 1
+
+	var flag = 0
+	var tx, ty int
+	for head < tail {
+		for i := 0; i <= 3; i++ {
+			tx = que[head].x + next[i][0]
+			ty = que[head].y + next[i][1]
+
+			if tx < 1 || tx > n || ty < 1 || ty > m {
+				continue
+			}
+
+			if a[tx][ty] == 0 && book[tx][ty] == 0 {
+				book[tx][ty] = 1
+				que[tail].x = tx
+				que[tail].y = ty
+				que[tail].f = head
+				que[tail].s = que[head].s + 1
+				tail++
+			}
+
+			if tx == p && ty == q {
+				flag = 1
+				break
+			}
+		}
+
+		if flag == 1 {
+			break
+		}
+		head++
+	}
+
+	fmt.Print(que[tail-1].s)
+}

breadthFirst2/Searcher.go

@@ -0,0 +1,83 @@
+package main
+
+import (
+	"log"
+	"strings"
+)
+
+type node struct {
+	pt     point
+	steps  int
+	father int
+}
+
+var directions = [4][2]int{
+	{0, 1}, {1, 0}, {0, -1}, {-1, 0},
+}
+
+type Searcher struct {
+	StartPt    point
+	book       []point
+	m          *Map
+	queue      []node
+	head, tail int
+}
+
+func NewSearcher(m *Map, pt point) *Searcher {
+	book := make([]point, 1, 16)
+	book[0] = pt
+	queue := make([]node, 1, 16)
+	queue[0].pt = pt
+
+	return &Searcher{StartPt: pt, book: book, m: m, queue: queue, tail: 1}
+}
+
+func (s Searcher) IsWalked(pt point) bool {
+	for _, v := range s.book {
+		if v == pt {
+			return true
+		}
+	}
+	return false
+}
+
+func (s Searcher) Path() string {
+	res := make([]string, 0, 16)
+	for i := len(s.queue) - 1; i != 0; i = s.queue[i].father {
+		res = append(res, s.queue[i].pt.String())
+	}
+	reverse := make([]string, len(res))
+	var index int
+	for i := len(res) - 1; i >= 0; i-- {
+		reverse[index] = res[i]
+		index++
+	}
+	return strings.Join(reverse, " ")
+}
+
+func (s *Searcher) Walk() string {
+	var next point
+Label:
+	for s.head < s.tail {
+		for _, dir := range directions {
+			next = s.queue[s.head].pt.walk(dir)
+			if s.m.Illegal(next) || s.IsWalked(next) {
+				continue
+			}
+			s.book = append(s.book, next)
+
+			var newNode node
+			newNode.pt = next
+			newNode.father = s.head
+			newNode.steps = s.queue[s.head].steps + 1
+			s.queue = append(s.queue, newNode)
+			s.tail++
+
+			if s.m.Arrive(next) {
+				break Label
+			}
+		}
+		s.head++
+	}
+	return s.Path()
+}

breadthFirst2/breadthFirst2.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	m := NewMap(5, 4)
+	searcher := NewSearcher(m, point{0, 0})
+	fmt.Println(searcher.Walk())
+}

breadthFirst2/map.go

@@ -0,0 +1,41 @@
+package main
+
+type Map struct {
+	data [][]int
+	x    int
+	y    int
+}
+
+func NewMap(n, m int) *Map {
+	var M Map
+	M.data = make([][]int, n)
+	for k, _ := range M.data {
+		M.data[k] = make([]int, m)
+	}
+
+	M.x = n - 1
+	M.y = m - 1
+	M.Init()
+	return &M
+}
+
+func (m *Map) Init() {
+	m.data[0][2] = -1
+	m.data[2][2] = -1
+	m.data[3][1] = -1
+	m.data[4][3] = -1
+	m.data[3][3] = 1
+}
+
+func (m Map) find(pt point) int {
+	return m.data[pt.x][pt.y]
+}
+
+func (m Map) Illegal(pt point) bool {
+	return pt.x < 0 || pt.x > m.x || pt.y < 0 ||
+		pt.y > m.y || m.find(pt) == -1
+}
+
+func (m Map) Arrive(pt point) bool {
+	return m.find(pt) == 1
+}

breadthFirst2/map_test.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestMap(t *testing.T) {
+	m := NewMap(5, 4)
+	fmt.Println(m.data)
+	if m == nil {
+		t.Error("should not happened")
+	}
+	if m.x != 4 || m.y != 3 {
+		t.Error("5,4", m.y, m.x)
+	}
+
+	if !m.Illegal(point{-1, 0}) || !m.Illegal(point{4, 3}) {
+		t.Error("illegal but not")
+	}
+
+	if m.Arrive(point{2, 3}) {
+		t.Error("illegal but not")
+	}
+	if !m.Arrive(point{3, 3}) {
+		t.Error("illegal but not")
+	}
+}

breadthFirst2/pt.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"fmt"
+)
+
+type point struct {
+	x, y int
+}
+
+func (p point) walk(dir [2]int) (next point) {
+	next.x = p.x + dir[0]
+	next.y = p.y + dir[1]
+	return next
+}
+
+func (p point) String() string {
+	return fmt.Sprintf("(%d,%d)", p.x, p.y)
+}

breadthFirst2/searcher_test.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestSearcher(t *testing.T) {
+	m := NewMap(5, 4)
+	s := NewSearcher(m, point{0, 0})
+	fmt.Println(s.Walk())
+}

depthFirst/depthFirst.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"fmt"
+)
+
+var (
+	n    int
+	a    []int
+	book []int
+)
+
+func dfs(step int) {
+	if step > n {
+		for i := 1; i <= n; i++ {
+			fmt.Print(a[i])
+		}
+		fmt.Println("")
+		return
+	}
+	for i := 1; i <= n; i++ {
+		if book[i] == 0 {
+			a[step] = i
+			book[i] = 1
+
+			dfs(step + 1)
+			book[i] = 0
+		}
+	}
+}
+
+func main() {
+	fmt.Println("请输入n的值")
+	fmt.Scanf("%d", &n)
+	fmt.Println("n:", n)
+	a = make([]int, n+1)
+	book = make([]int, n+1)
+	fmt.Println(a)
+
+	dfs(1)
+}