欲說還休https://blog.terryx.com/tags/algorithm/TerryX's BlogHugo 0.161.1zh-cnTerryXWed, 21 Mar 2018 00:00:00 +0000Search Problems in Interviewhttps://blog.terryx.com/posts/search-interview/Fri, 02 Mar 2018 00:00:00 +0000https://blog.terryx.com/posts/search-interview/<p>暂时不想写</p> K-th Problems in Interviewhttps://blog.terryx.com/posts/kth-interview/Thu, 01 Mar 2018 00:00:00 +0000https://blog.terryx.com/posts/kth-interview/K-th问题是说在给定数据集中，找到排名第k个的数据。通常这个数据集极大是没办法存在内存中，或者遍历一遍数据集的时间代价很高。通常解决这种方法是维护一个k大小的最大堆，这样我们可以一直维护top k个数据。这种方法比较常见且简单，这里我想说得是一般这种K-th类问题是可以通过Binary Search解决。

二分查找，是非常简单的算法。但是这种算法应用非常灵活，首先想一次性写对二分查找并不是一件容易的事情。这里我想简单总结一下二分查找的使用背景。众所周知，最最常见应用二分查找的地方就是对于一个已经排好序的数组中，找到一个我们已知的值的位置。这个问题背后隐藏着什么呢？记得我在初次学习二分查找的时候，看到有人总结说二分查找的应用条件就是这个问题是否可以证明是“单调的”。对于数组查找中，我们可以简化问题为一个函数f，f(index)就是对于查找index的值是否大于等于目标值，这样我们就发现函数f在定义域[0, n)是满足单调性质的，因为必然有个界限让小于的f为false，大于等于的时候是true（当然这个界限也有可能不存在，就是我们没有找到这个值的时候）。再举个例子，我们想找到实数取决一个满足f(x)=y的值，也可以对整个实数区域进行二分，然后求解x，就像解方程一样。

说完了背景，再说说写法。首先是整数的写法：

因为整数的二分会自动去掉小数部分，这就会遇到一个头疼的问题，如果当low = k, high = k + 1 这时候我们做二分，中间值永远是k。如果我们写的代码是while (low < high) {if (f(mid)) { low = mid; } else { high = mid - 1; }} 且这个时候f(mid)为true，那么我们永远也无法跳出这个循环。解决这个问题有两种思路：1. 因为我们停止的条件是low == high所以不妨把循环条件设置为 while (low + 1 < high) 但是这又会引起一个问题，我们需要在最后再double check一下low和high我们需要的答案是什么。 2. 也可以把二分的结果向上取整 mid = (low + high + 1) / 2 这样在遇到这种情况是我们总会选择high。所以在写完二分解法后最好想一下，两个答案的时候程序能不能成功运行出结果。第二个是值域分布的问题，有可能我们的判断函数f(x)永远都是false，这样的结果是我们最后的二分结果也是错的。

下面是实数二分的写法：

这里就不会遇到那个头疼问题，我们只要保证精度就可以了 while (left < high && Math.abs(left - high) < 1e-5) 但是我不喜欢这么写，会因为精度的问题陷入死循环。我们单纯循环100次就可以把精度控制在小数点后30位。

这里说一下为什么K-th问题都可以借用二分查找解决。因为K-th问题必然是单调性的，因为我们有函数f(x)=k表示x在数据集中的排序为k，那么比x大的数字，f(x)就会变大，反之亦然，单调性很容易证明。所以我们只要在合理的时间计算出x的排序，就可以二分查找出排序为k的数值。下面我们来看几道题：

Find K-th Smallest Pair Distance 给了一个数组，让找出两两pair中相差值为k-th小的值。我们可以对数组排序，然后二分这个相差值。然后根据这个值找出有多少个pair比这个值小。这里注意并不是如果比这个值小的元素有k-1个就证明了就是答案，因为我们不知道这个相差值是否真的存在。所以我们要找到答案为k-1且这个值最小的那个。因为这个值是处于一个分界点，比这个值小排序的序号就减少1，就说明了这个差值是存在的。这里我们用sliding window来找到多少个差值比target要小。

public int smallestDistancePair(int[] nums, int k) {
	Arrays.sort(nums);
	int low = 0, high = Integer.MAX_VALUE;
	while (low < high) {
		int mid = (low + high) / 2;
		int begin = 0, end = 0, cnt = 0;
		for (; end < nums.length; ++ end) {
			while (begin < nums.length && nums[end] - nums[begin] > mid) {
				begin++;
			}
			cnt += (end - begin);
		}
		if (cnt >= k) {
			high = mid;
		} else {
			low = mid + 1;
		}
	}
	return low;
}

K-th Smallest Prime Fraction 给一个排序好的素数数组，对于 p < q find p / q 找出所有值中第k小的。同样，这里我们对实数值域进行二分，找到多少个分数比当前值小，同样找到这些满足条件中的最小值。我们也可以通过比较巧妙的线性方法的找出所有满足小于查找值的分数个数。

