array

package

v0.0.0-...-eb09a2a Latest Latest Go to latest Published: Oct 19, 2022 License: Apache-2.0 Imports: 4 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/gopperin/leetcode

Links

Open Source Insights

Documentation ¶

Index ¶

func CanJump(nums []int) bool
func CombinationSum(candidates []int, target int) [][]int
func CombinationSum2(candidates []int, target int) [][]int
func FirstMissingPositive(nums []int) int
func GenerateMatrix(n int) [][]int
func IsValidSudoku(board [][]byte) bool
func IsValidSudoku1(board [][]byte) bool
func Jump(nums []int) int
func MaxArea[T int | int64](height []T) T
func MaxSubArray(nums []int) int
func MaxSubArray1(nums []int) int
func NextPermutation(nums []int)
func NextPermutation1(nums []int)
func Permute(nums []int) [][]int
func PermuteUnique(nums []int) [][]int
func PlusOne(digits []int) []int
func RemoveDuplicates(nums []int) int
func RemoveDuplicates1(nums []int) int
func RemoveElement(nums []int, val int) int
func Rotate(matrix [][]int)
func Rotate1(matrix [][]int)
func SolveNQueens(n int) [][]string
func SolveNQueens2(n int) (res [][]string)
func SolveSudoku(board [][]byte)
func SpiralOrder(matrix [][]int) []int
func SpiralOrder2(matrix [][]int) []int
func TotalNQueens(n int) int
func TotalNQueens1(n int) int
func Trap(height []int) int
type Interval

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

func CanJump ¶

func CanJump(nums []int) bool

Example ¶

package main

import (
	"fmt"
)

type question55 struct {
	para55
	ans55
}

// para 是参数
// one 代表第一个参数
type para55 struct {
	one []int
}

// ans 是答案
// one 代表第一个答案
type ans55 struct {
	one bool
}

func main() {

	qs := []question55{

		{
			para55{[]int{2, 3, 1, 1, 4}},
			ans55{true},
		},
		{
			para55{[]int{3, 2, 1, 0, 4}},
			ans55{false},
		},
	}

	for _, q := range qs {
		_, p := q.ans55, q.para55
		fmt.Println(p, CanJump(p.one))
	}
}

Output:

{[2 3 1 1 4]} true
{[3 2 1 0 4]} false

func CombinationSum ¶

func CombinationSum(candidates []int, target int) [][]int

Example ¶

package main

import (
	"fmt"
)

type question39 struct {
	para39
	ans39
}

// para 是参数
// one 代表第一个参数
type para39 struct {
	n []int
	k int
}

// ans 是答案
// one 代表第一个答案
type ans39 struct {
	one [][]int
}

func main() {

	qs := []question39{

		{
			para39{[]int{2, 3, 6, 7}, 7},
			ans39{[][]int{{7}, {2, 2, 3}}},
		},

		{
			para39{[]int{2, 3, 5}, 8},
			ans39{[][]int{{2, 2, 2, 2}, {2, 3, 3}, {3, 5}}},
		},
	}

	for _, q := range qs {
		_, p := q.ans39, q.para39
		fmt.Println(p, CombinationSum(p.n, p.k))
	}
}

Output:

{[2 3 6 7] 7} [[2 2 3] [7]]
{[2 3 5] 8} [[2 2 2 2] [2 3 3] [3 5]]

func CombinationSum2 ¶

func CombinationSum2(candidates []int, target int) [][]int

Example ¶

package main

import (
	"fmt"
)

type question40 struct {
	para40
	ans40
}

// para 是参数
// one 代表第一个参数
type para40 struct {
	n []int
	k int
}

// ans 是答案
// one 代表第一个答案
type ans40 struct {
	one [][]int
}

func main() {

	qs := []question40{

		{
			para40{[]int{10, 1, 2, 7, 6, 1, 5}, 8},
			ans40{[][]int{{1, 7}, {1, 2, 5}, {2, 6}, {1, 1, 6}}},
		},

		{
			para40{[]int{2, 5, 2, 1, 2}, 5},
			ans40{[][]int{{1, 2, 2}, {5}}},
		},
	}

	for _, q := range qs {
		_, p := q.ans40, q.para40
		fmt.Println(p, CombinationSum2(p.n, p.k))
	}
}

Output:

