回溯法(backtracking) 题目整理--------part2

N-Queens

模拟退火不会写 0.0

The n-queens puzzle is the problem of placing n queens on an n×n chessboard such that no two queens attack each other.

Given an integer n, return all distinct solutions to the n-queens puzzle.

Each solution contains a distinct board configuration of the n-queens' placement, where 'Q' and '.' both indicate a queen and an empty space respectively.

For example,
There exist two distinct solutions to the 4-queens puzzle:

[
 [".Q..",  // Solution 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // Solution 2
  "Q...",
  "...Q",
  ".Q.."]
]

回溯法，刚开始思路，做一个2层的循环，后来发现其实每行之需要记录一个值，也就是queen的位置就行了。

先生成result strings(只包含queen位置的string)， 然后把strings写成n-queue形式。

对于是否valid，写一个isvalid function. 做2个判断，1 同列是否冲突， 2 对角线是否冲突

代码：

public class Solution {
    public List<List<String>> solveNQueens(int n) {
        List<List<String>> res = new ArrayList<List<String>>();
        if (n <= 0) {
            return res;
        }
        List<String> path = new ArrayList<String>();
        int[] row = new int[n];
        helper (res, row,  n, 0);
        return res;
    }
     private void helper(List<List<String>> resultList,
                              int[] row,
                              int n,
                              int index) {
        if (n == index) {
            ArrayList<String> singleResult = translateString(row);
            resultList.add(singleResult);
            return;
        }
       
        for (int i = 0; i < n; i++) {
                if (isValid(row, index, i)) {
                row[index] = i;
                helper (resultList, row, n, index + 1);
                row[index] = 0;
            }
        }
        
    }
    
    private ArrayList<String> translateString(int[] row) {
        ArrayList<String> resultList = new ArrayList<>();
        for (int i = 0; i < row.length; i++) {
            StringBuilder sb = new StringBuilder();
            for (int j = 0; j < row.length; j++) {
                if (j == row[i]) {
                    sb.append('Q');
                }
                else {
                    sb.append('.');
                }
            }
            resultList.add(sb.toString());
        }
        return resultList;
    }
    
    private boolean isValid(int[] row, int rowNum, int columnNum) {
        for (int i = 0; i < rowNum; i++) {
            if (row[i] == columnNum) {
                return false;
            }
            //对角线检查
            if (Math.abs(row[i] - columnNum) == Math.abs(i - rowNum)) {
                return false;
            }
        }
        return true;
    }
}

--------------------------我是分割线-------------------

N-Queens II

Follow up for N-Queens problem.

Now, instead outputting board configurations, return the total number of distinct solutions.

 注意建立的res 是静态变量，在主方法里面赋值，防止它是dirty的

public class Solution {
    static int res;
    public int totalNQueens(int n) {
        if (n <= 0) {
            return 0;
        }
        int[] rows = new int[n];
        int index = 0;
        res = 0;
        helper(0, rows);
        return res;
        
    }
    
    private static void helper(int index,  int[] rows) {
        int n = rows.length;
        if (index == n) {
            res++;
            return;
        }
        for (int i = 0; i < n; i++) {
            if (isValid(rows, index, i)) {
                rows[index] = i;
                helper(index + 1,  rows);
            }
        }
    }
    
    private static boolean isValid(int rows[], int rowNum, int columnNum) {
        for (int i = 0; i < rowNum; i++) {
                if (rows[i] == columnNum) {
                    return false;
                }
                if (Math.abs(rows[i] - columnNum) == Math.abs(i - rowNum)) {
                    //columnNum1 - columnNum2 = rowNum1 - rowNum2 平行！
                    return false;
                }
            }
        return true;
    }
}

--------------------------我是分割线-------------------

Restore IP Addresses

 

Given a string containing only digits, restore it by returning all possible valid IP address combinations.

Have you met this question in a real interview? 

Yes

Example

Given "25525511135", return

[
  "255.255.11.135",
  "255.255.111.35"
]

Order does not matter.

写代码时候的坑：

1. 在计算path的时候，应该用list来记录路径，确定找到结果后再转化为相应的形式。用了stringbuilder 果然是sb，使得递归主体函数变复杂了。
2. 在每一个ip数字段的后面添加上一个. 再把最后的一个点删掉就行了。

3. for(int i = start; i < s.length() && i < start+3; i++)  这样控制for循环就好了 i < start+3， 不需要使用2重for循环。 蠢哭了

4. if(isvalid(tmp)) 验证是否合法比较麻烦的情况下，新建个函数放在外面

5. if(s.charAt(0) == '0')
   return s.equals("0"); // to eliminate cases like "00", "01"

代码：

public class Solution {
    /**
     * @param s the IP string
     * @return All possible valid IP addresses
     */
 
    
    public ArrayList<String> restoreIpAddresses(String s) {
        ArrayList<String> result = new ArrayList<String>();
        //use list to store path data is way better that use stringBuilder
        // not a good way StringBuilder sb = new StringBuilder();
        ArrayList<String> list = new ArrayList<String>();
        
        if(s.length() < 4 || s.length() > 12)
            return result;
        
        helper(result, list, s , 0);
        return result;
    }
    
    
    
