久久人人爽人人爽人人片av高清,日韩福利二区,亚洲综合无码一区二区

[Leetcode] Trapping Rain Water

Meng Lee — Tue, 14 Jan 2014 01:16:00 GMT

��法很简单，核心思想是：�Ҏ��个值A[i]来说�Q�能trapped的最多的water取决于在i之前最高的值leftMostHeight[i]和在i双��的最高的值rightMostHeight[i]。（均不包含自��n�Q�。如果min(left,right) > A[i]�Q�那么在i�q�个位置上能trapped的water��是min(left,right) – A[i]�?/div>

有了�q�个��x��好办了�Q�第一遍从左到双��数�l�leftMostHeight�Q�第二遍从右到左计算rightMostHeight�Q�在�W�二遍的同时��可以计��出i位置的结果了�Q�而且�q�不需要开�I�间来存放rightMostHeight数组�?/div>

旉��复杂度是O(n)�Q�只扫了两遍�?br />

1 public class TrappingRainWater {
2     public int trap(int A[], int n) {
3         if (n <= 2)
4             return 0;
5
6         int[] lmh = new int[n];
7         lmh[0] = 0;
8         int maxh = A[0];
9         for (int i = 1; i < n; ++i) {
10             lmh[i] = maxh;
11             if (maxh < A[i])
12                 maxh = A[i];
13         }
14         int trapped = 0;
15         maxh = A[n - 1];
16         for (int i = n - 2; i > 0; --i) {
17             int left = lmh[i];
18             int right = maxh;
19             int container = Math.min(left, right);
20             if (container > A[i]) {
21                 trapped += container - A[i];
22             }
23             if (maxh < A[i])
24                 maxh = A[i];
25         }
26         return trapped;
27     }
28 }

Meng Lee 2014-01-14 09:16 发表评论

[Leetcode] Permutation Sequence

Meng Lee — Tue, 07 Jan 2014 08:06:00 GMT

The set [1,2,3,…,n] contains a total of n! unique permutations.

By listing and labeling all of the permutations in order,

We get the following sequence (ie, for n = 3):

"123"

"132"

"213"

"231"

"312"

"321"

Given n and k, return the kth permutation sequence.

Note: Given n will be between 1 and 9 inclusive.

�q�道题其实有很强的规律可循。首先，n个元素的排列��L��是n!。在下面的分析中�Q�让k的范围是0 <= k < n!。（题目代码实际上是1<=k<=n!)
可以看到一个规律，��是�q�n�Q�个排列中，�W�一位的元素��L��(n-1)!一�l�出现的�Q�也��p��如果p = k / (n-1)!�Q�那么排列的最开始一个元素一定是arr[p]�?/div>

�q�个规律可以�c�L��下去�Q�在剩余的n-1个元素中逐渐挑选出�W�二个，�W�三个，...�Q�到�W�n个元素。程序就�l�束�?/div>

1 /**
2  * The set [1,2,3,…,n] contains a total of n! unique permutations.
3  *
4  * By listing and labeling all of the permutations in order, We get the
5  * following sequence (ie, for n = 3):
6  *
7  * "123" "132" "213" "231" "312" "321" Given n and k, return the kth permutation
8  * sequence.
9  *
10  * Note: Given n will be between 1 and 9 inclusive.
11  *
12  */
13
14 public class PermutationSequence {
15     public String getPermutation(int n, int k) {
16         char[] arr = new char[n];
17         int pro = 1;
18         for (int i = 0; i < n; ++i) {
19             arr[i] = (char) ('1' + i);
20             pro *= (i + 1);
21         }
22         k = k - 1;
23         k %= pro;
24         pro /= n;
25         for (int i = 0; i < n - 1; ++i) {
26             int selectI = k / pro;
27             k = k % pro;
28             pro /= (n - i - 1);
29             int temp = arr[selectI + i];
30             for (int j = selectI; j > 0; --j) {
31                 arr[i + j] = arr[i + j - 1];
32             }
33             arr[i] = (char) temp;
34         }
35         return String.valueOf(arr);
36     }
37 }
38

Meng Lee 2014-01-07 16:06 发表评论

[Leetcode] Lowest Common Ancestor of a Binary Search Tree (BST) && Lowest Common Ancestor of Binary Tree

Meng Lee — Mon, 06 Jan 2014 01:32:00 GMT

Lowest Common Ancestor of a Binary Search Tree (BST)

Given a binary search tree (BST), find the lowest common ancestor of two given nodes in the BST.

_______6______

/ \

___2__ ___8__

/ \ / \

0 _4 7 9

/ \

3 5

Using the above tree as an example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6.

But how about LCA of nodes 2 and 4? Should it be 6 or 2?

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between

two nodes v and w as the lowest node in T that has both v and w as descendants (where we allow a

node to be a descendant of itself).” Since a node can be a descendant of itself, the LCA of 2 and

4 should be 2, according to this definition.

Hint:

A top-down walk from the root of the tree is enough.

1 public class LowestCommonAncestorOfaBinarySearchTree {
2     public TreeNode LCA(TreeNode root, TreeNode p, TreeNode q) {
3         if (root == null || p == null || q == null)
4             return null;
5         if (Math.max(p.val, q.val) < root.val)
6             return LCA(root.left, p, q);
7         if (Math.min(p.val, q.val) > root.val)
8             return LCA(root.right, p, q);
9         return root;
10     }
11 }

Given a binary tree, find the lowest common ancestor of two given nodes in the tree.

_______3______

/ \

___5__ ___1__

/ \ / \

6 _2 0 8

/ \

7 4

If you are not so sure about the definition of lowest common ancestor (LCA), please refer to my previous

post: Lowest Common Ancestor of a Binary Search Tree (BST) or the definition of LCA here. Using the tree

above as an example, the LCA of nodes 5 and 1 is 3. Please note that LCA for nodes 5 and 4 is 5.

Hint:

Top-down or bottom-up? Consider both approaches and see which one is more efficient.

1 public class LowestCommonAncestorOfBinaryTree {
2     public TreeNode LCA(TreeNode root, TreeNode p, TreeNode q) {
3         if (root == null)
4             return null;
5         if (root == p || root == q)
6             return root;
7         TreeNode left = LCA(root.left, p, q);
8         TreeNode right = LCA(root.right, p, q);
9         if (left != null && right != null)
10             return root;
11         return left != null ? left : right;
12     }
13 }

Meng Lee 2014-01-06 09:32 发表评论

[Leetcode] Scramble String

Meng Lee — Sun, 05 Jan 2014 04:33:00 GMT

Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.

Below is one possible representation of s1 = "great":

great

/ \

gr eat

/ \ / \