public int[] kthSmallestPrimeFraction(int[] A, int K) {
	int n = A.length;
	double low = (double)A[0]/A[n - 1];
	double high = (double)A[n - 1]/A[0];
	Set<Integer> set = new HashSet<>();
	for (int a : A) set.add(a);
	for (int itr = 0; itr < 100; ++itr) {
		double mid = (low + high) * 0.5;
		int i = 0, j = 0, cnt = 0;
		for (; i < n; ++ i) {
			for (; j < n; ++ j) {
				if (i < j && A[i] < mid * A[j]) {
					cnt += (n - j);
					break;
				}
			}
		}
		if (cnt < K) {
			low = mid;
		} else {
			high = mid;
		}
	}
	for (int a : A) {
		double p = Math.round(low * (double)a);
		if (Math.abs(p - low * (double)a) < 1e-5 && set.contains((int)p)) {
			return new int[]{(int)p, a};
		}
	}
	return null;
}

Kth Smallest Element in a Sorted Matrix 给一个行和列都排序的矩阵，找到其中第k小的。我们二分来查找这个值，然后通过每行进行二分查找来统计多少个值比这个数要小。

public int kthSmallest(int[][] matrix, int k) {
	int n = matrix.length;
	int low = matrix[0][0], high = matrix[n - 1][n - 1];
	while (low < high) {
		int mid = (low + high) / 2;
		int count = 0;
		for (int i = 0; i < n; ++ i) {
			int l = 0, h = n - 1;
			while (l < h) {
				int m = (l + h + 1) / 2;
				if (matrix[i][m] <= mid) {
					l = m;
				} else {
					h = m - 1;
				}
			}
			if (matrix[i][l] <= mid) {
				count += l + 1;
			}
		}
		if (count < k) {
			low = mid + 1;
		} else {
			high = mid;
		}
	}
	return low;
}

Kth Smallest Number in Multiplication Table 和上道题类似，每行换成了等比数列。免去了进行二分查找统计，直接算除法就可以统计数量。

public int findKthNumber(int m, int n, int k) {
	int low = 1, high = m * n;
	while (low < high) {
		int mid = (low + high) >>> 1;
		int count = 0;
		for (int i = 1; i <= m; ++ i) {
			count += Math.min(n, mid / i);
		}
		if (count < k) {
			low = mid + 1;
		} else {
			high = mid;
		}
	}
	return low;
}
]]>Binary Search Tree in Interviewhttps://blog.terryx.com/posts/bst/Sun, 25 Feb 2018 00:00:00 +0000https://blog.terryx.com/posts/bst/Binary Search Tree (简称BST) 是最简单的搜索树，很多高级树用法都是以它为基础。因为设计它的算法很多都很巧妙，记得在面试的时候突然遇到一道BST的题卡住了。由于BST的结构特殊，所以有关它的题目都很灵活，想借此机会总结一下。

递归与递推

众所周知，BST是天生具有递归特性的，因为的BST的任一子树都是BST。所以很多题目都是利用这一性质。比如将BST有序打印出来就可以使用inorder遍历：

public void recursive(TreeNode root) {
    if (root == null) return;
    recursive(root.left);
        /*
        Do something...
        */
    recursive(root.right);
}

当然也可以通过栈来改写为递推，这里是将未处理的结点存入栈中。这里需要介绍一种pushAll操作。就是将该结点的所有左结点全部压入栈。然后每次取出结点后对右结点进行pushAll操作。Binary Tree Inorder Traversal：

public List<Integer> inorderTraversal(TreeNode root) {
	List<Integer> ans = new ArrayList<>();
	Stack<TreeNode> stack = new Stack<>();
	while(root != null) {
		stack.push(root);
		root = root.left;
	}
	while (!stack.isEmpty()) {
		TreeNode cur = stack.pop();
		ans.add(cur.val);
		cur = cur.right;
		while (cur != null) {
			stack.push(cur);
			cur = cur.left;
		}
	}
	return ans;
}

了解到这个特性后，我们就可以将BST改写成Iterator - next()取出下一个最小值，hasNext()是否存在结点。Binary Search Tree Iterator：

public class BSTIterator {
    private Deque<TreeNode> stack;

    public BSTIterator(TreeNode root) {
        stack = new ArrayDeque<>();
        pushAll(root);
    }

    /** @return whether we have a next smallest number */
    public boolean hasNext() {
        return !stack.isEmpty();
    }

    /** @return the next smallest number */
    public int next() {
        TreeNode cur = stack.pop();
        pushAll(cur.right);
        return cur.val;
    }

    private void pushAll(TreeNode root) {
        while (root != null) {
            stack.push(root);
            root = root.left;
        }
    }
}

在Java的Iterator是也可以支持remove()操作 - 删除上一个访问的结点。BST删除结点的操作也可以用递归算法来解决（当然也可用平衡二叉树删除结点进行分类的解法，但是递归的解法更加巧妙）。首先我们找到被删除的结点，然后把它替换成其右子树的最小值m（目的是为了保证删除后的右子树满足比当前结点大）。然后我们再递归删除右子树的m结点。Delete Node in a BST：