    public void helper(ArrayList<String> result, ArrayList<String> list, String s, int start){
        if(list.size() == 4){
            if(start != s.length())
                return;
            
            StringBuffer sb = new StringBuffer();
            for(String tmp: list){
                sb.append(tmp);
                sb.append(".");
            }
            sb.deleteCharAt(sb.length()-1);
            result.add(sb.toString());
            return;
        }
        
        for(int i = start; i < s.length() && i < start+3; i++){
            String tmp = s.substring(start, i+1);
            if(isvalid(tmp)){
                list.add(tmp);
                helper(result, list, s, i+1);
                list.remove(list.size()-1);
            }
        }
    }
     private boolean isvalid(String s){
        if(s.charAt(0) == '0')
            return s.equals("0"); // to eliminate cases like "00", "01"
        int digit = Integer.valueOf(s);
        return digit >= 0 && digit <= 255;
    }
   
}

--------------------------我是分割线-------------------

Wildcard Matching

Implement wildcard pattern matching with support for'?' and '*'.

• '?' Matches any single character.
• '*' Matches any sequence of characters (including the empty sequence).

The matching should cover the entire input string (not partial).

Example

isMatch("aa","a") → false
isMatch("aa","aa") → true
isMatch("aaa","aa") → false
isMatch("aa", "*") → true
isMatch("aa", "a*") → true
isMatch("ab", "?*") → true
isMatch("aab", "c*a*b") → false

没做优化，超时了

public class Solution {
    /**
     * @param s: A string 
     * @param p: A string includes "?" and "*"
     * @return: A boolean
     */
    private static boolean res;
    public boolean isMatch(String s, String p) {
        // write your code here
        res = false;
        
        helper( s, p, 0, 0);
        return res;
     }
    private static void helper(String s, String p, int sIndex , int pIndex) {
        if (sIndex == s.length() && pIndex == p.length()) {
            res = true;
            return;
        }
        if (res || (sIndex >= s.length() && p.charAt(pIndex) !='*') || pIndex >= p.length() ) {
            return;
        }
        
        //test current char at p
        if (p.charAt(pIndex) == '?') {
            helper(s, p, sIndex + 1, pIndex + 1);
        } else if (p.charAt(pIndex) == '*') {
            int temp = 0;
            while (sIndex + temp <= s.length()) {
                helper(s, p, sIndex + temp, pIndex + 1);
                temp++;
            }
        } else if (p.charAt(pIndex) == s.charAt(sIndex)) {
            helper(s, p, sIndex + 1, pIndex + 1);
        } else {
            return;
        }
        
    }
}

优化：

// without this optimization, it will fail for large data set
int plenNoStar = 0;
for (char c : p.toCharArray())
if (c != '*') plenNoStar++;
if (plenNoStar > s.length()) return false;

尼玛 加了优化还是挂了

答案= = 动态规划

public class Solution {

public boolean isMatch(String s, String p) {
    // without this optimization, it will fail for large data set
    int plenNoStar = 0;
    for (char c : p.toCharArray())
        if (c != '*') plenNoStar++;
    if (plenNoStar > s.length()) return false;

    s = " " + s;
    p = " " + p;
    int slen = s.length();
    int plen = p.length();

    boolean[] dp = new boolean[slen];
    TreeSet<Integer> firstTrueSet = new TreeSet<Integer>();
    firstTrueSet.add(0);
    dp[0] = true;

    boolean allStar = true;
    for (int pi = 1; pi < plen; pi++) {
        if (p.charAt(pi) != '*')
            allStar = false;
        for (int si = slen - 1; si >= 0; si--) {
            if (si == 0) {
                dp[si] = allStar ? true : false;
            } else if (p.charAt(pi) != '*') {
                if (s.charAt(si) == p.charAt(pi) || p.charAt(pi) == '?') dp[si] = dp[si-1];
                else dp[si] = false;
            } else {
                int firstTruePos = firstTrueSet.isEmpty() ? Integer.MAX_VALUE : firstTrueSet.first();
                if (si >= firstTruePos) dp[si] = true;
                else dp[si] = false;
            }
            if (dp[si]) firstTrueSet.add(si);
            else firstTrueSet.remove(si);
        }
    }
    return dp[slen - 1];
}
}

-------分割线---- 

Word Search

public class Solution {
    private int[] offset;
    private boolean[][] flag;
    private int m, n;
    
    public boolean exist(char[][] board, String word) {
        m = board.length;
        n = board[0].length;
        flag = new boolean[m][n];
        offset = new int[]{0, 1, 0, -1, 0};
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                flag[i][j] = true;
                if (word.charAt(0) == board[i][j]) {
                   // System.out.println("searching pos i == " + i + " j== " + j);
                    if (search(board, word, 1, i, j)){
                        return true;
                    }
                }
                flag[i][j] = false;
            }
        }
        return false;
    }
    private boolean search (char[][] board, String word, int pos, int i, int j) {
        if (pos == word.length()) {
            return true;
        }
        
        for (int k = 0; k < 4; k++) {
            //判断是否越界
            int new_i = i + offset[k], new_j = j + offset[k + 1];
            if (new_i < 0 || new_j < 0 || new_i >= m || new_j >= n) {
                continue;
            }
            //没越界，并且没有往来的方向返回的话，进行下一层的搜索
            if (word.charAt(pos) == board[new_i][new_j] && flag[new_i][new_j] == false) {
                flag[new_i][new_j] = true;
                 if (search(board, word, pos + 1, new_i, new_j)) {
                     return true;
                 }
                flag[new_i][new_j] = false;

            }
        }
        return false;
    }
}