Leetcode刷题系列（十八）CombinationSum && WordLadder

　　本篇给出Combination Sum 和Word Ladder 这两种题型。

Combination Sum

　　这道题为给出一个数组，使用数组中的数组成和为k的组合。使用前面提到的深度搜索，类似于第一篇提到的方法。

public  ArrayList<ArrayList<Integer>> combinationSum(int[] candidates, int target) {    ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();    if (candidates == null) {        return result;    }    ArrayList<Integer> path = new ArrayList<Integer>();    Arrays.sort(candidates);    helper(candidates, target, path, 0, result);    return result;} void helper(int[] candidates, int target, ArrayList<Integer> path, int index,    ArrayList<ArrayList<Integer>> result) {    if (target == 0) {        result.add(new ArrayList<Integer>(path));        return;    }    int prev = -1;    for (int i = index; i < candidates.length; i++) {        if (candidates[i] > target) {            break;        }        if (prev != -1 && prev == candidates[i]) {            continue;        }        path.add(candidates[i]);        helper(candidates, target - candidates[i], path, i, result);        path.remove(path.size() - 1);        prev = candidates[i];    }}

Combination Sum II

　　这道题也是求组合，不同点在于数组中的数只能使用一次。因此，在下一次搜索时index+1即可。

private ArrayList<ArrayList<Integer>> results;public ArrayList<ArrayList<Integer>> combinationSum2(int[] candidates,        int target) {    if (candidates.length < 1) {        return results;    }    ArrayList<Integer> path = new ArrayList<Integer>();    java.util.Arrays.sort(candidates);    results = new ArrayList<ArrayList<Integer>> ();    combinationSumHelper(path, candidates, target, 0);    return results;}private void combinationSumHelper(ArrayList<Integer> path, int[] candidates, int sum, int pos) {    if (sum == 0) {        results.add(new ArrayList<Integer>(path));    }    if (pos >= candidates.length || sum < 0) {        return;    }    int prev = -1;    for (int i = pos; i < candidates.length; i++) {        if (candidates[i] != prev) {            path.add(candidates[i]);            combinationSumHelper(path, candidates, sum - candidates[i], i + 1);            prev = candidates[i];            path.remove(path.size()-1);        }    }}

Word Ladder

　　这道题是求一个单词变成另一个单词的最少次数，变化过程中的单词必须是词典中的单词。求最少次数这道题可以使用广度搜索，类似于层序遍历，找到第一个即是最短的。

public int ladderLength(String start, String end, Set<String> dict) {    if (dict == null) {        return 0;    }    if (start.equals(end)) {        return 1;    }    dict.add(start);    dict.add(end);    HashSet<String> hash = new HashSet<String>();    Queue<String> queue = new LinkedList<String>();    queue.offer(start);    hash.add(start);    int length = 1;    while(!queue.isEmpty()) {        length++;        int size = queue.size();        for (int i = 0; i < size; i++) {            String word = queue.poll();            for (String nextWord: getNextWords(word, dict)) {                if (hash.contains(nextWord)) {                    continue;                }                if (nextWord.equals(end)) {                    return length;                }                hash.add(nextWord);                queue.offer(nextWord);            }        }    }    return 0;}private String replace(String s, int index, char c) {    char[] chars = s.toCharArray();    chars[index] = c;    return new String(chars);}private ArrayList<String> getNextWords(String word, Set<String> dict) {    ArrayList<String> nextWords = new ArrayList<String>();    for (char c = 'a'; c <= 'z'; c++) {        for (int i = 0; i < word.length(); i++) {            if (c == word.charAt(i)) {                continue;            }            String nextWord = replace(word, i, c);            if (dict.contains(nextWord)) {                nextWords.add(nextWord);            }        }    }    return nextWords;}

Word Ladder II

　　这道题求最少变换的过程。上面题求最少变换次数使用广搜，那么这道题求过程需要在广搜里面插入深度搜索。

public List<List<String>> findLadders(String start, String end,Set<String> dict) {    List<List<String>> ladders = new ArrayList<List<String>>();    Map<String, List<String>> map = new HashMap<String, List<String>>();    Map<String, Integer> distance = new HashMap<String, Integer>();    dict.add(start);    dict.add(end);    bfs(map, distance, start, end, dict);    List<String> path = new ArrayList<String>();    dfs(ladders, path, end, start, distance, map);    return ladders;}void dfs(List<List<String>> ladders, List<String> path, String crt,        String start, Map<String, Integer> distance,        Map<String, List<String>> map) {    path.add(crt);    if (crt.equals(start)) {        Collections.reverse(path);        ladders.add(new ArrayList<String>(path));        Collections.reverse(path);    } else {        for (String next : map.get(crt)) {            if (distance.containsKey(next) && distance.get(crt) == distance.get(next) + 1) {                 dfs(ladders, path, next, start, distance, map);            }        }               }    path.remove(path.size() - 1);}void bfs(Map<String, List<String>> map, Map<String, Integer> distance,        String start, String end, Set<String> dict) {    Queue<String> q = new LinkedList<String>();    q.offer(start);    distance.put(start, 0);    for (String s : dict) {        map.put(s, new ArrayList<String>());    }    while (!q.isEmpty()) {        String crt = q.poll();        List<String> nextList = expand(crt, dict);        for (String next : nextList) {            map.get(next).add(crt);            if (!distance.containsKey(next)) {                distance.put(next, distance.get(crt) + 1);                q.offer(next);            }        }    }}List<String> expand(String crt, Set<String> dict) {    List<String> expansion = new ArrayList<String>();    for (int i = 0; i < crt.length(); i++) {        for (char ch = 'a'; ch <= 'z'; ch++) {            if (ch != crt.charAt(i)) {                String expanded = crt.substring(0, i) + ch + crt.substring(i + 1);                if (dict.contains(expanded)) {                    expansion.add(expanded);                }            }        }    }    return expansion;}