java的递归与回溯法
public class Solutions {
private String letterMap[] = {
" ", //0
"", //1
"abc", //2
"def", //3
"ghi", //4
"jkl", //5
"mno", //6
"pqrs", //7
"tuv", //8
"wxyz" //9
};
private ArrayList<String> res;
public List<String> letterCombinations(String digits) {
res = new ArrayList<String>();
if(digits.equals(""))
return res;
findCombination(digits, 0, "");
return res;
}
// s中保存了此时从digits[0...index-1]翻译得到的一个字母字符串
// 寻找和digits[index]匹配的字母, 获得digits[0...index]翻译得到的解
private void findCombination(String digits, int index, String s){
System.out.println(index + " : " + s);
if(index == digits.length()){
res.add(s);
System.out.println("get " + s + " , return");
return;
}
//选定给定数字组合中的第一个数字，从这个数字出发一共有三种字母对应
Character c = digits.charAt(index);
assert c.compareTo('0') >= 0 &&
c.compareTo('9') <= 0 &&
c.compareTo('1') != 0;
//对于选定数字组合的第二个数字，接着上一个字母继续有三种字母的组合一共九种以此类推
String letters = letterMap[c - '0'];
for(int i = 0 ; i < letters.length() ; i ++){
System.out.println("digits[" + index + "] = " + c +
" , use " + letters.charAt(i));
findCombination(digits, index+1, s + letters.charAt(i));
}
System.out.println("digits[" + index + "] = " + c + " complete, return");
return;
}
private static void printList(List<String> list){
for(String s: list)
System.out.println(s);
}
public static void main(String[] args) {
printList((new Solution()).letterCombinations("234"));
}
}
public class Solutions {
private ArrayList<List<Integer>> res;
private boolean[] used;
public List<List<Integer>> permute(int[] nums) {
res = new ArrayList<List<Integer>>();
if(nums == null || nums.length == 0)
return res;
used = new boolean[nums.length];
LinkedList<Integer> p = new LinkedList<Integer>();
generatePermutation(nums, 0, p);
return res;
}
// p中保存了一个有index-1个元素的排列。
// 向这个排列的末尾添加第index个元素, 获得一个有index个元素的排列
private void generatePermutation(int[] nums, int index, LinkedList<Integer> p){
//递归的终止条件，只有一个元素的使用不用进行排列了就是本身，获得路径上的值为一个排列情况
if(index == nums.length){
res.add((LinkedList<Integer>)p.clone());
return;
}
//从整体中取出一个元素进行排列，从剩下的在剩余的元素中取出一个元素继续排列，是同一个问题可以使用递归
for(int i = 0 ; i < nums.length ; i ++)
if(!used[i]){
used[i] = true;
p.addLast(nums[i]);
generatePermutation(nums, index + 1, p );
p.removeLast();
used[i] = false;
}
return;
}
private static void printList(List<Integer> list){
for(Integer e: list)
System.out.print(e + " ");
System.out.println();
}
public static void main(String[] args) {
int[] nums = {1, 2, 3};
List<List<Integer>> res = (new Solution()).permute(nums);
for(List<Integer> list: res)
printList(list);
}
}
public class Solutions {
private ArrayList<List<Integer>> res;
public List<List<Integer>> combine(int n, int k) {
res = new ArrayList<List<Integer>>();
if(n <= 0 || k <= 0 || k > n)
return res;
LinkedList<Integer> c = new LinkedList<Integer>();
generateCombinations(n, k, 1, c);
return res;
}
// 求解C(n,k), 当前已经找到的组合存储在c中, 需要从start开始搜索新的元素
private void generateCombinations(int n, int k, int start, LinkedList<Integer> c){
if(c.size() == k){
res.add((List<Integer>)c.clone());
return;
}
//组合问题[1，2]和[2,1]都是一样的
//取第一个数的时候一共有4种可能，剩下的问题就是在剩余数中取出一个数，形成了递归的形式
for(int i = start ; i <= n ; i ++){
c.addLast(i);
generateCombinations(n, k, i + 1, c);
//取第二个数的时候，不取第一个数，依次类推后面的数不取前面的数
c.removeLast();
}
// 还有k - c.size()个空位, 所以, [i...n] 中至少要有 k - c.size() 个元素
// i最多为 n - (k - c.size()) + 1
//如果取完最后一个数，没有多余的数可以进行匹配了，所以最后一个数不用递归进行剪枝操作
//for(int i = start ; i <= n - (k - c.size()) + 1 ; i ++){
// c.addLast(i);
// generateCombinations(n, k, i + 1, c);
// c.removeLast();
}
return;
}
private static void printList(List<Integer> list){
for(Integer e: list)
System.out.print(e + " ");
System.out.println();
}
public static void main(String[] args) {
List<List<Integer>> res = (new Solution()).combine(4, 2);
for(List<Integer> list: res)
printList(list);
}
}二维平面的回溯法
public class Solutions {
private int d[][] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
private int m, n;
private boolean[][] visited;
public boolean exist(char[][] board, String word) {
if(board == null || word == null)
throw new IllegalArgumentException("board or word can not be null!");
m = board.length;
if(m == 0)
throw new IllegalArgumentException("board can not be empty.");
n = board[0].length;
if(n == 0)
throw new IllegalArgumentException("board can not be empty.");
visited = new boolean[m][n];
for(int i = 0 ; i < m ; i ++)
for(int j = 0 ; j < n ; j ++)
//二维平面找到单词，从二维平面的第一个位置开始判断是否为单词的首字母
if(searchWord(board, word, 0, i, j))
return true;
return false;
}
private boolean inArea( int x , int y ){
return x >= 0 && x < m && y >= 0 && y < n;
}
// 从board[startx][starty]开始, 寻找word[index...word.size())
private boolean searchWord(char[][] board, String word, int index,
int startx, int starty){
//assert(inArea(startx,starty));
if(index == word.length() - 1)
return board[startx][starty] == word.charAt(index);
if(board[startx][starty] == word.charAt(index)){
visited[startx][starty] = true;
// 从startx, starty出发,向四个方向寻
//继续寻找可以从上下左右四个方向前进，按照顺时针的顺序寻找，如果第二个元素匹配上，则从第二个元素开始继续四个方向的寻找
for(int i = 0 ; i < 4 ; i ++){
int newx = startx + d[i][0];
int newy = starty + d[i][1];
if(inArea(newx, newy) && !visited[newx][newy] &&
searchWord(board, word, index + 1, newx, newy))
return true;
}
//如果没有找到元素，回溯法退回到前一个字母继续寻找
visited[startx][starty] = false;
}
return false;
}
public static void main(String args[]){
char[][] b1 = { {'A','B','C','E'},
{'S','F','C','S'},
{'A','D','E','E'}};
String words[] = {"ABCCED", "SEE", "ABCB" };
for(int i = 0 ; i < words.length ; i ++)
if((new Solution()).exist(b1, words[i]))
System.out.println("found " + words[i]);
else
System.out.println("can not found " + words[i]);
// ---
char[][] b2 = {{'A'}};
if((new Solution()).exist(b2,"AB"))
System.out.println("found AB");
else
System.out.println("can not found AB");
}
}
public class Solutions {
private int d[][] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
private int m, n;
private boolean visited[][];
public int numIslands(char[][] grid) {
if(grid == null || grid.length == 0 || grid[0].length == 0)
return 0;
m = grid.length;
n = grid[0].length;
visited = new boolean[m][n];
int res = 0;
for(int i = 0 ; i < m ; i ++)
for(int j = 0 ; j < n ; j ++)
if(grid[i][j] == '1' && !visited[i][j]){
//遍历图中其他的地方，看是否有没有标记过的陆地，进行相同的操作
dfs(grid, i, j);
res ++;
}
return res;
}
// 从grid[x][y]的位置开始,进行floodfill
// 保证(x,y)合法,且grid[x][y]是没有被访问过的陆地
private void dfs(char[][] grid, int x, int y){
//首先从最开始的地方找起来，与起始岛屿连接在一起的岛屿如果没有访问过并且是岛屿进行标识为同属于一个岛屿，进行深度优先遍历
//assert(inArea(x,y));
visited[x][y] = true;
for(int i = 0; i < 4; i ++){
int newx = x + d[i][0];
int newy = y + d[i][1];
if(inArea(newx, newy) && !visited[newx][newy] && grid[newx][newy] == '1')
dfs(grid, newx, newy);
}
return;
}
private boolean inArea(int x, int y){
return x >= 0 && x < m && y >= 0 && y < n;
}
public static void main(String[] args) {
char grid1[][] = {
{'1','1','1','1','0'},
{'1','1','0','1','0'},
{'1','1','0','0','0'},
{'0','0','0','0','0'}
};
System.out.println((new Solution()).numIslands(grid1));
// 1
// ---
char grid2[][] = {
{'1','1','0','0','0'},
{'1','1','0','0','0'},
{'0','0','1','0','0'},
{'0','0','0','1','1'}
};
System.out.println((new Solution()).numIslands(grid2));
// 3
}
}
扫描二维码关注公众号，回复：
6726217 查看本文章
public class Solutions {
private boolean[] col;
private boolean[] dia1;
private boolean[] dia2;
private ArrayList<List<String>> res;
public List<List<String>> solveNQueens(int n) {
//快速的判断不合法的情况，通过数组堆第几列与对角线是否被占用过进行剪枝操作
res = new ArrayList<List<String>>();
col = new boolean[n];
dia1 = new boolean[2 * n - 1];
dia2 = new boolean[2 * n - 1];
LinkedList<Integer> row = new LinkedList<Integer>();
putQueen(n, 0, row);
return res;
}
// 尝试在一个n皇后问题中, 摆放第index行的皇后位置
private void putQueen(int n, int index, LinkedList<Integer> row){
if(index == n){
res.add(generateBoard(n, row));
return;
}
for(int i = 0 ; i < n ; i ++)
// 尝试将第index行的皇后摆放在第i列
//逐行搜索在每一行皇后出现在哪，如果第一行放在第一个位置，第二行只能放在第三个位置，第三行放在哪里都不符合要求，所以回溯到最开始的位置
if(!col[i] && !dia1[index + i] && !dia2[index - i + n - 1]){
row.addLast(i);
col[i] = true;
dia1[index + i] = true;
dia2[index - i + n - 1] = true;
putQueen(n, index + 1, row);
//回过头到上一行，从上一行开始继续进行从第二个位置找形成递归树
col[i] = false;
dia1[index + i] = false;
dia2[index - i + n - 1] = false;
row.removeLast();
}
return;
}
private List<String> generateBoard(int n, LinkedList<Integer> row){
assert row.size() == n;
ArrayList<String> board = new ArrayList<String>();
for(int i = 0 ; i < n ; i ++){
char[] charArray = new char[n];
Arrays.fill(charArray, '.');
charArray[row.get(i)] = 'Q';
board.add(new String(charArray));
}
return board;
}
private static void printBoard(List<String> board){
for(String s: board)
System.out.println(s);
System.out.println();
}
public static void main(String[] args) {
int n = 4;
List<List<String>> res = (new Solution()).solveNQueens(n);
for(List<String> board: res)
printBoard(board);
}
}