BlogJava-IT技术小屋-随笔分类-待字闺中

[待字闺中] 缺失的数字

Meng Lee — Sat, 28 Dec 2013 07:31:00 GMT

给定一个无序的整数数组，怎么找到第一个大于0，并且不在此数组的整数。比如[1,2,0] 返回 3, [3,4,-1,1] 返回 2。最好能O(1)空间和O(n)时间。

1 public class Solution {
2     public int findMissedNumber(int[] nums) {
3         for (int i = 0; i < nums.length; i++) {
4             if (nums[i] > 0 && nums[i] - 1 != i && nums[i] != nums[nums[i] - 1]) {
5                 int tmp = nums[nums[i] - 1];
6                 nums[nums[i] - 1] = nums[i];
7                 nums[i] = tmp;
8                 i--;
9             }
10         }
11         for (int j = 0; j < nums.length; j++) {
12             if (nums[j] - 1 != j) return j + 1;
13         }
14         return nums.length + 1;
15     }
16 }

Meng Lee 2013-12-28 15:31 发表评论

[待字闺中] interleave字符串分析

Meng Lee — Sat, 28 Dec 2013 06:29:00 GMT

3个字符串a，b，c。判断c是否是a和b的interleave，也就是c中应该有a，b中所有字符，并且c中字符顺序和a，b中一样。比如，
1. a = "ef" b = "gh" c = "egfh" return true
2. a = "ef" b = "gh" c = "ehgf" return false

分析：
这个题目中，并没有说明a和b中是否有相同的字符，这个直接影响了最终的解法。所以，大家在面试的过程中，要和面试官进行交互，弄清楚之后再动手。a和b中不含有相同字符的情况很简单，这里略去。下面给出a和b中包含相同字符的动态规划的解法。

1 public class Solution {
2     public boolean isInterleaved(String a, String b, String c) {
3         int lengthA = a.length();
4         int lengthB = b.length();
5         int lengthC = c.length();
6         if (lengthA + lengthB != lengthC)
7             return false;
8         boolean[][] map = new boolean[lengthB + 1][lengthA + 1];
9         map[0][0] = true;
10         for (int m = 1; m < lengthA; m++) {
11             map[0][m] = (a.charAt(m - 1) == c.charAt(m - 1) && map[0][m - 1]);
12         }
13         for (int n = 1; n < lengthB; n++) {
14             map[n][0] = (b.charAt(n - 1) == c.charAt(n - 1) && map[n - 1][0]);
15         }
16         for (int i = 1; i <= lengthB; i++) {
17             for (int j = 1; j <= lengthA; j++) {
18                 map[i][j] = (c.charAt(i + j - 1) == b.charAt(i - 1) && map[i - 1][j])
19                         || (c.charAt(i + j - 1) == a.charAt(j - 1) && map[i][j - 1]);
20             }
21         }
22         return map[lengthB][lengthA];
23     }
24 }

Meng Lee 2013-12-28 14:29 发表评论

[待字闺中] 删除字符

Meng Lee — Sat, 28 Dec 2013 03:02:00 GMT

删除字符串中的“b”和“ac”，需要满足如下的条件：
1. 字符串只能遍历一次
2. 不能够实用额外的空间

例如：
1. acbac   ==> ""
2. aaac    ==> aa
3. ababac ==>   aa
4. bbbbd   ==>   d
5. aaccac ==> ""

1 public class Solution {
2     public String deleteChars(String s) {
3         StringBuffer sb = new StringBuffer(s);
4         int fast = 0, slow = -1;
5         int length = s.length();
6         while (fast < length) {
7             if (sb.charAt(fast) == 'b') {
8                 fast++;
9             } else if (fast < length - 1 && sb.charAt(fast) == 'a' && sb.charAt(fast + 1) == 'c') {
10                 fast += 2;
11             } else {
12                 sb.setCharAt(++slow, sb.charAt(fast++));
13                 if (slow > 0 && sb.charAt(slow - 1) == 'a' && sb.charAt(slow) == 'c') {
14                     slow -= 2;
15                 }
16             }
17         }
18         return sb.substring(0, slow + 1);
19     }
20 }

Meng Lee 2013-12-28 11:02 发表评论

[待字闺中] 回文分割

Meng Lee — Fri, 27 Dec 2013 08:06:00 GMT

对一个字符串按照回文进行分割，例如aba|b|bbabb|a|b|aba就是字符串ababbbabbababa的一个回文分割，每一个字串都是一个回文。请找到可以分割的最少的字串数。例如：

1. ababbbabbababa最少4个字符串，分割三次：a|babbbab|b|ababa

2. 如果字符串整体是回文，则需要0次分割，最少1个字符串

分析：
递归方程为：f(i) = MIN(f(j - 1) + 1), map[j][i] == true, 0<=j

