🎉 add: 打家劫舍

Author: ConardLi

README.md

@@ -190,6 +190,7 @@
 - [动态规划-概览](/算法分类/动态规划/动态规划.md)
 - [斐波拉契数列](/算法分类/递归和循环/斐波拉契数列.md)⭐⭐
 - [最小路径和](/算法分类/动态规划/最小路径和.md)⭐⭐⭐
+- [打家劫舍](/算法分类/动态规划/打家劫舍.md)⭐⭐⭐
 
 
 ## 贪心算法

docs/.vuepress/config.js

@@ -109,6 +109,7 @@ module.exports = {
                     children: [
                         '/algorithm/动态规划/动态规划',
                         '/algorithm/动态规划/最小路径和',
+                        '/algorithm/动态规划/打家劫舍',
                     ]
                 },
                 {

docs/algorithm/README.md

@@ -66,6 +66,7 @@
 - [动态规划-概览](./动态规划/动态规划.md)
 - [斐波拉契数列](./递归和循环/斐波拉契数列.md)⭐⭐
 - [最小路径和](./动态规划/最小路径和.md)⭐⭐⭐
+- [打家劫舍](./动态规划/打家劫舍.md)⭐⭐⭐
 
 
 ## 贪心算法

docs/algorithm/动态规划/打家劫舍.md

@@ -0,0 +1,67 @@
+---
+{
+  "title": "打家劫舍",
+}
+---
+
+## 题目
+
+你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
+
+给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。
+
+```js
+示例 1:
+
+输入: [1,2,3,1]
+输出: 4
+解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
+     偷窃到的最高金额 = 1 + 3 = 4 。
+
+```
+
+```js
+示例 2:
+
+输入: [2,7,9,3,1]
+输出: 12
+解释: 偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
+     偷窃到的最高金额 = 2 + 9 + 1 = 12 。
+```
+
+## 思路
+
+考虑所有可能的抢劫方案过于困难。一个自然而然的想法是首先从最简单的情况开始。记：
+
+`f(k)` = 从前 k 个房屋中能抢劫到的最大数额，`Ai` = 第 i 个房屋的钱数。
+
+首先看` n = 1` 的情况，显然 `f(1) = A1`。
+
+再看 `n = 2`，`f(2) = max(A1, A2)`。
+
+对于 `n = 3`，有两个选项:
+
+抢第三个房子，将数额与第一个房子相加。
+
+不抢第三个房子，保持现有最大数额。
+
+显然，你想选择数额更大的选项。于是，可以总结出公式：
+
+`f(k) = max(f(k – 2) + Ak, f(k – 1))`
+
+## 代码
+
+
+```js
+    var rob = function (nums) {
+      var len = nums.length;
+      if (len < 2) {
+        return nums[len - 1] ? nums[len - 1] : 0;
+      }
+      var current = [nums[0], Math.max(nums[0], nums[1])];
+      for (var k = 2; k < len; k++) {
+        current[k] = Math.max(current[k - 2] + nums[k], current[k - 1]);
+      }
+      return current[len - 1];
+    };
+```

leetcode/198.打家劫舍.md

@@ -0,0 +1,61 @@
+## 题目
+
+你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
+
+给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。
+
+```js
+示例 1:
+
+输入: [1,2,3,1]
+输出: 4
+解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
+     偷窃到的最高金额 = 1 + 3 = 4 。
+
+```
+
+```js
+示例 2:
+
+输入: [2,7,9,3,1]
+输出: 12
+解释: 偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
+     偷窃到的最高金额 = 2 + 9 + 1 = 12 。
+```
+
+## 思路
+
+考虑所有可能的抢劫方案过于困难。一个自然而然的想法是首先从最简单的情况开始。记：
+
+`f(k)` = 从前 k 个房屋中能抢劫到的最大数额，`Ai` = 第 i 个房屋的钱数。
+
+首先看` n = 1` 的情况，显然 `f(1) = A1`。
+
+再看 `n = 2`，`f(2) = max(A1, A2)`。
+
+对于 `n = 3`，有两个选项:
+
+抢第三个房子，将数额与第一个房子相加。
+
+不抢第三个房子，保持现有最大数额。
+
+显然，你想选择数额更大的选项。于是，可以总结出公式：
+
+`f(k) = max(f(k – 2) + Ak, f(k – 1))`
+
+## 代码
+
+
+```js
+    var rob = function (nums) {
+      var len = nums.length;
+      if (len < 2) {
+        return nums[len - 1] ? nums[len - 1] : 0;
+      }
+      var current = [nums[0], Math.max(nums[0], nums[1])];
+      for (var k = 2; k < len; k++) {
+        current[k] = Math.max(current[k - 2] + nums[k], current[k - 1]);
+      }
+      return current[len - 1];
+    };
+```

算法分类/动态规划/打家劫舍.md

@@ -0,0 +1,61 @@
+## 题目
+
+你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
+
+给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。
+
+```js
+示例 1:
+
+输入: [1,2,3,1]
+输出: 4
+解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
+     偷窃到的最高金额 = 1 + 3 = 4 。
+
+```
+
+```js
+示例 2:
+
+输入: [2,7,9,3,1]
+输出: 12
+解释: 偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
+     偷窃到的最高金额 = 2 + 9 + 1 = 12 。
+```
+
+## 思路
+
+考虑所有可能的抢劫方案过于困难。一个自然而然的想法是首先从最简单的情况开始。记：
+
+`f(k)` = 从前 k 个房屋中能抢劫到的最大数额，`Ai` = 第 i 个房屋的钱数。
+
+首先看` n = 1` 的情况，显然 `f(1) = A1`。
+
+再看 `n = 2`，`f(2) = max(A1, A2)`。
+
+对于 `n = 3`，有两个选项:
+
+抢第三个房子，将数额与第一个房子相加。
+
+不抢第三个房子，保持现有最大数额。
+
+显然，你想选择数额更大的选项。于是，可以总结出公式：
+
+`f(k) = max(f(k – 2) + Ak, f(k – 1))`
+
+## 代码
+
+
+```js
+    var rob = function (nums) {
+      var len = nums.length;
+      if (len < 2) {
+        return nums[len - 1] ? nums[len - 1] : 0;
+      }
+      var current = [nums[0], Math.max(nums[0], nums[1])];
+      for (var k = 2; k < len; k++) {
+        current[k] = Math.max(current[k - 2] + nums[k], current[k - 1]);
+      }
+      return current[len - 1];
+    };
+```