{[1 1 2 5 6 7 10] 8} [[1 1 6] [1 2 5] [1 7] [2 6]]
{[1 2 2 2 5] 5} [[1 2 2] [5]]

func FirstMissingPositive ¶

func FirstMissingPositive(nums []int) int

Example ¶

package main

import (
	"fmt"
)

type question41 struct {
	para41
	ans41
}

// para 是参数
// one 代表第一个参数
type para41 struct {
	one []int
}

// ans 是答案
// one 代表第一个答案
type ans41 struct {
	one int
}

func main() {

	qs := []question41{

		{
			para41{[]int{10, -1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, -3}},
			ans41{6},
		},

		{
			para41{[]int{10, -1, 8, 6, 7, 3, -2, 5, 4, 2, 1, -3}},
			ans41{9},
		},

		{
			para41{[]int{1}},
			ans41{2},
		},

		{
			para41{[]int{0, 2, 2, 1, 1}},
			ans41{3},
		},

		{
			para41{[]int{}},
			ans41{1},
		},

		{
			para41{[]int{1, 2, 0}},
			ans41{3},
		},

		{
			para41{[]int{3, 4, -1, 1}},
			ans41{2},
		},
	}

	for _, q := range qs {
		_, p := q.ans41, q.para41
		fmt.Println(p, FirstMissingPositive(p.one))
	}
}

Output:

{[10 -1 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5 -3]} 6
{[10 -1 8 6 7 3 -2 5 4 2 1 -3]} 9
{[1]} 2
{[0 2 2 1 1]} 3
{[]} 1
{[1 2 0]} 3
{[3 4 -1 1]} 2

func GenerateMatrix ¶

func GenerateMatrix(n int) [][]int

Example ¶

package main

import (
	"fmt"
)

type question59 struct {
	para59
	ans59
}

// para 是参数
// one 代表第一个参数
type para59 struct {
	one int
}

// ans 是答案
// one 代表第一个答案
type ans59 struct {
	one [][]int
}

func main() {

	qs := []question59{

		{
			para59{3},
			ans59{[][]int{{1, 2, 3}, {8, 9, 4}, {7, 6, 5}}},
		},

		{
			para59{4},
			ans59{[][]int{{1, 2, 3, 4}, {12, 13, 14, 5}, {11, 16, 15, 6}, {10, 9, 8, 7}}},
		},
	}

	for _, q := range qs {
		_, p := q.ans59, q.para59
		fmt.Println(p, GenerateMatrix(p.one))
	}
}

Output:

{3} [[1 2 3] [8 9 4] [7 6 5]]
{4} [[1 2 3 4] [12 13 14 5] [11 16 15 6] [10 9 8 7]]

func IsValidSudoku ¶

func IsValidSudoku(board [][]byte) bool

解法一暴力遍历，时间复杂度 O(n^3)

func IsValidSudoku1 ¶

func IsValidSudoku1(board [][]byte) bool

解法二添加缓存，时间复杂度 O(n^2)

Example ¶

package main

import (
	"fmt"
)

type question36 struct {
	para36
	ans36
}

// para 是参数
// one 代表第一个参数
type para36 struct {
	s [][]byte
}

// ans 是答案
// one 代表第一个答案
type ans36 struct {
	s bool
}