g r e at

/ \

a t

To scramble the string, we may choose any non-leaf node and swap its two children.

For example, if we choose the node "gr" and swap its two children, it produces a scrambled string "rgeat".

rgeat

/ \

rg eat

/ \ / \

r g e at

/ \

a t

We say that "rgeat" is a scrambled string of "great".

Similarly, if we continue to swap the children of nodes "eat" and "at", it produces a scrambled string "rgtae".

rgtae

/ \

rg tae

/ \ / \

r g ta e

/ \

t a

We say that "rgtae" is a scrambled string of "great".

Given two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.

1 public class ScrambleString {
2     public boolean isScramble(String s1, String s2) {
3         if (s1.length() != s2.length())
4             return false;
5         if (s1.equals(s2))
6             return true;
7
8         int[] A = new int[26];
9         for (int i = 0; i < s1.length(); i++) {
10             ++A[s1.charAt(i) - 'a'];
11         }
12
13         for (int j = 0; j < s2.length(); j++) {
14             --A[s2.charAt(j) - 'a'];
15         }
16
17         for (int k = 0; k < 26; k++) {
18             if (A[k] != 0)
19                 return false;
20         }
21
22         for (int i = 1; i < s1.length(); i++) {
23             boolean result = isScramble(s1.substring(0, i), s2.substring(0, i))
24                     && isScramble(s1.substring(i), s2.substring(i));
25             result = result
26                     || (isScramble(s1.substring(0, i),
27                             s2.substring(s2.length() - i, s2.length())) && isScramble(
28                             s1.substring(i), s2.substring(0, s2.length() - i)));
29             if (result)
30                 return true;
31         }
32         return false;
33     }
34 }

Meng Lee 2014-01-05 12:33 发表评论

[Leetcode] Largest Rectangle in Histogram

Meng Lee — Sun, 05 Jan 2014 04:31:00 GMT

Given n non-negative integers representing the histogram's bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.

Above is a histogram where width of each bar is 1, given height = [2,1,5,6,2,3].

The largest rectangle is shown in the shaded area, which has area = 10 unit.

For example,

Given height = [2,1,5,6,2,3],

return 10.

本题需要��用栈�l�护一个高度单调递增的序列下标，如果遇到一个元素比当前栈顶元素高度��，那么出栈�Q��ƈ计算当前最大面�U�。如果栈为空�Q�需要特�D�考虑�?br />

1 public class LargestRectangleinHistogram {
2     public int largestRectangleArea(int[] height) {
3         Stack stack = new Stack();
4         int i = 0;
5         int maxArea = 0;
6         int[] h = new int[height.length + 1];
7         h = Arrays.copyOf(height, height.length + 1);
8         while (i < h.length) {
9             if (stack.isEmpty() || h[stack.peek()] <= h[i]) {
10                 stack.push(i++);
11             } else {
12                 int t = stack.pop();
13                 maxArea = Math.max(maxArea, h[t] * (stack.isEmpty() ? i : i - stack.peek() - 1));
14             }
15         }
16         return maxArea;
17     }
18 }

Meng Lee 2014-01-05 12:31 发表评论

[Leetcode] Binary Tree Inorder Traversal

Meng Lee — Sat, 04 Jan 2014 03:17:00 GMT

Given a binary tree, return the inorder traversal of its nodes' values.

For example:

Given binary tree {1,#,2,3},

return [1,3,2].

Note: Recursive solution is trivial, could you do it iteratively?

切记p节点初始时指向root.left。代码如下：

1 public class BinaryTreeInorderTraversal {
2     public ArrayList inorderTraversal(TreeNode root) {
3         ArrayList inOrder = new ArrayList();
4         if (root == null)
5             return inOrder;
6         Stack s = new Stack();
7         s.add(root);
8         TreeNode p = root.left;
9         while (!s.empty()) {
10             while (p != null) {
11                 s.add(p);
12                 p = p.left;
13             }
14             TreeNode n = s.pop();
15             inOrder.add(n.val);
16             p = n.right;
17             if (p != null) {
18                 s.add(p);
19                 p = p.left;
20             }
21         }
22         return inOrder;
23     }
24 }

Meng Lee 2014-01-04 11:17 发表评论

[Leetcode] Subsets II

Meng Lee — Fri, 03 Jan 2014 08:40:00 GMT

Given a collection of integers that might contain duplicates, S, return all possible subsets.

Note:

Elements in a subset must be in non-descending order.

The solution set must not contain duplicate subsets.

For example,

If S = [1,2,2], a solution is:

[

[2],

[1],

[1,2,2],

[2,2],

[1,2],

[]

]

�׃��元素中可能存在重复，因此较之于Subset的实玎ͼ�需要加一些判断。如果碰��C��重复元素�Q�只需要在上一�ơ�P代新增的子集的基��上再�q�行�q�代卛_��。实��C��码如下：

1 public class SubsetsII {
2     public ArrayList> subsetsWithDup(int[] num) {
3         ArrayList> ret = new ArrayList>();
4         ArrayList> lastLevel = null;
5         ret.add(new ArrayList());
6         Arrays.sort(num);
7         for (int i = 0; i < num.length; i++) {
8             ArrayList> tmp = new ArrayList>();
9             ArrayList> prev = i == 0 || num[i] != num[i - 1] ? ret : lastLevel;
10             for (ArrayList s : prev) {
11                 ArrayList newSet = new ArrayList(s);
12                 newSet.add(num[i]);
13                 tmp.add(newSet);
14             }
15             ret.addAll(tmp);
16             lastLevel = tmp;
17         }
18         return ret;
19     }
20 }

Meng Lee 2014-01-03 16:40 发表评论

[Leetcode] Word Ladder II

Meng Lee — Thu, 02 Jan 2014 05:59:00 GMT

Given two words (start and end), and a dictionary, find all shortest transformation sequence(s) from start to end, such that:

Only one letter can be changed at a time

Each intermediate word must exist in the dictionary

For example,

Given:

start = "hit"

end = "cog"

dict = ["hot","dot","dog","lot","log"]

Return

[

["hit","hot","dot","dog","cog"],

["hit","hot","lot","log","cog"]

]

Note:

All words have the same length.

All words contain only lowercase alphabetic characters.

�q�个题目应该��是leetcode上比较难的题目了。刚开始我采用了和Word Ladder�怼�的做法，只是用ArrayList记录了当前变换�\径，在小数据的情况下可以Accept�Q�但是大数据��时。究其原因，是由于�ؓ每个当前节点记录变换路径的时候，需要复制之前的ArrayList�Q�这个时间开销较大�?br />其实�Q�我们可以采用一个Map>�l�构�Q�记录字典单词的每一个前驱，�q�样我们可以从end反向遍历�Q�构造出转换路径�?br />同时�Q�我利用了两个ArrayList�Q�交替记录上一层和下一层的节点�Q�如果下一层节点�ؓ�I�，则不存在路径�Q�立卌��回。如果下一层中出现了end�Q�证明找��C��所有的最短�\径，停止搜烦开始构造�\径。实��C��码如下：

1 public class WordLadderII {
2     private void GeneratePath(Map> prevMap,
3             ArrayList path, String word,
4             ArrayList> ret) {
5         if (prevMap.get(word).size() == 0) {
6             path.add(0, word);
7             ArrayList curPath = new ArrayList(path);
8             ret.add(curPath);
9             path.remove(0);
10             return;
11         }
12
13         path.add(0, word);
14         for (String pt : prevMap.get(word)) {
15             GeneratePath(prevMap, path, pt, ret);
16         }
17         path.remove(0);
18     }
19
20     public ArrayList> findLadders(String start, String end,
21             HashSet dict) {
22         ArrayList> ret = new ArrayList>();
23         Map> prevMap = new HashMap>();
24         dict.add(start);
25         dict.add(end);
26         for (String d : dict) {
27             prevMap.put(d, new ArrayList());
28         }
29         ArrayList> candidates = new ArrayList>();
30         candidates.add(new HashSet());
31         candidates.add(new HashSet());
32         int current = 0;
33         int previous = 1;
34         candidates.get(current).add(start);
35         while (true) {
36             current = current == 0 ? 1 : 0;
37             previous = previous == 0 ? 1 : 0;
38             for (String d : candidates.get(previous)) {
39                 dict.remove(d);
40             }
41             candidates.get(current).clear();
42             for (String wd : candidates.get(previous)) {
43                 for (int pos = 0; pos < wd.length(); ++pos) {
44                     StringBuffer word = new StringBuffer(wd);
45                     for (int i = 'a'; i <= 'z'; ++i) {
46                         if (wd.charAt(pos) == i) {
47                             continue;
48                         }
49
50                         word.setCharAt(pos, (char) i);
51
52                         if (dict.contains(word.toString())) {
53                             prevMap.get(word.toString()).add(wd);
54                             candidates.get(current).add(word.toString());
55                         }
56                     }
57                 }
58             }
59
60             if (candidates.get(current).size() == 0) {
61                 return ret;
62             }
63             if (candidates.get(current).contains(end)) {
64                 break;
65             }
66         }
67
68         ArrayList path = new ArrayList();
69         GeneratePath(prevMap, path, end, ret);
70
71         return ret;
72     }
73 }

Meng Lee 2014-01-02 13:59 发表评论

[Leetcode] Distinct Subsequences && Edit Distance

Meng Lee — Tue, 31 Dec 2013 02:21:00 GMT

Distinct Subsequences

Given a string S and a string T, count the number of distinct sub sequences of T in S.

A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, "ACE" is a subsequence of "ABCDE" while "AEC" is not).

