algorithm004-01 · AceXu · Dec 22, 2019
diff --git a/Week 05/id_666/LeetCode_62_666.java b/Week 05/id_666/LeetCode_62_666.java
@@ -0,0 +1,13 @@
+class Solution {
+    public int uniquePaths(int m, int n) {
+        //典型动态规化
+        int[] cur = new int[n];
+        Arrays.fill(cur,1);
+        for (int i = 1; i < m;i++){
+            for (int j = 1; j < n; j++){
+                cur[j] += cur[j-1] ;
+            }
+        }
+        return cur[n-1];
+    }
+}
diff --git a/Week 05/id_666/LeetCode_70_666.java b/Week 05/id_666/LeetCode_70_666.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int climbStairs(int n) {
+        //递归思路，f(n) = f(n-1) + f(n-2);
+        //动态规划解法
+        if (n == 1) {
+            return 1;
+        }
+        int[] dp = new int[n + 1];
+        dp[1] = 1;
+        dp[2] = 2;
+        for (int i = 3; i <= n; i++) {
+            dp[i] = dp[i - 1] + dp[i - 2];
+        }
+        return dp[n];
+    }
+}
diff --git a/Week 06/id_666/LeetCode_200_666.java b/Week 06/id_666/LeetCode_200_666.java
@@ -0,0 +1,35 @@
+class Solution {
+    //没整明白
+    public int numIslands(char[][] grid) {
+        if (grid == null || grid.length == 0) {
+            return 0;
+        }
+        int nr = grid.length;
+        int nc = grid[0].length;
+        int num_islands = 0;
+        for (int r = 0; r < nr; ++r) {
+            for (int c = 0; c < nc; ++c) {
+                if (grid[r][c] == '1') {
+                    ++num_islands;
+                    dfs(grid, r, c);
+                }
+            }
+        }
+        return num_islands;
+    }
+
+    private void dfs(char[][] grid, int r, int c) {
+        int nr = grid.length;
+        int nc = grid[0].length;
+
+        if (r < 0 || c < 0 || r >= nr || c >= nc || grid[r][c] == '0') {
+            return;
+        }
+
+        grid[r][c] = '0';
+        dfs(grid, r - 1, c);
+        dfs(grid, r + 1, c);
+        dfs(grid, r, c - 1);
+        dfs(grid, r, c + 1);
+    }
+}
diff --git a/Week 06/id_666/LeetCode_51_666.java b/Week 06/id_666/LeetCode_51_666.java
@@ -0,0 +1,66 @@
+class Solution {
+    //背诵题
+    int rows[];
+    int hills[];
+    int dales[];
+    int n;
+    List<List<String>> output = new ArrayList();
+    int queens[];
+
+    public boolean isNotUnderAttack(int row, int col) {
+        int res = rows[col] + hills[row - col + 2 * n] + dales[row + col];
+        return (res == 0) ? true : false;
+    }
+
+    public void placeQueen(int row, int col) {
+        queens[row] = col;
+        rows[col] = 1;
+        hills[row - col + 2 * n] = 1;  // "hill" diagonals
+        dales[row + col] = 1;   //"dale" diagonals
+    }
+
+    public void removeQueen(int row, int col) {
+        queens[row] = 0;
+        rows[col] = 0;
+        hills[row - col + 2 * n] = 0;
+        dales[row + col] = 0;
+    }
+
+    public void addSolution() {
+        List<String> solution = new ArrayList<String>();
+        for (int i = 0; i < n; ++i) {
+            int col = queens[i];
+            StringBuilder sb = new StringBuilder();
+            for(int j = 0; j < col; ++j) sb.append(".");
+            sb.append("Q");
+            for(int j = 0; j < n - col - 1; ++j) sb.append(".");
+            solution.add(sb.toString());
+        }
+        output.add(solution);
+    }
+
+    public void backtrack(int row) {
+        for (int col = 0; col < n; col++) {
+            if (isNotUnderAttack(row, col)) {
+                placeQueen(row, col);
+                // if n queens are already placed
+                if (row + 1 == n) addSolution();
+                    // if not proceed to place the rest
+                else backtrack(row + 1);
+                // backtrack
+                removeQueen(row, col);
+            }
+        }
+    }
+
+    public List<List<String>> solveNQueens(int n) {
+        this.n = n;
+        rows = new int[n];
+        hills = new int[4 * n - 1];
+        dales = new int[2 * n - 1];
+        queens = new int[n];
+
+        backtrack(0);
+        return output;
+    }
+}