func main() {

	qs := []question36{

		{
			para36{[][]byte{
				{'5', '3', '.', '.', '7', '.', '.', '.', '.'},
				{'6', '.', '.', '1', '9', '5', '.', '.', '.'},
				{'.', '9', '8', '.', '.', '.', '.', '6', '.'},
				{'8', '.', '.', '.', '6', '.', '.', '.', '3'},
				{'4', '.', '.', '8', '.', '3', '.', '.', '1'},
				{'7', '.', '.', '.', '2', '.', '.', '.', '6'},
				{'.', '6', '.', '.', '.', '.', '2', '8', '.'},
				{'.', '.', '.', '4', '1', '9', '.', '.', '5'},
				{'.', '.', '.', '.', '8', '.', '.', '7', '9'}}},
			ans36{true},
		},

		{
			para36{[][]byte{
				{'8', '3', '.', '.', '7', '.', '.', '.', '.'},
				{'6', '.', '.', '1', '9', '5', '.', '.', '.'},
				{'.', '9', '8', '.', '.', '.', '.', '6', '.'},
				{'8', '.', '.', '.', '6', '.', '.', '.', '3'},
				{'4', '.', '.', '8', '.', '3', '.', '.', '1'},
				{'7', '.', '.', '.', '2', '.', '.', '.', '6'},
				{'.', '6', '.', '.', '.', '.', '2', '8', '.'},
				{'.', '.', '.', '4', '1', '9', '.', '.', '5'},
				{'.', '.', '.', '.', '8', '.', '.', '7', '9'}}},
			ans36{false},
		},

		{
			para36{[][]byte{
				{'.', '8', '7', '6', '5', '4', '3', '2', '1'},
				{'2', '.', '.', '.', '.', '.', '.', '.', '.'},
				{'3', '.', '.', '.', '.', '.', '.', '.', '.'},
				{'4', '.', '.', '.', '.', '.', '.', '.', '.'},
				{'5', '.', '.', '.', '.', '.', '.', '.', '.'},
				{'6', '.', '.', '.', '.', '.', '.', '.', '.'},
				{'7', '.', '.', '.', '.', '.', '.', '.', '.'},
				{'8', '.', '.', '.', '.', '.', '.', '.', '.'},
				{'9', '.', '.', '.', '.', '.', '.', '.', '.'}}},
			ans36{true},
		},
	}

	for _, q := range qs {
		_, p := q.ans36, q.para36
		fmt.Println(p, IsValidSudoku1(p.s))
	}
}

Output:

{[[53 51 46 46 55 46 46 46 46] [54 46 46 49 57 53 46 46 46] [46 57 56 46 46 46 46 54 46] [56 46 46 46 54 46 46 46 51] [52 46 46 56 46 51 46 46 49] [55 46 46 46 50 46 46 46 54] [46 54 46 46 46 46 50 56 46] [46 46 46 52 49 57 46 46 53] [46 46 46 46 56 46 46 55 57]]} true
{[[56 51 46 46 55 46 46 46 46] [54 46 46 49 57 53 46 46 46] [46 57 56 46 46 46 46 54 46] [56 46 46 46 54 46 46 46 51] [52 46 46 56 46 51 46 46 49] [55 46 46 46 50 46 46 46 54] [46 54 46 46 46 46 50 56 46] [46 46 46 52 49 57 46 46 53] [46 46 46 46 56 46 46 55 57]]} false
{[[46 56 55 54 53 52 51 50 49] [50 46 46 46 46 46 46 46 46] [51 46 46 46 46 46 46 46 46] [52 46 46 46 46 46 46 46 46] [53 46 46 46 46 46 46 46 46] [54 46 46 46 46 46 46 46 46] [55 46 46 46 46 46 46 46 46] [56 46 46 46 46 46 46 46 46] [57 46 46 46 46 46 46 46 46]]} true

func Jump ¶

func Jump(nums []int) int

Example ¶

package main

import (
	"fmt"
)

type question45 struct {
	para45
	ans45
}

// para 是参数
// one 代表第一个参数
type para45 struct {
	nums []int
}

// ans 是答案
// one 代表第一个答案
type ans45 struct {
	one int
}

func main() {

	qs := []question45{

		{
			para45{[]int{2, 3, 1, 1, 4}},
			ans45{2},
		},

		{
			para45{[]int{2, 3, 0, 1, 4}},
			ans45{2},
		},
	}

	for _, q := range qs {
		_, p := q.ans45, q.para45
		fmt.Println(p, Jump(p.nums))
	}
}

Output:

{[2 3 1 1 4]} 2
{[2 3 0 1 4]} 2

func MaxArea ¶

func MaxArea[T int | int64](height []T) T

Example ¶

package main

import (
	"fmt"
)

type question11 struct {
	para11
	ans11
}

// para 是参数
// one 代表第一个参数
type para11 struct {
	one []int
}

// ans 是答案
// one 代表第一个答案
type ans11 struct {
	one int
}

func main() {

	qs := []question11{

		{
			para11{[]int{1, 8, 6, 2, 5, 4, 8, 3, 7}},
			ans11{49},
		},

		{
			para11{[]int{1, 1}},
			ans11{1},
		},
	}

	for _, q := range qs {
		_, p := q.ans11, q.para11
		fmt.Println(MaxArea(p.one))
	}

}

Output:

49
1

func MaxSubArray ¶

func MaxSubArray(nums []int) int

解法一 DP

Example ¶

package main

import (
	"fmt"
)

type question53 struct {
	para53
	ans53
}