Here is an example:

S = "rabbbit", T = "rabbit"

Return 3.

�q�两个题目很�怼��Q�状态方�E�是f(i, j) = f(i - 1, j) + S[i] == T[j]? f(i - 1, j - 1) : 0 Where f(i, j) is the number of distinct sub-sequence for T[0:j] in S[0:i].
数组初始情况是第一列全部是1�Q�代表T字符串是�I�Z��Q�S和自己做匚w��。实��C��码如下：

1 public class DistinctSubsequences {
2     public int numDistinct(String S, String T) {
3         int[][] f = new int[S.length() + 1][T.length() + 1];
4         for (int k = 0; k < S.length(); k++)
5             f[k][0] = 1;
6         for (int i = 1; i <= S.length(); i++) {
7             for (int j = 1; j <= T.length(); j++) {
8                 if (S.charAt(i - 1) == T.charAt(j - 1)) {
9                     f[i][j] += f[i - 1][j] + f[i - 1][j - 1];
10                 } else {
11                     f[i][j] += f[i - 1][j];
12                 }
13             }
14         }
15         return f[S.length()][T.length()];
16     }
17 }

Edit Distance

Given two words word1 and word2, find the minimum number of steps required to convert word1 to word2. (each operation is counted as 1 step.)

You have the following 3 operations permitted on a word:

a) Insert a character

b) Delete a character

c) Replace a character

1 public class EditDistance {
2     public int minDistance(String word1, String word2) {
3         if (word1.length() == 0 || word2.length() == 0)
4             return word1.length() == 0 ? word2.length() : word1.length();
5         int[][] arr = new int[word2.length() + 1][word1.length() + 1];
6         for (int i = 0; i <= word1.length(); i++) {
7             arr[0][i] = i;
8         }
9         for (int j = 0; j <= word2.length(); j++) {
10             arr[j][0] = j;
11         }
12         for (int i = 0; i < word1.length(); i++) {
13             for (int j = 0; j < word2.length(); j++) {
14                 if (word1.charAt(i) == word2.charAt(j)) {
15                     arr[j + 1][i + 1] = arr[j][i];
16                 } else {
17                     int dis = Math.min(arr[j][i + 1], arr[j + 1][i]);
18                     arr[j + 1][i + 1] = Math.min(arr[j][i], dis) + 1;
19                 }
20             }
21         }
22         return arr[word2.length()][word1.length()];
23     }
24 }

Meng Lee 2013-12-31 10:21 发表评论

[Leetcode] 合�ƈ区间

Meng Lee — Thu, 26 Dec 2013 06:47:00 GMT

1、给定一�l�区��_��表示为[start,end]�Q�请�l�出�Ҏ��Q�将有重叠的区间�q�行合�ƈ。例如：

�l�定�Q�[1,3],[2,6],[8,10],[15,18],

合�ƈ�Q�[1,6],[8,10],[15,18].

分析�Q�题目很直观�Q�首先把区间递增排序�Q�然后从头合�qӞ��合�ƈ时观察当前区间的start是否��于或等于前一个区间的end。代码如下：

1 public class MergeIntervals {
2     public class IntervalCmp implements Comparator {
3         @Override
4         public int compare(Interval i1, Interval i2) {
5             if (i1.start < i2.start) return -1;
6             if (i1.start == i2.start && i1.end <= i2.end) return -1;
7             return 1;
8         }
9     }
10
11     public ArrayList merge(ArrayList intervals) {
12         ArrayList ret = new ArrayList();
13         if (intervals.size() == 0) return ret;
14         Interval[] arr = new Interval[intervals.size()];
15         intervals.toArray(arr);
16         Arrays.sort(arr, new IntervalCmp());
17         int start = arr[0].start;
18         int end = arr[0].end;
19         for (int i = 0; i < arr.length; i++) {
20             if (arr[i].start <= end) {
21                 end = Math.max(end, arr[i].end);
22             } else {
23                 ret.add(new Interval(start, end));
24                 start = arr[i].start;
25                 end = arr[i].end;
26             }
27         }
28         ret.add(new Interval(start, end));
29         return ret;
30     }
31 }

