lintcode做题总结, Oct 07

1. Scramble String 这道题代码没几行但是用了三维DP还是很复杂的，用[i][j][k]代表从s1.charAt(i)和s2.charAt(j)开始的k的字符的字符串是不是scramble，由于字符变换是基于交换的，所以只要找到那个分界线然后交换判断既可以。

public class Solution {
    public boolean isScramble(String s1, String s2) {  
        if(s1==null || s2==null || s1.length()!=s2.length())  
            return false;  
        if(s1.length()==0)  
            return true;  
        boolean[][][] res = new boolean[s1.length()][s2.length()][s1.length()+1];  
        for(int i=0;i<s1.length();i++) {  
            for(int j=0;j<s2.length();j++) {  
                res[i][j][1] = s1.charAt(i)==s2.charAt(j);  
            }  
        }  
        for(int len=2;len<=s1.length();len++) {  
            for(int i=0;i<s1.length()-len+1;i++) {  
                for(int j=0;j<s2.length()-len+1;j++) {  
                    for(int k=1;k<len;k++) {  
                        res[i][j][len] |= (
                            // for abc, abc
                            res[i][j][k]&&res[i+k][j+k][len-k] 
                            // for a|bc, cb|a
                            || res[i][j+len-k][k]&&res[i+k][j][len-k]);  
                    }  
                }  
            }  
        }  
        return res[0][0][s1.length()];
    }
}

2. Text Justification 这道题思路并不复杂但是写起来很繁琐，用每行的总空格数除以word间的间隔数就可以找到平均值，然后把余数一次放入各个间隔即可。

public class Solution {
    public List<String> fullJustify(String[] words, int L) {
        List<String> ans = new ArrayList<String>();
        int n = words.length;
        int i = 0;
        while (i < n) {
            int len = words[i].length();
            int j = i + 1;
            while (j < n && len + 1 + words[j].length() <= L) {
                len += 1 + words[j].length();
                j++;
            }
            
            String line = words[i];
            if (j == n) { // if this is the last line
                for (int k = i + 1; k < n; k++) {
                    line += " " + words[k];
                }
                while (line.length() < L) {
                	line += " ";
                }
            } else {
                int extraWhite = L - len;
                int whiteNum = j - i - 1;
                if (whiteNum == 0) { // if this line has only one word
                	while (line.length() < L) {
                    	line += " ";
                    }
                } else {
	                for (int k = i + 1; k < j; k++) {
	                    line += " ";
	                    for (int p = 0; p < extraWhite/whiteNum; p++) {
	                        line += " ";
	                    }
	                    if (k - i <= extraWhite%whiteNum) {
	                        line += " ";
	                    }
	                    line += words[k];
	                }
                }
            }
            ans.add(line);
            i = j;
        }
        return ans;
    }
}

3. Trapping Rain Water这道题思路非常巧妙，只需要从左向右保存当时的最大值再从右向左扫一遍，然后去min就是装满水后的总体积，这是在减去原来的就是水的体积。

public class Solution {
    public int trap(int[] height) {
        if (height == null || height.length <= 2){
            return 0;
        }
        int[] left = new int[height.length];
        int[] right = new int[height.length];
        
        int max = height[0];
        for (int i = 0; i < height.length; i++){
            if (height[i] < max){
                left[i] = max;
            } else {
                left[i] = height[i];
                max = height[i];
            }
        }
        max = height[height.length - 1];
        for (int i = height.length - 1; i >= 0; i--){
            if (height[i] < max){
                right[i] = max;
            } else {
                right[i] = height[i];
                max = height[i];
            }
        }
        int res = 0;
        for (int i = 0; i < height.length; i++){
            res += Math.min(left[i], right[i]) - height[i];
        }
        return res;
    }
}

4.Recover Binary Search Tree 这道题的主要考察点是BST的中序历遍输出是有序的。但是交换可能有两种情况，一种是不在同一位置，这样找到两个逆序即可，还有一种是交换在同一位置，这样就只有一次逆序

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public void recoverTree(TreeNode root) {
        if (root == null)
            return;
        // BST inorder. ele in order list is from large to small 5->4->3->2
        LinkedList<TreeNode> order = new LinkedList<TreeNode>();
        ArrayList<TreeNode> swap = new ArrayList<TreeNode>();
        helper(root, order, swap);
        if (swap.size() == 2){
            int tmp = swap.get(0).val;
            swap.get(0).val = swap.get(1).val;
            swap.get(1).val = tmp;
        } else if (swap.size() == 3){
            int tmp = swap.get(0).val;
            swap.get(0).val = swap.get(2).val;
            swap.get(2).val = tmp;
        }
    }
    public void helper(TreeNode root, LinkedList<TreeNode> order, ArrayList<TreeNode> swap){
        //if having already found the 2 elements with wrong order.
        if (root == null || swap.size() == 3)
            return;
        helper(root.left, order, swap);
        if (order.size() != 0 && order.get(0).val > root.val){
            //cases like 1,2,3,5,4,6,7
            if (swap.size() == 0){
                swap.add(order.get(0));
                swap.add(root);
            //cases like 1,2,6,4,5,3,7
            } else {
                swap.add(root);
                return;
            }
        }
        order.addFirst(root);
        helper(root.right, order, swap);
    }
}

5. Binary Tree Maximum Path Sum 这道题思路也不复杂，只要使用递归，然后针对每一个节点，更新max

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int maxPathSum(TreeNode root) {
        if (root == null)
            return 0;
    	int max[] = new int[1]; 
    	max[0] = root.val;
    	visit(root, max);
    	return max[0];
    }
 
    public int visit(TreeNode root, int[] max) {
    	if (root == null)
    		return 0;
     
    	int left = visit(root.left, max);
    	int right = visit(root.right, max);
     
    	int curr = Math.max(root.val, Math.max(root.val + left, root.val + right));
     
    	max[0] = Math.max(max[0], Math.max(curr, left + root.val + right));
     
    	return curr;
    }
}

6. Distinct Subsequences 这道题有点类似于找最长子序列，只是换成了所有子序列的数量，用的是DP（二维优化成一维）

public class Solution {
    public int numDistinct(String s, String t) {
        int[] res = new int[t.length()];
        for (int i = 0; i < s.length(); i++){
            for (int j = t.length() - 1; j >= 0; j--){
                if (s.charAt(i) == t.charAt(j)) {
                    res[j] += j==0?1:res[j-1];
                }
            }
        }
        return res[t.length()-1];
    }
}