回溯法总结

class Solution {
	//一个映射表，第二个位置是"abc“,第三个位置是"def"。。。
	//这里也可以用map，用数组可以更节省点内存
	String[] letter_map = {" ","*","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
	public List<String> letterCombinations(String digits) {
		//注意边界条件
		if(digits==null || digits.length()==0) {
			return new ArrayList<>();
		}
		iterStr(digits, new StringBuilder(), 0);
		return res;
	}
	//最终输出结果的list
	List<String> res = new ArrayList<>();
	
	//递归函数
	void iterStr(String str, StringBuilder letter, int index) {
		//递归的终止条件，注意这里的终止条件看上去跟动态演示图有些不同，主要是做了点优化
		//动态图中是每次截取字符串的一部分，"234"，变成"23"，再变成"3"，最后变成""，这样性能不佳
		//而用index记录每次遍历到字符串的位置，这样性能更好
		if(index == str.length()) {
			res.add(letter.toString());
			return;
		}
		//获取index位置的字符，假设输入的字符是"234"
		//第一次递归时index为0所以c=2，第二次index为1所以c=3，第三次c=4
		//subString每次都会生成新的字符串，而index则是取当前的一个字符，所以效率更高一点
		char c = str.charAt(index);
		//map_string的下表是从0开始一直到9， c-'0'就可以取到相对的数组下标位置
		//比如c=2时候，2-'0'，获取下标为2,letter_map[2]就是"abc"
		int pos = c - '0';
		String map_string = letter_map[pos];
		//遍历字符串，比如第一次得到的是2，页就是遍历"abc"
		for(int i=0;i<map_string.length();i++) 
			//调用下一层递归，用文字很难描述，请配合动态图理解
            letter.append(map_string.charAt(i));
            //如果是String类型做拼接效率会比较低
			//iterStr(str, letter+map_string.charAt(i), index+1);
            iterStr(str, letter, index+1);
            letter.deleteCharAt(letter.length()-1);
		}
	}
}

• for(int i=0;i<map_string.length();i++) ：执行完整个循环是处理一个数字，找到该数字对应的所有字母。这个过程也是一层递归，在递归树上显示的是同一层的处理情况。

class Solution {
    static final int SEG_COUNT = 4;
    List<String> ans;
    int[] segments;
    public List<String> restoreIpAddresses(String s) {
        ans = new ArrayList<>();
        segments = new int[SEG_COUNT];
        dfs(s, 0, 0);
        return ans;
    }
    public void dfs(String s, int segId, int segStart) {
        if (segId == SEG_COUNT) {
            if (segStart == s.length()) {
                StringBuilder ipAddr = new StringBuilder();
                for (int i = 0; i < segments.length; i++) {
                    ipAddr.append(segments[i]);
                    if (i != segments.length - 1)
                        ipAddr.append('.');
                }
                ans.add(ipAddr.toString());
            }
            return; 
        }
        if (segStart == s.length()) {
            return;
        }

        if (s.charAt(segStart) == '0') {
            segments[segId] = 0;
            dfs(s, segId+1, segStart+1);
        }

        int addr = 0;
        for (int i = segStart; i < s.length(); i++) {
            addr = addr * 10 + (s.charAt(i) - '0');
            if(addr > 0 && addr <= 255) {
                segments[segId] = addr;
                dfs(s, segId+1, i+1);
            } else {
                break;  
            }
        }
    }
}

与其他回溯法代码的区别是 for (int i = segStart; i < s.length(); i++) 循环条件这里，执行完整个循环的终止条件是if(addr < 0 || addr > 255)，然后break，并没有撤销操作，这里值得思考一下为什么？因为用的是字符串数组存的临时结果。如果是队列，字符串的话则都需要删除最后一个元素。