// para 是参数
// one 代表第一个参数
type para53 struct {
	one []int
}

// ans 是答案
// one 代表第一个答案
type ans53 struct {
	one int
}

func main() {

	qs := []question53{

		{
			para53{[]int{-2, 1, -3, 4, -1, 2, 1, -5, 4}},
			ans53{6},
		},
		{
			para53{[]int{2, 7, 9, 3, 1}},
			ans53{22},
		},

		{
			para53{[]int{2}},
			ans53{2},
		},

		{
			para53{[]int{-1, -2}},
			ans53{-1},
		},
	}

	for _, q := range qs {
		_, p := q.ans53, q.para53
		fmt.Println(p, MaxSubArray(p.one))
	}
}

Output:

{[-2 1 -3 4 -1 2 1 -5 4]} 6
{[2 7 9 3 1]} 22
{[2]} 2
{[-1 -2]} -1

func MaxSubArray1 ¶

func MaxSubArray1(nums []int) int

解法二模拟

func NextPermutation ¶

func NextPermutation(nums []int)

解法一

Example ¶

package main

import (
	"fmt"
)

type question31 struct {
	para31
	ans31
}

// para 是参数
// one 代表第一个参数
type para31 struct {
	nums []int
}

// ans 是答案
// one 代表第一个答案
type ans31 struct {
	one []int
}

func main() {

	qs := []question31{

		{
			para31{[]int{1, 2, 3}},
			ans31{[]int{1, 3, 2}},
		},

		{
			para31{[]int{3, 2, 1}},
			ans31{[]int{1, 2, 3}},
		},

		{
			para31{[]int{1, 1, 5}},
			ans31{[]int{1, 5, 1}},
		},

		{
			para31{[]int{1}},
			ans31{[]int{1}},
		},
	}

	for _, q := range qs {
		_, p := q.ans31, q.para31
		NextPermutation(p.nums)
		fmt.Println(p.nums)
	}

}

Output:

[1 3 2]
[1 2 3]
[1 5 1]
[1]

func NextPermutation1 ¶

func NextPermutation1(nums []int)

解法二 [2,(3),6,5,4,1] -> 2,(4),6,5,(3),1 -> 2,4, 1,3,5,6

func Permute ¶

func Permute(nums []int) [][]int

Example ¶

package main

import (
	"fmt"
)

type question46 struct {
	para46
	ans46
}

// para 是参数
// one 代表第一个参数
type para46 struct {
	s []int
}

// ans 是答案
// one 代表第一个答案
type ans46 struct {
	one [][]int
}

func main() {

	qs := []question46{

		{
			para46{[]int{1, 2, 3}},
			ans46{[][]int{{1, 2, 3}, {1, 3, 2}, {2, 1, 3}, {2, 3, 1}, {3, 1, 2}, {3, 2, 1}}},
		},
	}

	for _, q := range qs {
		_, p := q.ans46, q.para46
		fmt.Println(p, Permute(p.s))
	}
}

Output:

{[1 2 3]} [[1 2 3] [1 3 2] [2 1 3] [2 3 1] [3 1 2] [3 2 1]]

func PermuteUnique ¶

func PermuteUnique(nums []int) [][]int

Example ¶

package main

import (
	"fmt"
)

type question47 struct {
	para47
	ans47
}

// para 是参数
// one 代表第一个参数
type para47 struct {
	s []int
}

// ans 是答案
// one 代表第一个答案
type ans47 struct {
	one [][]int
}

func main() {

	qs := []question47{

		{
			para47{[]int{1, 1, 2}},
			ans47{[][]int{{1, 1, 2}, {1, 2, 1}, {2, 1, 1}}},
		},

		{
			para47{[]int{1, 2, 2}},
			ans47{[][]int{{1, 2, 2}, {2, 2, 1}, {2, 1, 2}}},
		},

		{
			para47{[]int{2, 2, 2}},
			ans47{[][]int{{2, 2, 2}}},
		},
	}

	for _, q := range qs {
		_, p := q.ans47, q.para47
		fmt.Println(p, PermuteUnique(p.s))
	}
}

Output:

{[1 1 2]} [[1 1 2] [1 2 1] [2 1 1]]
{[1 2 2]} [[1 2 2] [2 1 2] [2 2 1]]
{[2 2 2]} [[2 2 2]]

func PlusOne ¶

func PlusOne(digits []int) []int