1 public class Solution {
2     public int minPalindromePartition(String s) {
3         int length = s.length();
4         boolean[][] map = new boolean[length][length];
5         int[] record = new int[length];
6         for (int k = 0; k < length; k++) {
7             record[k] = k;
8         }
9         for (int offset = 0; offset < length; offset++) {
10             for (int i = 0, j = i + offset; i < length - offset; i++, j++) {
11                 if (i == j || (s.charAt(i) == s.charAt(j) && (j - i == 1 || map[i + 1][j - 1]))) {
12                     map[i][j] = true;
13                 }
14             }
15         }
16         for (int i = 1; i < length; i++) {
17             for (int j = 0; j < i; j++) {
18                 if (map[j][i]) {
19                     if (j > 0) {
20                         record[i] = Math.min(record[i], record[j - 1] + 1);
21                     } else {
22                         record[i] = 0;
23                     }
24                 }
25             }
26         }
27         return record[length - 1];
28     }
29 }

Meng Lee 2013-12-27 16:06 发表评论

[待字闺中] 求二叉搜索树的中序后继节点

Meng Lee — Fri, 27 Dec 2013 03:06:00 GMT

求二叉搜索树的中序后继节点

分析：
1. 如果目标节点的右子树不为空，则返回右子树的最小节点；
2. 如果目标节点的右子树为空，则从根节点开始遍历。
实现代码如下：

1 public class Solution {
2     public TreeNode inOrderSuccessor(TreeNode root, TreeNode target) {
3         if (target == null) return null;
4         if (target.right != null) return minValue(target.right);
5         TreeNode succ = null;
6         while (root != null) {
7             if (target.val < root.val) {
8                 succ = root;
9                 root = root.left;
10             } else if (target.val > root.val) {
11                 root = root.right;
12             } else {
13                 break;
14             }
15         }
16         return succ;
17     }
18
19     private TreeNode minValue(TreeNode root) {
20         while (root.left != null) {
21             root = root.left;
22         }
23         return root;
24     }
25 }

Meng Lee 2013-12-27 11:06 发表评论

[待字闺中] 最少插入字符

Meng Lee — Thu, 26 Dec 2013 08:53:00 GMT

最少插入字符

给定字符串，可以通过插入字符，使其变为回文。求最少插入字符的数量。例如：

1. ab最少插入1个字符，变为bab

2. aa最少插入0个字符

3. abcd最少插入3个字符，dcbabcd

分析

这个题目的分析思路，和前面两期是非常相似的：给出递归的解法，发现重复的子问题，改进为动态规划的解法，这是一个分析的过程，待同学们比较熟悉时候，可以直接给出动态规划的解决方案，就很好了。

这个题目，递归该如何解呢？给定一个字符串str，长度为n，怎么插入最少的字符，是的字符串变为回文呢？插入最少的字符，就是要尽量利用原来的字符，在原字符串str中，尽量利用更多能够匹配的字符。怎么对这个问题进行分解呢？考虑str字符串整体：

1. 如果str[0]==str[n-1]，则问题转变为求str[1,n-2]，插入最少字符，得到回文

2. 如果str[0]!=str[n-1]，则需要插入一个字符要么和str[0]相同，要么和str[n-1]相同，

3. 如果和str[0]，则转变为str[1,n-1]，插入最少字符，得到回文

4. 如果和str[n-1]，则转变为str[0,n-2]，插入最少字符，得到回文

上面的第2种情况中，需要取两个值最小值。则完成了问题的分解，并且，基本情况也分析完全，则有递归式为：

fmi(str, l, h) = (str[l] == str[h]) ? fmi(str, l+1, h-1) : (min(fmi(str, i+1, h), fmi(str,l, h-1))+1)

通过上面的式子，有经验的、熟练的同学，很直接的就能看出来，存在重复的子问题，这就意味着，我们可以讲子问题的解缓存使用。如果，没有直接能够看出来的同学们，还是可以按照我们之前的方法，把递归树画出来吧，那样更加一目了然。

那么，这个题目该如何用动态规划的解决呢？如何重复利用子问题的解呢？似乎有些不那么直接。但其实也是于规律可循的。上面的递归式，是从字符串的两边，想中间移动递归，根据动态规划解决问题的思想，我们先解决子问题，再重复利用子问题，就是要从内向外解决，大家还记得回文子串判断的那个题目么，动态规划解法的外层循环是子串的长度，这个题目也是类似的。示例代码如下：

1 public class Solution {
2     public int constructPalindrome(String s) {
3         int length = s.length();
4         int[][] map = new int[length][length];
5         for (int offset = 1; offset < length; offset++) {
6             for (int i = 0, j = offset; i < length - offset; i++, j++) {
7                 if (i == j - 1) {
8                     if (s.charAt(i) != s.charAt(j)) {
9                         map[i][j] = 1;
10                     }
11                 } else {
12                     if (s.charAt(i) != s.charAt(j)) {
13                         map[i][j] = Math.min(map[i][j - 1], map[i + 1][j]) + 1;
14                     } else {
15                         map[i][j] = map[i + 1][j - 1];
16                     }
17                 }
18             }
19         }
20         return map[0][length - 1];
21     }
22 }

Meng Lee 2013-12-26 16:53 发表评论