2、给定的一�l�区��_��区间中的存在的��L��区间的父区间删除�Q�例如：

�l�定�Q�[1,2] [1,3] [1,4] [5,9] [6,8]

删除后：[1,2] [6,8]

分析�Q�此题暴力的解法的复杂度为O(N^2)。受上一题排序的启发�Q�是否有好一点的思�\呢？

我们可以按照start递增排序�Q�若start相等�Q�则按照end递减排序。考虑排序后的�W�i-1 和第i个区��_��׃��start是递增的，所以第i-1个区间的start肯定��于�{�于�W�i个区间的start。若�W�i-1个区间的end大于�{�于�W�i个区间的end�Q�则�W�i-1个区间就成�ؓ�W�i个区间的父区间了�?/div>

按照�q�个思�\�Q�可以试着在排序之后逆向��序处理每一个区间。假讑ֽ�前处理第i个区��_��如前所�q�ͼ�若第i-1个区间的end大于�{�于�W�i个区间的end�Q�则�W�i-1个区间成为第i个区间的父区��_��可以保留�W�i个区��_��第i-1个区间删除。由于第i-1个区间是�W�i个区间的父区��_��所以第i-1个区间的父区间也是第i个区间的父区��_��q�种情�Ş下删掉第i-1个区��_��后箋不会漏删�W�i-1个区间的父区间。若�W�i-1个区间的end��于�W�i个区间的end�Q�则可以跌��W�i个区��_��开始处理第i-1个区间。因为按照这�U�处理的�Ҏ��Q�在处理到第i个区间时�Q�该区间不会是�Q何区间的父区��_��若是父区间已�l�被如前所�q�的�Ҏ��删除了）。而且�Q�在�q�种情�Ş下，后箋可能出现的第i个区间的父区间会是第i-1个区间的父区��_��所以也不会漏掉�W�i个区间的父区间。所以排序之后逆向处理�Q�只需要O(N)的时��_��可以解册��道问题。整体的旉��复杂度�ؓO(nlogn)�?br />

1 public class Solution {
2     public class IntervalCmp implements Comparator {
3         @Override
4         public int compare(Interval i1, Interval i2) {
5             if (i1.start < i2.start) return -1;
6             if (i1.start == i2.start && i1.end >= i2.end) return -1;
7             return 1;
8         }
9     }
10
11     public ArrayList merge(ArrayList intervals) {
12         ArrayList ret = new ArrayList();
13         if (intervals.size() == 0) return ret;
14         Interval[] arr = new Interval[intervals.size()];
15         intervals.toArray(arr);
16         Arrays.sort(arr, new IntervalCmp());
17         int start = arr[arr.length - 1].start;
18         int end = arr[arr.length - 1].end;
19         for (int i = arr.length - 2; i >= 0; i--) {
20             if (arr[i].end < end) {
21                 ret.add(new Interval(start, end));
22                 start = arr[i].start;
23                 end = arr[i].end;
24             }
25         }
26         ret.add(new Interval(start, end));
27         return ret;
28     }
29 }

Meng Lee 2013-12-26 14:47 发表评论

[Leetcode] Triangle

Meng Lee — Wed, 25 Dec 2013 03:31:00 GMT

Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adjacent numbers on the row below.

For example, given the following triangle

[

[2],

[3,4],

[6,5,7],

[4,1,8,3]

]

The minimum path sum from top to bottom is 11 (i.e., 2 + 3 + 5 + 1 = 11).

Note:

Bonus point if you are able to do this using only O(n) extra space, where n is the total number of rows in the triangle.

本题本来的想法是用递归做，实现代码如下�Q?br />

1 public class Solution {
2     public int minimumTotal(ArrayList> triangle) {
3         int row = triangle.size();
4         return findMinPath(triangle, 0, 0, row);
5     }
6
7     private int findMinPath(ArrayList> triangle, int row,
8             int col, int totalRow) {
9         if (row == totalRow - 1) {
10             return triangle.get(row).get(col);
11         } else {
12             return triangle.get(row).get(col) + Math.min(findMinPath(triangle, row + 1, col, totalRow), findMinPath(triangle, row + 1, col + 1, totalRow));
13         }
14     }
15 }

提交之后发现��时�Q�于是考虑到可能是递归的开销问题�Q�考虑用�P代解题。实现如下：

1 public class Triangle {
2     public int minimumTotal(ArrayList> triangle) {
3         int n = triangle.size() - 1;
4         int[] path = new int[triangle.size()];
5         for (int o = 0; o < triangle.get(n).size(); o++) {
6             path[o] = triangle.get(n).get(o);
7         }
8         for (int i = triangle.size() - 2; i >= 0; i--) {
9             for (int j = 0, t = 0; j < triangle.get(i + 1).size() - 1; j++, t++) {
10                 path[t] = triangle.get(i).get(t)
11                         + Math.min(path[j], path[j + 1]);
12             }
13         }
14         return path[0];
15     }
16 }

�q�个解法的核心是从叶节点自底向上构造解�I�间�?/div>

Meng Lee 2013-12-25 11:31 发表评论

[Leetcode] Gray Code && Subsets

Meng Lee — Tue, 24 Dec 2013 04:06:00 GMT

Subsets的解法是从空集开始，依次取每一个元素与子集中的每个集合做�ƈ操作。实��C��码如下：

1 public class Subsets {
2     public ArrayList<ArrayList<Integer>> subsets(int[] S) {
3         Arrays.sort(S);
4         ArrayList<ArrayList<Integer>> subsets = new ArrayList<ArrayList<Integer>>();
5         subsets.add(new ArrayList<Integer>());
6         for (int i = 0; i < S.length; i++) {
7             int size = subsets.size();
8             for (int j = 0; j < size; j++) {
9                 ArrayList<Integer> subset = new ArrayList<Integer>(
10                         subsets.get(j));
11                 subset.add(S[i]);
12                 subsets.add(subset);
13             }
14         }
15         return subsets;
16     }
17 }

Gray Code的算法是初始旉��合中只有{0, 1}两个元素�Q�此后在每个元素的前面附加一�?。实��C��码如下：

1 public class GrayCode {
2     public ArrayList<Integer> grayCode(int n) {
3         ArrayList<Integer> result = new ArrayList<Integer>();
4         if (n == 0) {
5             result.add(0);
6             return result;
7         }
8         ;
9         result.add(0);
10         result.add(1);
11         for (int i = 1; i < n; i++) {
12             ArrayList<Integer> tmp = new ArrayList<Integer>(result);
13             Integer a = 1 << i;
14             for (int k = result.size() - 1; k >= 0; k--) {
15                 tmp.add(result.get(k) + a);
16             }
17             result = tmp;
18         }
19         return result;
20     }
21 }

Meng Lee 2013-12-24 12:06 发表评论

[Leetcode] Multiply Strings

Meng Lee — Mon, 23 Dec 2013 03:59:00 GMT

Given two numbers represented as strings, return multiplication of the numbers as a string.

Note: The numbers can be arbitrarily large and are non-negative.

�Ҏ��个数字相乘，记录��C��个数�l�中�Q�然后对�q�个数字的每个元素进行进位检查。主要相乘的时候要分别从两个数字的最后一位开始，�q�要记录偏移量。实现如下：

1 public class MultiplyStrings {
2     public String multiply(String num1, String num2) {
3         int length1 = num1.length();
4         int length2 = num2.length();
5         int[] m = new int[length1 + length2];
6         for (int k = length2 - 1, offset2 = 0; k >= 0; k--, offset2++) {
7             for (int i = length1 - 1, offset1 = 0; i >= 0; i--, offset1++) {
8                 m[length1 + length2 - 1 - offset1 - offset2] += (num1.charAt(i) - '0') * (num2.charAt(k) - '0');
9             }
10         }
11         int add = 0;
12         for (int t = length1 + length2 - 1; t >= 0; t--) {
13             int value = m[t] + add;
14             add = value / 10;
15             m[t] = value % 10;
16         }
17         StringBuffer sb = new StringBuffer();
18         int w = 0;
19         for (; w < length1 + length2; w++) {
20             if (m[w] != 0) break;
21         }
22         for (int e = w; e < length1 + length2; e++) {
23             sb.append(m[e]);
24         }
25         return sb.length() == 0 ? "0" : sb.toString();
26     }
27 }

Meng Lee 2013-12-23 11:59 发表评论

[Leetcode] Search for a Range

Meng Lee — Mon, 23 Dec 2013 01:58:00 GMT

Given a sorted array of integers, find the starting and ending position of a given target value.

Your algorithm's runtime complexity must be in the order of O(log n).

If the target is not found in the array, return [-1, -1].

For example,

Given [5, 7, 7, 8, 8, 10] and target value 8,

return [3, 4].

�q�个题目有递归和非递归两个解法�?br />递归解法�Q�这个解法比较简�z�，代码如下�Q?br />

1 public class SearchforaRange {
2         public int[] searchRange(int[] A, int target) {
3                 int low = findLow(A, target, 0, A.length - 1);
4                 int high = findHigh(A, target, 0, A.length - 1);
5                 int[] ret = new int[2];
6                 ret[0] = low;
7                 ret[1] = high;
8                 return ret;
9         }
10
11         private int findLow(int[] A, int target, int l, int r) {
12                 int mid = 0;
13                 int ret = -1;
14                 while (l <= r) {
15                         mid = (l + r) / 2;
16                         if (A[mid] == target) {
17                                 ret = mid;
18                                 int next = findLow(A, target, l, mid - 1);
19                                 if (next != -1) {
20                                         ret = next;
21                                 }
22                                 break;
23                         } else if (A[mid] < target) {
24                                 l = mid + 1;
25                         } else {
26                                 r = mid - 1;
27                         }
28
29                 }
30                 return ret;
31         }
32
33         private int findHigh(int[] A, int target, int l, int r) {
34                 int mid = 0;
35                 int ret = -1;
36                 while (l <= r) {
37                         mid = (l + r) / 2;
38                         if (A[mid] == target) {
39                                 ret = mid;
40                                 int next = findHigh(A, target, mid + 1, r);
41                                 if (next != -1) {
42                                         ret = next;
43                                 }
44                                 break;
45                         } else if (A[mid] < target) {
46                                 l = mid + 1;
47                         } else {
48                                 r = mid - 1;
49                         }
50                 }
51                 return ret;
52         }
53 }

非递归解法�Q�以��L��左边界�ؓ例，�q�个解法的思�\��是一直向左进行二分查找，直到扑ֈ�最左的目标元素或者最左的目标元素的下一个元素。因此，二分查找�l�束之后�Q�需要判断找到的元素到底是目标元素还是他的第一个不满��的元素，然后�Ҏ��情况�q�回下标。代码实现如下：

1 public class Solution {
2     public int[] searchRange(int[] A, int target) {
3         int left = findLeft(A, target);
4         int right = findRight(A, target);
5         return new int[] { left, right };
6     }
7
8     private int findLeft(int[] A, int target) {
9         int i = 0, j = A.length - 1;
10         while (i < j) {
11             int mid = (i + j) / 2;
12             if (A[mid] < target) {
13                 i = mid + 1;
14             } else {
15                 j = mid - 1;
16             }
17         }
18         if (A[i] == target) return i;
19         if (i < A.length - 1 && A[i + 1] == target) return i + 1;
20         return -1;
21     }
22
23     private int findRight(int[] A, int target) {
24         int i = 0, j = A.length - 1;
25         while (i < j) {
26             int mid = (i + j) / 2;
27             if (A[mid] > target) {
28                 j = mid - 1;
29             } else {
30                 i = mid + 1;
31             }
32         }
33         if (j >= 0 && A[j] == target)
34             return j;
35         if (j > 0 && A[j - 1] == target)
36             return j - 1;
37         return -1;
38     }
39 }

Meng Lee 2013-12-23 09:58 发表评论

[Leetcode] Search Insert Position

Meng Lee — Mon, 23 Dec 2013 01:11:00 GMT

Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.

You may assume no duplicates in the array.

Here are few examples.

[1,3,5,6], 5 → 2

[1,3,5,6], 2 → 1

[1,3,5,6], 7 → 4

[1,3,5,6], 0 → 0

本题先对数组�q�行二分搜烦�Q�如果找��C��目标元素��p��回相应的index�Q�如果最�l�没有找到对应的元素�Q�则比较最后一个元素与目标元素的大��。实��C��码如下：

1 public class Solution {
2     public int searchInsert(int[] A, int target) {
3         int length = A.length;
4         if (A.length == 0) return 0;
5         int i = 0, j = length - 1;
6         while (i < j) {
7             int mid = (i + j) / 2;
8             if (A[mid] == target) return mid;
9             if (A[mid] < target) {
10                 i = mid + 1;
11             } else {
12                 j = mid - 1;
13             }
14         }
15         return A[i] < target ? i + 1 : i;
16     }
17 }

Meng Lee 2013-12-23 09:11 发表评论

[Leetcode] Longest Substring Without Repeating Characters

Meng Lee — Sun, 22 Dec 2013 12:07:00 GMT

Given a string, find the length of the longest substring without repeating characters. For example, the longest substring without repeating letters for "abcabcbb" is "abc", which the length is 3. For "bbbbb" the longest substring is "b", with the length of 1.

本题比较��单，需要注意的是左指针右移�Ӟ��需要将它掠�q�的元素从map中移除。实��C��码如下：

1 public class Solution {
2     public int lengthOfLongestSubstring(String s) {
3         int length = s.length();
4         if (length == 0) return 0;
5         Map map = new HashMap();
6         int ret = 0;
7         int count = 0;
8         int start = 0;
9         for (int i = 0; i < length; i++) {
10             char c = s.charAt(i);
11             if (map.containsKey(c)) {
12                 int newStart = map.remove(c).intValue() + 1;
13                 for (int j = start; j < newStart; j++) {
14                     map.remove(s.charAt(j));
15                 }
16                 start = newStart;
17                 ret = ret < count ? count : ret;
18                 count = i - start + 1;
19             } else {
20                 count++;
21             }
22             map.put(c, i);
23         }
24         return ret < count ? count : ret;
25     }
26 }

Meng Lee 2013-12-22 20:07 发表评论

[Leetcode] Spiral Matrix

Meng Lee — Sun, 22 Dec 2013 08:59:00 GMT

Given a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral order.

For example,

Given the following matrix:

[

[ 1, 2, 3 ],

[ 4, 5, 6 ],

[ 7, 8, 9 ]

]

You should return [1,2,3,6,9,8,7,4,5].

可以为矩阵设�|�上下左叛_��个边界，每次�l�着�q�四个边界打印元素。实��C��码如下：

1 public class Solution {
2     public ArrayList spiralOrder(int[][] matrix) {
3         ArrayList ret = new ArrayList();
4         if (matrix.length == 0) return ret;
5         int upper = 0, bottom = matrix.length - 1;
6         int left = 0, right = matrix[0].length - 1;
7         int i = 0, j = 0;
8         while (true) {
9             for (i = left; i <= right; i++) {
10                 ret.add(matrix[upper][i]);
11             }
12             if (++upper > bottom) break;
13             for (j = upper; j <= bottom; j++) {
14                 ret.add(matrix[j][right]);
15             }
16             if (--right < left) break;
17             for (i = right; i >= left; i--) {
18                 ret.add(matrix[bottom][i]);
19             }
20             if (--bottom < upper) break;
21             for (j = bottom; j >= upper; j--) {
22                 ret.add(matrix[j][left]);
23             }
24             if (++left > right) break;
25         }
26         return ret;
27     }
28 }

Meng Lee 2013-12-22 16:59 发表评论

[Leetcode] Longest Valid Parentheses

Meng Lee — Sat, 21 Dec 2013 13:28:00 GMT

Given a string containing just the characters '(' and ')', find the length of the longest valid (well-formed) parentheses substring.

For "(()", the longest valid parentheses substring is "()", which has length = 2.

Another example is ")()())", where the longest valid parentheses substring is "()()", which has length = 4.

本题的主要思�\��是标记那些括号是被匚w��的�?br />我们可以利用一个布��数�l�，如果位置为i的��gؓtrue�Q�则表示�W�i个括��h��被匹配的�Q�然后我们只需要求�q�箋为true的元素的个数卛_��。实��C��码如下：

1 public class LongestValidParentheses {
2     public int longestValidParentheses(String s) {
3         int length = s.length();
4         if (length == 0)
5             return 0;
6         int left = 0;
7         Stack indexs = new Stack();
8         boolean[] record = new boolean[length];
9         for (int i = 0; i < length; i++) {
10             if (s.charAt(i) == '(') {
11                 left++;
12                 indexs.push(i);
13             } else if (left > 0) {
14                 int idx = indexs.pop();
15                 record[idx] = true;
16                 record[i] = true;
17                 left--;
18             }
19         }
20         int ret = 0;
21         int current = 0;
22         for (int k = 0; k < length; k++) {
23             if (record[k]) {
24                 current++;
25             } else {
26                 ret = current > ret ? current : ret;
27                 current = 0;
28             }
29         }
30         return ret > current ? ret : current;
31     }
32 }

Meng Lee 2013-12-21 21:28 发表评论

[Leetcode] Minimum Depth of Binary Tree

Meng Lee — Sat, 21 Dec 2013 13:19:00 GMT

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

本题有两�U�解法�?br />�W�一�U�解法：对二叉树�q�行BFS�Q�由于是按层遍历的，因此如果在某一层发��C��一个叶子节点，那么��找��C��最��深度，此时�q�回当前深度卛_��。实��C��码如下：

1 public class Solution {
2     public int minDepth(TreeNode root) {
3         if (root == null) return 0;
4         int depth = 1;
5         int currentLevel = 1;
6         int nextLevel = 0;
7         Queue queue = new LinkedList();
8         queue.add(root);
9         while (!queue.isEmpty()) {
10             TreeNode node = queue.remove();
11             currentLevel--;
12             if (node.left == null && node.right == null) {
13                 return depth;
14             }
15             if (node.left != null) {
16                 queue.add(node.left);
17                 nextLevel++;
18             }
19             if (node.right != null) {
20                 queue.add(node.right);
21                 nextLevel++;
22             }
23             if (currentLevel == 0) {
24                 if (nextLevel != 0) {
25                     depth++;
26                 }
27                 currentLevel = nextLevel;
28                 nextLevel = 0;
29             }
30         }
31         return depth;
32     }
33 }

�W�二�U�解法：采用递归的思想�Q�分别求左右子树的最��深度，比较之后�q�回较小倹{��实现如下：

1 public class MinimumDepthofBinaryTree {
2     public int minDepth(TreeNode root) {
3         if (root == null)
4             return 0;
5         if (root.left == null && root.right == null)
6             return 1;
7         else {
8             int leftDepth = root.left != null ? minDepth(root.left)
9                     : Integer.MAX_VALUE;
10             int rightDepth = root.right != null ? minDepth(root.right)
11                     : Integer.MAX_VALUE;
12             return Math.min(leftDepth, rightDepth) + 1;
13         }
14     }
15 }

Meng Lee 2013-12-21 21:19 发表评论

[Leetcode] Permutations II

Meng Lee — Fri, 20 Dec 2013 07:30:00 GMT

Given a collection of numbers, return all possible permutations.

For example,

[1,2,3] have the following permutations:

[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], and [3,2,1].

数组全排列题目，基本思想是对每一个字�W�与后面的字�W�作交换�Q�以生成新的序列。�ؓ了防止重复，交换之前需要检查之前是否已�l�和同样的字�W�串做过交换。代码如下：

1 public class PermutationsII {
2     public ArrayList> permuteUnique(int[] num) {
3         ArrayList> result = new ArrayList>();
4         permuteUnique(num, 0, result);
5         return result;
6     }
7
8     void permuteUnique(int[] num, int begin,
9             ArrayList> result) {
10         if (begin > num.length - 1) {
11             ArrayList item = new ArrayList();
12             for (int h = 0; h < num.length; h++) {
13                 item.add(num[h]);
14             }
15             result.add(item);
16         }
17         for (int end = begin; end < num.length; end++) {
18             if (isSwap(num, begin, end)) {
19                 swap(num, begin, end);
20                 permuteUnique(num, begin + 1, result);
21                 swap(num, begin, end);
22             }
23         }
24     }
25
26     boolean isSwap(int[] arr, int i, int j) {
27         for (int k = i; k < j; k++) {
28             if (arr[k] == arr[j]) {
29                 return false;
30             }
31         }
32         return true;
33     }
34
35     private void swap(int[] a, int i, int j) {
36         int tmp = a[i];
37         a[i] = a[j];
38         a[j] = tmp;
39     }
40 }

Meng Lee 2013-12-20 15:30 发表评论

[Leetcode] Unique Binary Search Trees

Meng Lee — Fri, 20 Dec 2013 03:58:00 GMT

Given n, how many structurally unique BST's (binary search trees) that store values 1...n?

For example,

Given n = 3, there are a total of 5 unique BST's.

1 3 3 2 1

\ / / / \ \

3 2 1 1 3 2

/ / \ \

2 1 2 3
本题使用一�l�线性规划解冟�?br />如果n�{�于0�Ӟ��l�果�?�Q?br />如果n�{�于1�Ӟ��只有一个节点，�l�果�?�Q?br />如果n�{�于2�Ӟ��根节�Ҏ��两种选择�Q�结果�ؓ2�Q?br />如果n大于3�Ӟ��根节�Ҏ��n�U�选择�Q�确定根节点后分别计��左叛_��树的可能情况�Q�然后相乘就是当前根节点下所有的变�Ş�U�类�Q�之后在求和卛_��。算法实现如下：

1 public class UniqueBinarySearchTrees {
2     public int numTrees(int n) {
3         if (n == 1)
4             return 1;
5         if (n == 2)
6             return 2;
7         int[] record = new int[n + 1];
8         record[0] = 1;
9         record[1] = 1;
10         record[2] = 2;
11         for (int i = 3; i <= n; i++) {
12             int tmp = 0;
13             for (int k = 0; k < i; k++) {
14                 tmp += (record[k] * record[i - k - 1]);
15             }
16             record[i] = tmp;
17         }
18         return record[n];
19     }
20 }

Meng Lee 2013-12-20 11:58 发表评论

[Leetcode] Palindrome Partitioning

Meng Lee — Thu, 19 Dec 2013 09:03:00 GMT

Given a string s, partition s such that every substring of the partition is a palindrome.

Return all possible palindrome partitioning of s.

For example, given s = "aab",

Return

[

["aa","b"],

["a","a","b"]

]

�q�个题目考虑用动态规划解题，关键在于构造一个解�I�间�Q�确定S的�Q意子串S(i, j)是不是对�U�的。判断标准如下：
1、如果i == j�Q�则S(i, j)是对�U�的�Q?br />2、如果j - i == 1 && S[i] == S[j]�Q�则S(i, j)是对�U�的�Q?br />3、如果j - i > 1 && S[i] == S[j] && S(i + 1, j - 1)是对�U�的�Q�则S(i, j)也是对称的�?br />在构造完�q�样的解�I�间后，��可以在O(1)旉��内判定�Q意子串是不是对称的了。算法实现如下：

1 public class PalindromePartitioning {
2     public ArrayList> partition(String s) {
3         ArrayList> ret = new ArrayList>();
4         ArrayList r = new ArrayList();
5         int length = s.length();
6         boolean[][] map = new boolean[length][length];
7         findPartition(s, 0, ret, r, map);
8         return ret;
9     }
10
11     private void findPartition(String s, int start,
12             ArrayList> ret, ArrayList r,
13             boolean[][] map) {
14         int length = s.length();
15         if (start == length && r.size() != 0) {
16             ArrayList clone = new ArrayList(r);
17             ret.add(clone);
18         } else {
19             for (int j = start; j < length; j++) {
20                 if (start == j
21                         || (j - start > 1 && s.charAt(start) == s.charAt(j) && map[start + 1][j - 1])
22                         || (j - start == 1 && s.charAt(start) == s.charAt(j))) {
23                     map[start][j] = true;
24                     r.add(s.substring(start, j + 1));
25                     findPartition(s, j + 1, ret, r, map);
26                     r.remove(r.size() - 1);
27                 }
28             }
29         }
30     }
31 }

Meng Lee 2013-12-19 17:03 发表评论

[Leetcode] Clone Graph

Meng Lee — Thu, 19 Dec 2013 02:36:00 GMT

Clone an undirected graph. Each node in the graph contains a label and a list of its neighbors.

OJ's undirected graph serialization:

Nodes are labeled uniquely.

We use # as a separator for each node, and , as a separator for node label and each neighbor of the node.

As an example, consider the serialized graph {0,1,2#1,2#2,2}.

The graph has a total of three nodes, and therefore contains three parts as separated by #.

1. First node is labeled as 0. Connect node 0 to both nodes 1 and 2.

2. Second node is labeled as 1. Connect node 1 to node 2.

3. Third node is labeled as 2. Connect node 2 to node 2 (itself), thus forming a self-cycle.

Visually, the graph looks like the following:

/ \

0 --- 2

/ \

\_/

需要对原图�q�行BFS搜烦�Q�其中Set visited对已�l�访问过的节点进行记录，Map map用来记录新老节点的对应关系。代码实现如下：

1 import java.util.HashMap;
2 import java.util.HashSet;
3 import java.util.LinkedList;
4 import java.util.Map;
5 import java.util.Queue;
6 import java.util.Set;
7
8 public class CloneGraph {
9     public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
10         if (node == null)
11             return node;
12         Queue queue = new LinkedList();
13         queue.add(node);
14         Set visited = new HashSet();
15         Map map = new HashMap();
16         while (!queue.isEmpty()) {
17             UndirectedGraphNode n = queue.remove();
18             if (visited.contains(n))
19                 continue;
20             visited.add(n);
21             UndirectedGraphNode clone;
22             if (!map.containsKey(n)) {
23                 clone = new UndirectedGraphNode(n.label);
24                 map.put(n, clone);
25             } else {
26                 clone = map.get(n);
27             }
28             for (UndirectedGraphNode child : n.neighbors) {
29                 queue.add(child);
30                 UndirectedGraphNode cloneChild;
31                 if (!map.containsKey(child)) {
32                     cloneChild = new UndirectedGraphNode(child.label);
33                     map.put(child, cloneChild);
34                 } else {
35                     cloneChild = map.get(child);
36                 }
37                 clone.neighbors.add(cloneChild);
38             }
39         }
40         return map.get(node);
41     }
42 }

Meng Lee 2013-12-19 10:36 发表评论

[Leetcode] Gas Station

Meng Lee — Thu, 19 Dec 2013 01:29:00 GMT

There are N gas stations along a circular route, where the amount of gas at station i is gas[i].

You have a car with an unlimited gas tank and it costs cost[i] of gas to travel from station i to its next station (i+1). You begin the journey with an empty tank at one of the gas stations.

Return the starting gas station's index if you can travel around the circuit once, otherwise return -1.

Note: The solution is guaranteed to be unique.

首先�Q�这个题目要明确如果gas[0] + gas[1] + ... + gas[n] >= cost[0] + cost[1] + .. + cost[n]�Q�那么这个题目一定有解。因为，�Ҏ��条�g�U�项可得�Q?br />(gas[0] - cost[0]) + (gas[1] - cost[1]) + ... + (gas[n] - cost[n]) >= 0�Q�由于最�l�结果大于等于零�Q�因此一定可以通过加法交换律，得到一个序列，使得中间�l�果都�ؓ非负。因此可以将��法实现如下�Q?br />

1 public class GasStation {
2     public int canCompleteCircuit(int[] gas, int[] cost) {
3         int sum = 0, total = 0, len = gas.length, index = -1;
4         for (int i = 0; i < len; i++) {
5             sum += gas[i] - cost[i];
6             total += gas[i] - cost[i];
7             if (sum < 0) {
8                 index = i;
9                 sum = 0;
10             }
11         }
12         return total >= 0 ? index + 1 : -1;
13     }
14 }

Meng Lee 2013-12-19 09:29 发表评论

[Leetcode] Word Ladder

Meng Lee — Thu, 19 Dec 2013 01:11:00 GMT

Given two words (start and end), and a dictionary, find the length of shortest transformation sequence from start to end, such that:

1. Only one letter can be changed at a time

2. Each intermediate word must exist in the dictionary

For example,

Given:

start = "hit"

end = "cog"

dict = ["hot","dot","dog","lot","log"]

As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",

return its length 5.

Note:

1. Return 0 if there is no such transformation sequence.

2. All words have the same length.

3. All words contain only lowercase alphabetic characters.

�W�一个思�\是遍历dict中的每一个元素，看是不是和当前word只相差一个字�W�，如果是则作�ؓ新的当前word�Q�直到当前word与target只相差一个字�W�。实��C��码如下：

1 public class Solution {
2     public int ladderLength(String start, String end, HashSet dict) {
3         HashSet trash = new HashSet();
4         return searchWordLadder(start, end, dict, trash) + 1;
5     }
6
7     private int searchWordLadder(String start, String end, HashSet dict, HashSet trash) {
8         if (stringDiff(start, end) == 1) return 1;
9         if (dict.size() == trash.size()) return 0;
10         int steps = Integer.MAX_VALUE;
11         for (String word : dict) {
12             if (!trash.contains(word) && stringDiff(start, word) == 1) {
13                 trash.add(word);
14                 int lt = searchWordLadder(word, end, dict, trash);
15                 if (lt != 0 && lt < steps) {
16                     steps = lt;
17                 }
18                 trash.remove(word);
19             }
20         }
21         return steps == Integer.MAX_VALUE ? 0 : steps + 1;
22     }
23
24     private int stringDiff(String s1, String s2) {
25         int diff = 0;
26         int length = s1.length();
27         for (int i = 0; i < length; i++) {
28             if (s1.charAt(i) != s2.charAt(i)) {
29                 diff++;
30             }
31         }
32         return diff;
33     }
34 }

�q�个��法可以通过��数据测试，但是在大数据下报��时错误。主要问题是��法复杂度较高，�׃��dict中的单词是�ؕ序的�Q�因此最坏情况下需要遍历所有可能的转换路径才能做出判断�?br />改变思�\�Q�其实可以通过trie树的BFS搜烦获得�l�果�Q�由于BFS是分层遍历的�Q�因此找��C��个解之后��可以马上返回，复杂度是O(N)�Q�N是原单词的长度。实��C��码如下：

1 public class WordLadder {
2     public int ladderLength(String start, String end, HashSet dict) {
3         if (dict.size() == 0)
4             return 0;
5         int currentLevel = 1;
6         int nextLevel = 0;
7         int step = 1;
8         boolean found = false;
9         Queue st = new LinkedList();
10         HashSet visited = new HashSet();
11         st.add(start);
12         while (!st.isEmpty()) {
13             String s = st.remove();
14             currentLevel--;
15             if (stringDiff(s, end) == 1) {
16                 found = true;
17                 step++;
18                 break;
19             } else {
20                 int length = s.length();
21                 StringBuffer sb = new StringBuffer(s);
22                 for (int i = 0; i < length; i++) {
23                     for (int j = 0; j < 26; j++) {
24                         char c = sb.charAt(i);
25                         sb.setCharAt(i, (char) ('a' + j));
26                         if (dict.contains(sb.toString())
27                                 && !visited.contains(sb.toString())) {
28                             nextLevel++;
29                             st.add(sb.toString());
30                             visited.add(sb.toString());
31                         }
32                         sb.setCharAt(i, c);
33                     }
34                 }
35             }
36             if (currentLevel == 0) {
37                 currentLevel = nextLevel;
38                 nextLevel = 0;
39                 step++;
40             }
41         }
42         return found ? step : 0;
43     }
44
45     private int stringDiff(String s1, String s2) {
46         int diff = 0;
47         int length = s1.length();
48         for (int i = 0; i < length; i++) {
49             if (s1.charAt(i) != s2.charAt(i)) {
50                 diff++;
51             }
52         }
53         return diff;
54     }
55 }

其中利用了队列对trie树进行BFS�?/div>

Meng Lee 2013-12-19 09:11 发表评论