Example ¶

package main

import (
	"fmt"
)

type question66 struct {
	para66
	ans66
}

// para 是参数
// one 代表第一个参数
type para66 struct {
	one []int
}

// ans 是答案
// one 代表第一个答案
type ans66 struct {
	one []int
}

func main() {

	qs := []question66{

		{
			para66{[]int{1, 2, 3}},
			ans66{[]int{1, 2, 4}},
		},

		{
			para66{[]int{4, 3, 2, 1}},
			ans66{[]int{4, 3, 2, 2}},
		},

		{
			para66{[]int{9, 9}},
			ans66{[]int{1, 0, 0}},
		},

		{
			para66{[]int{0}},
			ans66{[]int{0}},
		},
	}

	for _, q := range qs {
		_, p := q.ans66, q.para66
		fmt.Println(p, PlusOne(p.one))
	}
}

Output:

{[1 2 4]} [1 2 4]
{[4 3 2 2]} [4 3 2 2]
{[1 0]} [1 0 0]
{[1]} [1]

func RemoveDuplicates ¶

func RemoveDuplicates(nums []int) int

解法一

Example ¶

package main

import (
	"fmt"
)

type question26 struct {
	para26
	ans26
}

// para 是参数
// one 代表第一个参数
type para26 struct {
	one []int
}

// ans 是答案
// one 代表第一个答案
type ans26 struct {
	one int
}

func main() {

	qs := []question26{

		{
			para26{[]int{1, 1, 2}},
			ans26{2},
		},

		{
			para26{[]int{0, 0, 1, 1, 1, 1, 2, 3, 4, 4}},
			ans26{5},
		},

		{
			para26{[]int{0, 0, 0, 0, 0}},
			ans26{1},
		},

		{
			para26{[]int{1}},
			ans26{1},
		},
	}

	for _, q := range qs {
		_, p := q.ans26, q.para26
		fmt.Println(p.one, RemoveDuplicates(p.one))
	}
}

Output:

[1 2 2] 2
[0 1 2 3 4 1 2 3 4 4] 5
[0 0 0 0 0] 1
[1] 1

func RemoveDuplicates1 ¶

func RemoveDuplicates1(nums []int) int

解法二

func RemoveElement ¶

func RemoveElement(nums []int, val int) int

Example ¶

package main

import (
	"fmt"
)

type question27 struct {
	para27
	ans27
}

// para 是参数
// one 代表第一个参数
type para27 struct {
	one []int
	two int
}

// ans 是答案
// one 代表第一个答案
type ans27 struct {
	one int
}

func main() {

	qs := []question27{

		{
			para27{[]int{1, 0, 1}, 1},
			ans27{1},
		},

		{
			para27{[]int{0, 1, 0, 3, 0, 12}, 0},
			ans27{3},
		},

		{
			para27{[]int{0, 1, 0, 3, 0, 0, 0, 0, 1, 12}, 0},
			ans27{4},
		},

		{
			para27{[]int{0, 0, 0, 0, 0}, 0},
			ans27{0},
		},

		{
			para27{[]int{1}, 1},
			ans27{0},
		},

		{
			para27{[]int{0, 1, 2, 2, 3, 0, 4, 2}, 2},
			ans27{5},
		},
	}

	for _, q := range qs {
		_, p := q.ans27, q.para27
		fmt.Println(p.one, RemoveElement(p.one, p.two))
	}
}

Output:

[0 1 1] 1
[1 3 12 0 0 0] 3
[1 3 1 12 0 0 0 0 0 0] 4
[0 0 0 0 0] 0
[1] 0
[0 1 3 0 4 2 2 2] 5

func Rotate ¶

func Rotate(matrix [][]int)

解法一

Example ¶

package main

import (
	"fmt"
)

type question48 struct {
	para48
	ans48
}

// para 是参数
// one 代表第一个参数
type para48 struct {
	s [][]int
}

// ans 是答案
// one 代表第一个答案
type ans48 struct {
	s [][]int
}

func main() {

	qs := []question48{

		{
			para48{[][]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}},
			ans48{[][]int{{7, 4, 1}, {8, 5, 2}, {9, 6, 3}}},
		},

		{
			para48{[][]int{{5, 1, 9, 11}, {2, 4, 8, 10}, {13, 3, 6, 7}, {15, 14, 12, 16}}},
			ans48{[][]int{{15, 13, 2, 5}, {14, 3, 4, 1}, {12, 6, 8, 9}, {16, 7, 10, 11}}},
		},
	}

	for _, q := range qs {
		_, p := q.ans48, q.para48
		Rotate(p.s)
		fmt.Println(p)
	}

}