public TreeNode deleteNode(TreeNode root, int key) {
	if (root == null) {
		return null;
	}
	if (key < root.val) {
		root.left = deleteNode(root.left, key);
	}  else if (key > root.val) {
		root.right = deleteNode(root.right, key);
	} else {
		if (root.left == null) {
			return root.right;
		} else if (root.right == null) {
			return root.left;
		} else {
			TreeNode min = findMin(root.right);
			// copy
			root.val = min.val;
			root.right = deleteNode(root.right, min.val);
		}
	}
	return root;
}

private TreeNode findMin(TreeNode root) {
	TreeNode cur = root;
	while (cur.left != null) {
		cur = cur.left;
	}
	return cur;
}

查找

上文中我们知道BST是可以有序输出的，所以很多针对有序数据的算法都可以套在BST上。比如，二分查找，第k大问题，等等。

如果查找的结点存在于BST上，我们很容易可以将它找出。但是如果需要查找的结点不存在与树上，我们希望返回最接近的结点，这种问题该如何解决呢？首先我们要想一个问题，对于一个在BST上的结点，比它大的值可能存在于哪里？应该是存在于这个结点的右子树或父结点（如果存在）的右子树。但是这么思考的问题是我们需要跟踪父结点的情况，这个如果不借助其他数据结构存储很难实现。我们不如换一种思路：当访问到结点时，如果值大于target就找保存左子树的最接近target的值，然后取这两个值最接近target的一个；反之就从右子树来找。同样借助递归的特性我们可以解决这个问题。Closest Binary Search Tree Value

public int closestValue(TreeNode root, double target) {
	if (root == null) {
		return -1;
	}
	if (Math.abs((double)root.val - target) < 1e-6) {
		return root.val;
	}
	if ((double)root.val < target && root.right != null) {
		int r = closestValue(root.right, target);
		if (Math.abs(target - (double)r) < Math.abs(target - (double)root.val)) {
			return r;
		}
		return root.val;
	} else if ((double)root.val > target && root.left != null) {
		int r = closestValue(root.left, target);
		if (Math.abs(target - (double)r) < Math.abs(target - (double)root.val)) {
			return r;
		}
		return root.val;
	}
	return root.val;
}

借用这种想法，我们还可以解决类似的问题。比如将BST分成两个BST，一个所有的值小于等于target，另一个大于target。对于当前结点如果小于等于target，其左边子树都是小于等于target，所以将右子树分成的结果的第一部分连接到当前结点的右边；如果大于target，说明右子树都是大于target，需要将左子树的结果的第二部分连入左边。Split BST：

public TreeNode[] splitBST(TreeNode root, int V) {
	if (root == null) {
		return new TreeNode[]{null, null};
	}
	TreeNode[] res;
	if (root.val <= V) {
		res = splitBST(root.right, V);
		root.right = res[0];
		res[0] = root;
	} else {
		res = splitBST(root.left, V);
		root.left = res[1];
		res[1] = root;
	}
	return res;
}

对于第k大的问题，可以通过inorder遍历来解决。Kth Smallest Element in a BST：

int count = 0;
public int kthSmallest(TreeNode root, int k) {
	return solve(root, k);
}

private int solve(TreeNode root, int k) {
	if (root == null) {
		return -1;
	}
	int r = solve(root.left, k);
	if (r != -1) return r;
	count++;
	if (count == k) {
		return root.val;
	}
	r = solve(root.right, k);
	return r;
}

另一种变形是，在BST找到接近target的k个数。这个可以通过inorder来找到，但是这里介绍一种高效的方法借助额外的数据结构来解决。通过栈来存储比target小的结点，另一个栈存储大于等于target的结点。然后用类似two pointer的方法找到接近target的k个数。Closest Binary Search Tree Value II：

public List<Integer> closestKValues(TreeNode root, double target, int k) {
	Deque<TreeNode> greater = new ArrayDeque<>(), less = new ArrayDeque<>();
	TreeNode cur = root;
	while (cur != null) {
		if (cur.val < target) {
			less.push(cur);
			cur = cur.right;
		} else {
			greater.push(cur);
			cur = cur.left;
		}
	}
	List<Integer> list = new ArrayList<>();
	while (k > 0) {
		if (greater.isEmpty() && less.isEmpty()) {
			break;
		} else if (greater.isEmpty()) {
			list.add(lessNext(less));
		} else if (less.isEmpty()) {
			list.add(greaterNext(greater));
		} else if (Math.abs(less.peek().val - target) < Math.abs(greater.peek().val - target)) {
			list.add(lessNext(less));
		} else {
			list.add(greaterNext(greater));
		}
		k--;
	}
	return list;
}

private int lessNext(Deque<TreeNode> stack) {
	TreeNode top = stack.pop();
	int r = top.val;
	top = top.left;
	while (top != null) {
		stack.push(top);
		top = top.right;
	}
	return r;
}

private int greaterNext(Deque<TreeNode> stack) {
	TreeNode top = stack.pop();
	int r = top.val;
	top = top.right;
	while (top != null) {
		stack.push(top);
		top = top.left;
	}
	return r;
}
]]>