Merge branch 'master' of github.com:chen-shiwei/leetcode

Author: chen-shiwei

leetcode/332.重新安排行程_回溯/findItinerary.go

@@ -0,0 +1,72 @@
+package _322_重新安排行程
+
+import (
+	"sort"
+)
+
+type Airport struct {
+	airport string
+	visited bool
+}
+
+type Airports []Airport
+
+func (a Airports) Len() int {
+	return len(a)
+}
+
+func (a Airports) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+	return
+}
+func (a Airports) Less(i, j int) bool {
+	return a[i].airport < a[j].airport
+}
+
+func findItinerary(tickets [][]string) []string {
+	var (
+		path    []string
+		fn      func(curTicket string, ticketN int) bool
+		targets = make(map[string]Airports)
+	)
+
+	for _, ticket := range tickets {
+		if _, ok := targets[ticket[0]]; !ok {
+			targets[ticket[0]] = make(Airports, 0)
+		}
+		targets[ticket[0]] = append(targets[ticket[0]], Airport{
+			airport: ticket[1],
+			visited: false,
+		})
+	}
+
+	for _, target := range targets {
+		sort.Sort(target)
+	}
+
+	path = append(path, "JFK")
+
+	fn = func(curTicket string, ticketN int) bool {
+		if ticketN == len(tickets) {
+			return true
+		}
+		for i, target := range targets[curTicket] {
+			if target.visited {
+				continue
+			}
+			path = append(path, target.airport)
+			targets[curTicket][i].visited = true
+			if fn(target.airport, ticketN+1) {
+				return true
+			}
+			targets[curTicket][i].visited = false
+			path = path[:len(path)-1]
+		}
+
+		return false
+	}
+
+	fn("JFK", 0)
+
+	return path
+}

leetcode/332.重新安排行程_回溯/findItinerary_test.go

@@ -0,0 +1,26 @@
+package _322_重新安排行程
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_findItinerary(t *testing.T) {
+	type args struct {
+		tickets [][]string
+	}
+	tests := []struct {
+		name string
+		args args
+		want []string
+	}{
+		{name: `[["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]`, args: args{tickets: [][]string{{"JFK", "SFO"}, {"JFK", "ATL"}, {"SFO", "ATL"}, {"ATL", "JFK"}, {"ATL", "SFO"}}}, want: []string{"JFK", "ATL", "JFK", "SFO", "ATL", "SFO"}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := findItinerary(tt.args.tickets); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("findItinerary() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

leetcode/51.N皇后_回溯/solveNQueens.go

@@ -0,0 +1,77 @@
+package _1_N皇后_回溯
+
+import "fmt"
+
+func solveNQueens(n int) [][]string {
+	var (
+		paths [][]string
+		path  = make([][]byte, n)
+		fn    func(col, row int)
+	)
+
+	b := make([]byte, n)
+	for i := 0; i < n; i++ {
+		b[i] = '.'
+	}
+
+	for i := range path {
+		c := make([]byte, n)
+		copy(c, b)
+		path[i] = c
+	}
+
+	fn = func(col, row int) {
+		if row == n {
+			var tmp []string
+			for _, v := range path {
+				tmp = append(tmp, string(v))
+			}
+			paths = append(paths, tmp)
+			return
+		}
+
+		for i := 0; i < n; i++ {
+			if IsValid(path, row, i, n) {
+				path[row][i] = 'Q'
+				fn(i, row+1)
+				path[row][i] = '.'
+			}
+		}
+	}
+	fn(0, 0)
+
+	return paths
+}
+
+func IsValid(chessboard [][]byte, row, col int, n int) bool {
+	// 列
+	for i := 0; i < n; i++ {
+		if chessboard[i][col] == 'Q' {
+			return false
+		}
+	}
+	// 左斜线
+	i := row - 1
+	j := col - 1
+	for i >= 0 && j >= 0 {
+		fmt.Println(i, j)
+		if chessboard[i][j] == 'Q' {
+			return false
+		}
+		i--
+		j--
+	}
+
+	a := row - 1
+	b := col + 1
+
+	for a >= 0 && b < n {
+		if chessboard[a][b] == 'Q' {
+			return false
+		}
+		a--
+		b++
+	}
+
+	return true
+}

leetcode/51.N皇后_回溯/solveNQueens_test.go

@@ -0,0 +1,60 @@
+package _1_N皇后_回溯
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestIsValid(t *testing.T) {
+	type args struct {
+		chessboard [][]byte
+		row        int
+		col        int
+		n          int
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{name: "", args: args{
+			chessboard: [][]byte{
+				{'.', '.', '.', '.'},
+				{'.', 'Q', '.', '.'},
+				{'Q', '.', '.', '.'},
+				{'Q', '.', '.', '.'},
+			},
+			row: 2,
+			col: 2,
+			n:   4,
+		}, want: false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := IsValid(tt.args.chessboard, tt.args.row, tt.args.col, tt.args.n); got != tt.want {
+				t.Errorf("IsValid() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_solveNQueens(t *testing.T) {
+	type args struct {
+		n int
+	}
+	tests := []struct {
+		name string
+		args args
+		want [][]string
+	}{
+		{name: `输入：n = 4
+输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]`, args: args{n: 4}, want: [][]string{{".Q..", "...Q", "Q...", "..Q."}, {"..Q.", "Q...", "...Q", ".Q.."}}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := solveNQueens(tt.args.n); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("solveNQueens() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}