add some new files

Author: tao

BFS/README.md

@@ -0,0 +1,30 @@
+### BFS专题学习
+
+#### 介绍
+
+BFS 叫广度优先搜索（bread first search), 是一种常见的搜索算法。广度优先搜索的例子和解释有很多， 这里不再详细赘述。
+
+这里想介绍一下bfs的相关模版，然后会有相关的题解练习。
+
+BFS要用到队列的特性来完成。队列的常见特性是先进先出，利用这个特性，我们可以很好的完成搜索。
+
+```java
+Queue<T> q = new LinkedList();
+q.add(start_position);
+while (!q.isEmpty()) {
+  T t = q.poll();
+  if (something is connected to t) {
+    q.add(something);
+  }
+}
+```
+
+这就是bfs的模版了。我们搜索的重点， 是入队条件的判定，我们到底要把什么样的东西入队呢？我们可以好好思考。
+
+
+
+#### 做题记录
+
+话不多说， 上code：
+
+- [leetcode 130]()

DP/README.md

@@ -0,0 +1,12 @@
+### 动态规划
+
+这章记录我的动态规划之路。
+
+相信大家学习动态规划的时候都感觉这个技巧好神奇，好有用。
+
+
+
+[leetcode 120 三角形路径和](DP/leetcode120.md)
+
+[leetcode 64最小路径和](DP/leetcode64.md)
+

DP/leetcode120.md

@@ -0,0 +1,105 @@
+### 描述
+
+给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。
+
+相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。
+
+ 
+
+例如，给定三角形：
+
+[
+     [**2**],
+    [**3**,4],
+   [6,**5**,7],
+  [4,**1**,8,3]
+]
+自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。
+
+
+[点击此处查看原题](https://leetcode-cn.com/problems/triangle)
+
+### 思路
+
+我的思维过程可能旁人看起来会比较奇怪。既然谈到动态规划，我们首先想到的是状态转移方程怎么列出来。OK， 我们来想这个题，
+
+我们来看一个小一点的例子：
+
+```java 
+  1
+ / \
+2   3
+```
+
+这里， 我们发现，我们最短的路径是 1 + 2， 因为在1 可以去到的通路上，2是最小的值。
+
+那么我们稍微归纳一下，假设我们有个函数可以完成这样的一件事情：
+
+```java
+public int minSum(int[][] arr, int i, int j)
+// i 表示第 i 行， j 表示第 j 个数字
+// 这个函数我们假设已经写出来，能够帮我们找到，在arr[i][j]位置上的最短路径和。
+// 比如， 上面小三角形的例子， minSum(arr, 0, 0) = 3
+```
+
+
+
+那么抽象点，我们的状态转移方程就是：
+
+```java
+minSum(arr, i, j) = Math.min(minSum(arr, i+1, j), minSum(arr, i+1, j+1))
+```
+
+我的解决递归的思路是，先写出一个暴力的递归解，然后我们可以来优化他。（那种一眼秒出答案的神仙不是我，是tth）
+
+```java
+public int minSum(int[][] arr, int i, int j) {
+ 		if (i == arr.length - 1) {
+      // 在数组的最下面一列，我们自然返回他自己。
+      return arr[i][j];
+    }
+  	int res = Math.min(minSum(arr, i+1, j), minSum(arr, i+1, j+1));
+  	return res;
+}
+```
+
+我们稍微把递归树给画出来，我们可以发现这样的一个规律：
+
+```java
+// 为了方便，我直接拿上图的数字作为函数的参数了。
+minSum(2) = Math.min(minSum(3), minSum(4))
+minSum(3) = Math.min(minSum(6), **minSum(5)**)
+minSum(4) = Math.min(**minSum(5)**, minSum(7))
+.
+.
+.
+```
+
+可以发现，如果单纯的递归，我们会发现在计算 minSum(3) 和 minSum(4)的时候， minSum(5)被重复计算了。
+
+我们可以开额外的空间，把这个东西记住，就减少了不必要的计算。
+
+上我的题解：
+
+```java
+
+public int minimumTotal(List<List<Integer>> triangle) {
+        int n = triangle.size();
+        int[][] f = new int[n][n];
+        f[0][0] = triangle.get(0).get(0);
+        for (int i = 1; i < n; ++i) {
+            f[i][0] = f[i - 1][0] + triangle.get(i).get(0);
+            for (int j = 1; j < i; ++j) {
+                f[i][j] = Math.min(f[i - 1][j - 1], f[i - 1][j]) + triangle.get(i).get(j);
+            }
+            f[i][i] = f[i - 1][i - 1] + triangle.get(i).get(i);
+        }
+        int minTotal = f[n - 1][0];
+        for (int i = 1; i < n; ++i) {
+            minTotal = Math.min(minTotal, f[n - 1][i]);
+        }
+        return minTotal;
+}
+```
+
+虽然不是双百，但是也能看吧。。。。。。

DP/leetcode64.md

@@ -0,0 +1,59 @@
+
+
+### 描述
+
+给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
+
+说明：每次只能向下或者向右移动一步。
+
+示例:
+
+输入:
+[
+  [1,3,1],
+  [1,5,1],
+  [4,2,1]
+]
+输出: 7
+解释: 因为路径 1→3→1→1→1 的总和最小。
+
+
+原题链接： https://leetcode-cn.com/problems/minimum-path-sum
+
+### 思路
+
+如果你看过前面 120 的题解，相信这题你可以秒杀。
+
+本质上，他还是开额外的空间，来避免重复的计算。
+
+这题跟120 题很类似，如果你没思路，可以按照我那个思路来写。
+
+### 题解
+
+```java
+public int minPathSum(int[][] grid) {
+
+        int m = grid.length;
+        int n = grid[0].length;
+
+        int[][] dp = new int[m][n];
+        int sum = 0;
+        for (int i = 0; i < n; i++) {
+            sum += grid[0][i];
+            dp[0][i] = sum;
+        }
+        sum = 0;
+        for (int i = 0; i < m; i++) {
+            sum += grid[i][0];
+            dp[i][0] = sum;
+        }
+        for (int i = 1; i < m; i++) {
+            for (int j = 1; j < n; j++) {
+                dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + grid[i][j];
+            }
+        }
+        return dp[m-1][n-1];
+
+    }
+```
+

_sidebar.md

@@ -5,3 +5,5 @@
 * [栈和队列](stack_queue/)
 * [递归学习](recursive/)
 * [C Style Guide](myself/c_style_guide.md)
+* [BFS](BFS/)
+* [DP](DP/)

binaryTree/README.md

@@ -368,3 +368,7 @@ public List<List<Integer>> levelOrder(TreeNode root) {
 
 思路我们有了，那我们来看代码怎么写：
 
+```java
+
+```
+