【hihoCoder】基站选址

时间限制: 2000ms

单点时限: 1000ms

内存限制: 256MB

描述

需要在一个N × M的网格中建立一个通讯基站，通讯基站仅必须建立在格点上。

网格中有A个用户，每个用户的通讯代价是用户到基站欧几里得距离的平方。

网格中还有B个通讯公司，维护基站的代价是基站到最近的一个通讯公司的路程（路程定义为曼哈顿距离）。

在网格中建立基站的总代价是用户通讯代价的总和加上维护基站的代价，最小总代价。

输入

第一行为一个整数T，表示数据组数。

每组数据第一行为四个整数：N, M, A, B。

接下来的A+B行每行两个整数x, y，代表一个坐标，前A行表示各用户的坐标，后B行表示各通讯公司的坐标。

输出

对于每组数据输出一行"Case #X: Y"，X代表数据编号（从1开始），Y代表所求最小代价。

数据范围

1 ≤ T ≤ 20

1 ≤ x ≤ N

1 ≤ y ≤ M

1 ≤ B ≤ 100

小数据

1 ≤ N, M ≤ 100

1 ≤ A ≤ 100

大数据

1 ≤ N, M ≤ 107

1 ≤ A ≤ 1000

样例输入

2
3 3 4 1
1 2
2 1
2 3
3 2
2 2
4 4 4 2
1 2
2 4
3 1
4 3
1 4
1 3

样例输出

Case #1: 4
Case #2: 13

【解析】

直观想法就是暴力遍历，但这样必然会超时。其实不用遍历每一个格子，距离所有用户总和最小的必然是除于所有用户中心位置的，所以只需要判断( (x1+x2+...+xn)/n, (y1+y2+...+yn)/n ), ( (x1+x2+...+xn)/n + 1, (y1+y2+...+yn)/n ), ( (x1+x2+...+xn)/n, (y1+y2+...+yn)/n + 1 ), ( (x1+x2+...+xn)/n + 1, (y1+y2+...+yn)/n + 1 ) 这四个点哪个距离所有用户总和最小就OK了。至于通讯公司，因为只要找到最近的一个而非到所有通讯公司的距离总和，并且是曼哈顿距离而非欧氏距离，所以影响因素较小。

【Java代码】

import java.util.Scanner;
	
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int T = in.nextInt();
        
        for (int t = 1; t <= T; t++) {
        	int N = in.nextInt();
        	int M = in.nextInt();
        	int A = in.nextInt();
        	int B = in.nextInt();
        	
        	int[][] a = new int[A][2];
        	int[][] b = new int[B][2];
        	
        	int rowSum = 0;
        	int colSum = 0;
        	
        	for (int i = 0; i < A; i++) {
        		a[i][0] = in.nextInt();
        		a[i][1] = in.nextInt();
        		rowSum += a[i][0];
        		colSum += a[i][1];
        	}
        	
        	for (int i = 0; i < B; i++) {
        		b[i][0] = in.nextInt();
        		b[i][1] = in.nextInt();
        	}
        	
        	int minCost = Integer.MAX_VALUE;
        	int fromRow = rowSum / A;
        	int fromCol = colSum / A;
        	for (int i = fromRow; i <= fromRow + 1; i++) {
        		for (int j = fromCol; j <= fromCol + 1; j++) {
        			int cost = 0;
        			for (int k = 0; k < A; k++) {
        				cost += (i - a[k][0]) * (i - a[k][0]) + (j - a[k][1]) * (j - a[k][1]);
        			}
        			
        			int costB = Integer.MAX_VALUE;
        			for (int k = 0; k < B; k++) {
        				int tmp = Math.abs(i - b[k][0]) + Math.abs(j - b[k][1]);
        				costB = Math.min(costB, tmp);
        			}
        			
        			cost += costB;
        			minCost = Math.min(minCost, cost);
        		}
        	}
        	
        	System.out.println("Case #" + t + ": " + minCost);
        }
    }
}

免责声明：题目来源于hihoCoder.com，如有侵权，请联系博主删帖。