Output:

{[[7 4 1] [8 5 2] [9 6 3]]}
{[[15 13 2 5] [14 3 4 1] [12 6 8 9] [16 7 10 11]]}

func Rotate1 ¶

func Rotate1(matrix [][]int)

解法二

func SolveNQueens ¶

func SolveNQueens(n int) [][]string

解法一 DFS

Example ¶

package main

import (
	"fmt"
)

type question51 struct {
	para51
	ans51
}

// para 是参数
// one 代表第一个参数
type para51 struct {
	one int
}

// ans 是答案
// one 代表第一个答案
type ans51 struct {
	one [][]string
}

func main() {

	qs := []question51{

		{
			para51{4},
			ans51{[][]string{
				{".Q..",
					"...Q",
					"Q...",
					"..Q."},
				{"..Q.",
					"Q...",
					"...Q",
					".Q.."},
			}},
		},
	}

	for _, q := range qs {
		_, p := q.ans51, q.para51
		fmt.Println(p, SolveNQueens(p.one))
	}
}

Output:

{4} [[.Q.. ...Q Q... ..Q.] [..Q. Q... ...Q .Q..]]

func SolveNQueens2 ¶

func SolveNQueens2(n int) (res [][]string)

解法二二进制操作法 Signed-off-by: Hanlin Shi shihanlin9@gmail.com

func SolveSudoku ¶

func SolveSudoku(board [][]byte)

Example ¶

package main

import (
	"fmt"
)

type question37 struct {
	para37
	ans37
}

// para 是参数
// one 代表第一个参数
type para37 struct {
	s [][]byte
}

// ans 是答案
// one 代表第一个答案
type ans37 struct {
	s [][]byte
}

func main() {

	qs := []question37{

		{
			para37{[][]byte{
				{'5', '3', '.', '.', '7', '.', '.', '.', '.'},
				{'6', '.', '.', '1', '9', '5', '.', '.', '.'},
				{'.', '9', '8', '.', '.', '.', '.', '6', '.'},
				{'8', '.', '.', '.', '6', '.', '.', '.', '3'},
				{'4', '.', '.', '8', '.', '3', '.', '.', '1'},
				{'7', '.', '.', '.', '2', '.', '.', '.', '6'},
				{'.', '6', '.', '.', '.', '.', '2', '8', '.'},
				{'.', '.', '.', '4', '1', '9', '.', '.', '5'},
				{'.', '.', '.', '.', '8', '.', '.', '7', '9'}}},
			ans37{[][]byte{
				{'5', '3', '4', '6', '7', '8', '9', '1', '2'},
				{'6', '7', '2', '1', '9', '5', '3', '4', '8'},
				{'1', '9', '8', '3', '4', '2', '5', '6', '7'},
				{'8', '5', '9', '7', '6', '1', '4', '2', '3'},
				{'4', '2', '6', '8', '5', '3', '7', '9', '1'},
				{'7', '1', '3', '9', '2', '4', '8', '5', '6'},
				{'9', '6', '1', '5', '3', '7', '2', '8', '4'},
				{'2', '8', '7', '4', '1', '9', '6', '3', '5'},
				{'3', '4', '5', '2', '8', '6', '1', '7', '9'}}},
		},
	}

	for _, q := range qs {
		_, p := q.ans37, q.para37
		SolveSudoku(p.s)
		fmt.Println(p)
	}
}

Output:

{[[53 51 52 54 55 56 57 49 50] [54 55 50 49 57 53 51 52 56] [49 57 56 51 52 50 53 54 55] [56 53 57 55 54 49 52 50 51] [52 50 54 56 53 51 55 57 49] [55 49 51 57 50 52 56 53 54] [57 54 49 53 51 55 50 56 52] [50 56 55 52 49 57 54 51 53] [51 52 53 50 56 54 49 55 57]]}

func SpiralOrder ¶

func SpiralOrder(matrix [][]int) []int

解法 1

Example ¶

package main

import (
	"fmt"
)

type question54 struct {
	para54
	ans54
}

// para 是参数
// one 代表第一个参数
type para54 struct {
	one [][]int
}

