diff --git a/LeetCode/LeetCode_51_N_Queens.java b/LeetCode/LeetCode_51_N_Queens.java
new file mode 100644
index 00000000..bd8c6117
--- /dev/null
+++ b/LeetCode/LeetCode_51_N_Queens.java
@@ -0,0 +1,105 @@
+package com.algorithm;
+
+import org.junit.Test;
+
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/06/15
+ */
+public class LeetCode_51_108 {
+
+    //8皇后
+    @Test
+    public void test() {
+        int num = 8;
+        int[][] queens = new int[num][num];
+        List<List<String>> result = new LinkedList<>();
+        queens(queens, 0, num,result);
+        System.out.println(result);
+    }
+
+    private List<String> postQueens(int[][] queens){
+        List<String> values = new LinkedList<>();
+        for (int i = 0; i < queens.length; i++) {
+            String row = "";
+            for (int j = 0; j < queens[0].length; j++) {
+                row = row.concat(parse(queens[i][j]));
+            }
+            values.add(row);
+        }
+        return values;
+    }
+
+    private String parse(int value){
+        return value == 0 ? "." : "Q";
+    }
+
+    private void queens(int[][] queens, int i, int num,List<List<String>> result) {
+        if (i == num) {
+            List<String> value = postQueens(queens);
+            printQueens(value);
+            result.add(postQueens(queens));
+            return;
+        }
+
+        for (int j = 0; j < queens[0].length; j++) {
+            if (check(queens, i, j)) {
+                queens[i][j] = j + 1;
+                queens(queens, i + 1, num,result);
+            }
+            queens[i][j] = 0;
+        }
+    }
+
+    private void printQueens(List<String> queens) {
+        for (int i = 0; i < queens.size(); i++) {
+            System.out.println(queens.get(i));
+        }
+        System.out.println();
+        System.out.println();
+        System.out.println();
+        System.out.println();
+    }
+
+    private boolean check(int[][] queens, int i, int j) {
+        int length = queens[0].length;
+        int width = queens.length;
+
+        int i_copy = i - 1;
+        int j_copy = j - 1;
+        //检查左上
+        while (i_copy >= 0 && j_copy >= 0) {
+            if (queens[i_copy][j_copy] != 0) {
+                return false;
+            }
+            i_copy--;
+            j_copy--;
+        }
+        //检查右上
+        i_copy = i - 1;
+        j_copy = j + 1;
+        while (i_copy >= 0 && j_copy <= length - 1) {
+            if (queens[i_copy][j_copy] != 0) {
+                return false;
+            }
+            i_copy--;
+            j_copy++;
+        }
+        //检查上
+        i_copy = i - 1;
+        j_copy = j;
+        while (i_copy >= 0) {
+            if (queens[i_copy][j_copy] != 0) {
+                return false;
+            }
+            i_copy--;
+        }
+
+        return true;
+    }
+
+}
diff --git a/Week_01/id_108/LeetCode_174_108.java b/Week_01/id_108/LeetCode_174_108.java
new file mode 100644
index 00000000..26f93407
--- /dev/null
+++ b/Week_01/id_108/LeetCode_174_108.java
@@ -0,0 +1,35 @@
+import org.junit.Test;
+
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/05/29
+ */
+public class LeetCode_174_108 {
+
+    /**
+     * 利用动态规划，构造到达某个节点时的最小生命值,最小存活值是1
+     * 1、如果是最后一个，到达最后一个点时的存活值就是（1-健康点数，1）的最大值，必须大于等于1，要不就立即死亡
+     * 2、如果是最下面一行的点，那么到达它的最小存活着就是=（右边一个点的最小存活值-自己的健康点数，1）的最大值，表示进入我这个点时得具有多少个健康值才能顺利进入下一个点
+     * 3、如果是最右边一列，跟上面同理，只不过比较的是下面的点，因为只能往右或往下走
+     * 4、如果是中间的某个点，那么肯定找个门槛最低的点走，所以比较下面和右边的点，找到最小值，再跟1比较
+     */
+    public int calculateMinimumHP(int[][] dungeon) {
+        int row = dungeon.length - 1;
+        int column = dungeon[0].length - 1;
+        for (int i = row; i >= 0; i--) {
+            for (int j = column; j >= 0; j--) {
+                if (i == row && j == column) {
+                    dungeon[i][j] = Math.max(1 - dungeon[i][j], 1);
+                } else if (i == row) {
+                    dungeon[i][j] = Math.max(dungeon[i][j + 1] - dungeon[i][j], 1);
+                } else if (j == column) {
+                    dungeon[i][j] = Math.max(dungeon[i + 1][j] - dungeon[i][j], 1);
+                } else {
+                    dungeon[i][j] = Math.max(Math.min(dungeon[i + 1][j], dungeon[i][j + 1]) - dungeon[i][j], 1);
+                }
+            }
+        }
+        return dungeon[0][0];
+    }
+}
diff --git a/Week_01/id_108/LeetCode_242_108.java b/Week_01/id_108/LeetCode_242_108.java
new file mode 100644
index 00000000..af91eb68
--- /dev/null
+++ b/Week_01/id_108/LeetCode_242_108.java
@@ -0,0 +1,29 @@
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/05/26
+ */
+public class LeetCode_242_108 {
+    class Solution {
+        public boolean isAnagram(String s, String t) {
+            if(s == null || t == null || s.length() != t.length()){
+                return false;
+            }
+            if(s.equals("") && t.equals("")){
+                return true;
+            }
+            int[] arr = new int[26];
+            for(int i = 0; i<s.length() ; i++){
+                arr[s.charAt(i) - 'a'] ++;
+                arr[t.charAt(i) - 'a'] --;
+            }
+            for(int i = 0;i<arr.length; i++){
+                if(arr[i] != 0){
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    }
+}
diff --git a/Week_01/id_108/LeetCode_441_108.java b/Week_01/id_108/LeetCode_441_108.java
new file mode 100644
index 00000000..cf68cc9f
--- /dev/null
+++ b/Week_01/id_108/LeetCode_441_108.java
@@ -0,0 +1,58 @@
+import org.junit.Test;
+
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/05/26
+ */
+public class LeetCode_441_108 {
+
+
+    public int arrangeCoins1(int n) {
+        if (n == 0) {
+            return 0;
+        }
+        int m = n;
+        int k = 0;
+        for (; m > 0; ) {
+            if (m >= k + 1) {
+                k++;
+                m = m - k;
+            } else {
+                return k;
+            }
+        }
+        return k;
+    }
+
+    public int arrangeCoins2(int n) {
+        if (n == 0) {
+            return 0;
+        }
+        return (int)(Math.sqrt(2.0*n+0.25)-0.5);
+    }
+
+    public int arrangeCoins3(int n) {
+        if (n == 0) {
+            return 0;
+        }
+
+        int low = 1;
+        int high = n;
+        int mid;
+        double tmp;
+        while (low <= high){
+            mid = (high + low)/2;
+            tmp = (mid * mid + mid) / 2.0;
+            if(tmp == n){
+                return mid;
+            }else if (tmp < (double) n){
+                low = mid + 1 ;
+            } else {
+                high = mid - 1;
+            }
+        }
+
+        return high;
+    }
+}
diff --git a/Week_01/id_108/LeetCode_50_108.java b/Week_01/id_108/LeetCode_50_108.java
new file mode 100644
index 00000000..7b519e17
--- /dev/null
+++ b/Week_01/id_108/LeetCode_50_108.java
@@ -0,0 +1,36 @@
+import org.junit.Test;
+
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/05/28
+ */
+public class LeetCode_50_108 {
+
+
+    public double myPow(double x, int n) {
+
+        if (n == 0) {
+            return 1;
+        }
+
+        if (n == 1) {
+            return x;
+        }
+        //对于myPow(2, -2147483648)，如果直接取绝对值就会溢出，导致Math.abs(n)还是负数,所以先除2再取绝对值
+        double result = myPow(x, n == Integer.MIN_VALUE ? -(n/2) : Math.abs(n) / 2);
+
+        if (n % 2 == 0) {
+            result = result * result;
+        } else {
+            result = result * x * result;
+        }
+
+        if (n >= 0) {
+            return result;
+        } else {
+            return 1.0 / result;
+        }
+
+    }
+}