195. 第十行 Tenth Line

给定一个文本文件 file.txt，请只打印这个文件中的第十行。

示例:

假设 file.txt 有如下内容：

Line 1
Line 2
Line 3
Line 4
Line 5
Line 6
Line 7
Line 8
Line 9
Line 10

你的脚本应当显示第十行：

Line 10

说明:
1. 如果文件少于十行，你应当输出什么？
2. 至少有三种不同的解法，请尝试尽可能多的方法来解题。

代码：

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	file, _ := os.Open("file.txt")
	defer file.Close()

	scanner := bufio.NewScanner(file)
	lineCount := 0

	for scanner.Scan() {
		lineCount++
		if lineCount == 10 {
			fmt.Println(scanner.Text())
			return
		}
	}

	if err := scanner.Err(); err != nil {
		fmt.Fprintln(os.Stderr, "reading file error:", err)
	}
}

调用系统命令：

awk 'NR == 10' file.txt
tail -n +10 file.txt | head -n 1
sed -n '10p' file.txt
grep '' file.txt | sed -n '10p'

调用代码：

package main
 
import (
    "fmt"
    "os/exec"
)
 
func main() {
    cmd := exec.Command("awk", "NR==10", "file.txt")
    output, err := cmd.Output()
    if err != nil {
        fmt.Println(err)
    }
    fmt.Print(string(output))
}

198. 打家劫舍 House Robber

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例 1：

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
     偷窃到的最高金额 = 1 + 3 = 4 。

示例 2：

输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
     偷窃到的最高金额 = 2 + 9 + 1 = 12 。

提示：

1 <= nums.length <= 100
0 <= nums[i] <= 400

代码1： 动态规划

package main

import "fmt"

func rob(nums []int) int {
	n := len(nums)
	if n == 0 {
		return 0
	}
	dp := make([]int, n+1)
	dp[1] = nums[0]
	for i := 2; i <= n; i++ {
		dp[i] = max(dp[i-1], dp[i-2]+nums[i-1])
	}
	return dp[n]
}

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

func main() {
	nums := []int{1, 2, 3, 1}
	fmt.Println(rob(nums))
	nums = []int{2, 7, 9, 3, 1}
	fmt.Println(rob(nums))
}

其它写法：

```golang
func rob(nums []int) int {
   if len(nums) == 0 {
       return 0
   }
   if len(nums) == 1 {
       return nums[0]
   }
   dp := make([]int, len(nums))
   dp[0] = nums[0]
   dp[1] = max(nums[0], nums[1])
   for i := 2; i < len(nums); i++ {
       dp[i] = max(dp[i-2]+nums[i], dp[i-1])
   }
   return dp[len(nums)-1]
}
```

代码2： 使用滚动数组优化空间

package main

import "fmt"

func rob(nums []int) int {
	n := len(nums)
	if n == 0 {
		return 0
	}
	var pre, cur int
	cur = nums[0]
	for i := 2; i <= n; i++ {
		cur, pre = max(pre+nums[i-1], cur), cur
	}
	return cur
}

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

func main() {
	nums := []int{1, 2, 3, 1}
	fmt.Println(rob(nums))
	nums = []int{2, 7, 9, 3, 1}
	fmt.Println(rob(nums))
}

代码3： 递归+记忆化搜索

package main

import "fmt"

func rob(nums []int) int {
	mem := make([]int, len(nums))
	for i := 0; i < len(mem); i++ {
		mem[i] = -1
	}
	return helper(nums, mem, len(nums)-1)
}

func helper(nums []int, mem []int, i int) int {
	if i < 0 {
		return 0
	}
	if mem[i] >= 0 {
		return mem[i]
	}
	res := max(helper(nums, mem, i-2)+nums[i], helper(nums, mem, i-1))
	mem[i] = res
	return res
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	nums := []int{1, 2, 3, 1}
	fmt.Println(rob(nums))
	nums = []int{2, 7, 9, 3, 1}
	fmt.Println(rob(nums))
}

输出：

4
12