// ans 是答案
// one 代表第一个答案
type ans54 struct {
	one []int
}

func main() {

	qs := []question54{

		{
			para54{[][]int{{3}, {2}}},
			ans54{[]int{3, 2}},
		},

		{
			para54{[][]int{{2, 3}}},
			ans54{[]int{2, 3}},
		},

		{
			para54{[][]int{{1}}},
			ans54{[]int{1}},
		},

		{
			para54{[][]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}},
			ans54{[]int{1, 2, 3, 6, 9, 8, 7, 4, 5}},
		},
		{
			para54{[][]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}},
			ans54{[]int{1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7}},
		},
	}

	for _, q := range qs {
		_, p := q.ans54, q.para54
		fmt.Println(p, SpiralOrder(p.one))
	}
}

Output:

{[[3] [2]]} [3 2]
{[[2 3]]} [2 3]
{[[1]]} [1]
{[[1 2 3] [4 5 6] [7 8 9]]} [1 2 3 6 9 8 7 4 5]
{[[1 2 3 4] [5 6 7 8] [9 10 11 12]]} [1 2 3 4 8 12 11 10 9 5 6 7]

func SpiralOrder2 ¶

func SpiralOrder2(matrix [][]int) []int

解法 2

func TotalNQueens ¶

func TotalNQueens(n int) int

解法一，暴力打表法

Example ¶

package main

import (
	"fmt"
)

type question52 struct {
	para52
	ans52
}

// para 是参数
// one 代表第一个参数
type para52 struct {
	one int
}

// ans 是答案
// one 代表第一个答案
type ans52 struct {
	one int
}

func main() {

	qs := []question52{

		{
			para52{1},
			ans52{1},
		},

		{
			para52{2},
			ans52{0},
		},
		{
			para52{3},
			ans52{0},
		},

		{
			para52{4},
			ans52{2},
		},

		{
			para52{5},
			ans52{10},
		},

		{
			para52{6},
			ans52{4},
		},

		{
			para52{7},
			ans52{40},
		},

		{
			para52{8},
			ans52{92},
		},

		{
			para52{9},
			ans52{352},
		},

		{
			para52{10},
			ans52{724},
		},
	}

	for _, q := range qs {
		_, p := q.ans52, q.para52
		fmt.Println(p, TotalNQueens(p.one))
	}
}

Output:

{1} 1
{2} 0
{3} 0
{4} 2
{5} 10
{6} 4
{7} 40
{8} 92
{9} 352
{10} 724

func TotalNQueens1 ¶

func TotalNQueens1(n int) int

解法二，DFS 回溯法

func Trap ¶

func Trap(height []int) int

Example ¶

package main

import (
	"fmt"
)

type question42 struct {
	para42
	ans42
}

// para 是参数
// one 代表第一个参数
type para42 struct {
	one []int
}

// ans 是答案
// one 代表第一个答案
type ans42 struct {
	one int
}

func main() {

	qs := []question42{

		{
			para42{[]int{0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1}},
			ans42{6},
		},
	}

	for _, q := range qs {
		_, p := q.ans42, q.para42
		fmt.Println(p, Trap(p.one))
	}
}

Output:

{[0 1 0 2 1 0 1 3 2 1 2 1]} 6

Types ¶

type Interval ¶

type Interval = structures.Interval

Interval define

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL

array

Documentation ¶

Index ¶

Examples ¶

Constants ¶

Variables ¶

Functions ¶

func CanJump ¶

func CombinationSum ¶

func CombinationSum2 ¶

func FirstMissingPositive ¶

func GenerateMatrix ¶

func IsValidSudoku ¶

func IsValidSudoku1 ¶

func Jump ¶

func MaxArea ¶

func MaxSubArray ¶

func MaxSubArray1 ¶

func NextPermutation ¶

func NextPermutation1 ¶

func Permute ¶

func PermuteUnique ¶

func PlusOne ¶

func RemoveDuplicates ¶

func RemoveDuplicates1 ¶

func RemoveElement ¶

func Rotate ¶

func Rotate1 ¶

func SolveNQueens ¶

func SolveNQueens2 ¶

func SolveSudoku ¶

func SpiralOrder ¶

func SpiralOrder2 ¶

func TotalNQueens ¶

func TotalNQueens1 ¶

func Trap ¶

Types ¶

type Interval ¶

Source Files ¶