[LeetCode] Heaters 加热器

Winter is coming! Your first job during the contest is to design a standard heater with fixed warm radius to warm all the houses.

Now, you are given positions of houses and heaters on a horizontal line, find out minimum radius of heaters so that all houses could be covered by those heaters.

So, your input will be the positions of houses and heaters seperately, and your expected output will be the minimum radius standard of heaters.

Note:

1. Numbers of houses and heaters you are given are non-negative and will not exceed 25000.
2. Positions of houses and heaters you are given are non-negative and will not exceed 10^9.
3. As long as a house is in the heaters' warm radius range, it can be warmed.
4. All the heaters follow your radius standard and the warm radius will the same.

 

Example 1:

Input: [1,2,3],[2]
Output: 1
Explanation: The only heater was placed in the position 2, and if we use the radius 1 standard, then all the houses can be warmed.

 

Example 2:

Input: [1,2,3,4],[1,4]
Output: 1
Explanation: The two heater was placed in the position 1 and 4. We need to use radius 1 standard, then all the houses can be warmed.

 

这道题是一道蛮有意思的题目，首先我们看题目中的例子，不管是houses还是heaters数组都是有序的，所以我们也需要给输入的这两个数组先排序，以免其为乱序。我们就拿第二个例子来分析，我们的目标是houses中的每一个数字都要被cover到，那么我们就遍历houses数组，对每一个数组的数字，我们在heaters中找能包含这个数字的左右范围，然后看离左右两边谁近取谁的值，如果某个house位置比heaters中最小的数字还小，那么肯定要用最小的heater去cover，反之如果比最大的数字还大，就用最大的数字去cover。对于每个数字算出的半径，我们要取其中最大的值。通过上面的分析，我们就不难写出代码了，我们在heater中两个数一组进行检查，如果后面一个数和当前house位置差的绝对值小于等于前面一个数和当前house位置差的绝对值，那么我们继续遍历下一个位置的数。跳出循环的条件是遍历到heater中最后一个数，或者上面的小于等于不成立，此时heater中的值和当前house位置的差的绝对值就是能cover当前house的最小半径，我们更新结果res即可，参见代码如下：

 

解法一：

public static void main(String[] args) {
		int  is = findRadius(new int[]{1,2,3,4}, new int[]{1,4});
		System.out.println(is);

	}
	static  int findRadius(int[] houses, int[] heaters) {
	        int n = heaters.length, j = 0, res = 0;
	        Arrays.sort(houses);
	        Arrays.sort(heaters);
 
	        for (int i = 0; i < houses.length; ++i) {
	            int cur = houses[i];
	            while (j < n - 1 && Math.abs(heaters[j + 1] - cur) <= Math.abs(heaters[j] - cur)) {
	                ++j;
	            }
	            res = Math.max(res, Math.abs(heaters[j] - cur));
	        }
	        return res;
	    }

 

第二类： 查找第一个不小于目标值的数，可变形为查找最后一个小于目标值的数

这是比较常见的一类，因为我们要查找的目标值不一定会在数组中出现，也有可能是跟目标值相等的数在数组中并不唯一，而是有多个，那么这种情况下nums[mid] == target这条判断语句就没有必要存在。比如在数组[2, 4, 5, 6, 9]中查找数字3，就会返回数字4的位置；在数组[0, 1, 1, 1, 1]中查找数字1，就会返回第一个数字1的位置。我们可以使用如下代码：

static int binarySearch(int[] nums, int target) {
		int left = 0, right = nums.length - 1;
		while (left <= right) {
		  int mid = (right + left) / 2;
			
		  if (nums[mid] < target)
				left = mid + 1;
			else
				right = mid - 1;
		}
		return left;
	}

还是上面的思路，我们可以用二分查找法来快速找到第一个大于等于当前house位置的数，如果这个数存在，那么我们可以算出其和house的差值，并且如果这个数不是heater的首数字，我们可以算出house和前面一个数的差值，这两个数中取较小的为cover当前house的最小半径，然后我们每次更新结果res即可，参见代码如下：

 

解法二：

public static void main(String[] args) {
		  int is = findRadius(new int[] { 1, 2, 3 }, new int[] { 5 });
		System.out.println(is); 
	}

	 static int findRadius(int[] houses, int[] heaters) {
		int n = heaters.length, res = 0;

		Arrays.sort(heaters);

		for (int i = 0; i < houses.length; ++i) {
			int index = binarySearch(heaters, houses[i]);
			 
			int dist1 = (index == n) ? Integer.MAX_VALUE : heaters[index] - houses[i];
			int dist2 = (index == 0) ? Integer.MAX_VALUE : houses[i] - heaters[index - 1];
			res = Math.max(res, Math.min(dist1, dist2));
		}
		return res;
	} 
		static int binarySearch(int[] nums, int target) {
			int left = 0, right = nums.length - 1;
			while (left <= right) {
			  int mid = (right + left) / 2;
				
			  if (nums[mid] < target)
					left = mid + 1;
				else
					right = mid - 1;
			}
			return left;
		}