Google题解

Kickstart2017 RoundB

B.题意: 二维平面上有n个点, 每个点坐标(xi, yi), 权值wi, 问: 在平面上找一点p, 使得 Σwi*max(|X-xi|, |Y-yi|)最小, (X, Y)为p点坐标。求该最小值。

二维空间：

欧几里得距离：d=√(|x1-x2|²+|y1-y2|²)

曼哈顿距离 ：d=|x1-x2|+|y1-y2|，到某点的曼哈顿距离为r的点组成一个边长为√2*r的正方形，且边与坐标轴成45度

切比雪夫距离：d=max(|x1-x2|,|y1-y2|)，到某点的切比雪夫距离为r的点组成一个边长为2*r的正方形，且边与坐标轴平行

 /*
 题解: 赛后看到有不少随机化算法可乱搞过去
 该题是二维平面邮局距离(参见《算法导论》)的变形
 
 simple版：一维下, 使得Σwi*|X-xi|最小, 其中所有wi = 1. 答案显然为xi的中位数
 middle版：我们可以将wi看成有wi个点重合, 权值均为1, 则可套用simple版解法
 hard版：二维下, 使得 Σwi*(|X-xi| +|Y-yi|)最小. X轴, Y轴分开解即可
 此题：我们将整个平面旋转45°即可变为hard版. 为什么？
 
 因为hard中|X-xi| +|Y-yi|表示的边界形状为以(xi, yi)为中心的45°倾斜的正方形
 而本题max(|X-xi|, |Y-yi|)表示的边界形状为以(xi, yi)为中心的正方形
 */
 
 #include <iostream>
 #include <algorithm>
 #include <vector>
 #include <string>
 #include <unordered_set>
 #include <unordered_map>
 #include <set>
 #include <map>
 #include <queue>
 #include <stack>
 #include <functional>
 #include <cmath>
 #include <string.h>
 
 using namespace std;
 using ull = unsigned long long;
 using ll = long long;
 using db = double;
 using PII = pair<int, int>;
 
 template<typename T>
 void print_vec(T& container, const std::string& sep = " "){
     for (auto& x: container){
         std::cout << x << sep;
     }
     std::cout << std::endl;
 }
 
 template<typename T>
 void print_map(T& mp){
     for(auto& x: mp){
         std::cout << x.first << " " << x.second << std::endl;
     }
 }
 
 struct Point{
     double x, y, w;
     void input(){
         cin >> x >> y >> w;
     }
     double dist(double _x, double _y){
         return fabs(x - _x) + fabs(y - _y);
     }
     void rotate(){
         static double ang = 45.0 /  * acos(-1.0);
         double x1 = x * cos(ang) - y * sin(ang);
         double y1 = x * sin(ang) + y * cos(ang);
         x = x1 * sin(ang) ;
         y = y1 * sin(ang) ;
     }
 };
 struct Problem{
 
     int N;
     Point p[];
     void read(){
         cin >> N;
         for (int i = ; i < N; i++){
             p[i].input();
             p[i].rotate();
         }
     }
 
     struct WEIGHT{
         double w;
         double x;
         bool operator<(const WEIGHT& wt) const{
             return x < wt.x;
         }
     };
 
     double calc(WEIGHT wt[], int n){
         sort(wt, wt + n);
         double ans = ;
         double cur_x = wt[].x;
         double pre_sum = ;
         double suf_sum = ;
         for (int i = ; i < n; i++){
             ans += (wt[i].x - cur_x) * wt[i].w;
             suf_sum += wt[i].w;
         }
         double ret = ans;
         for (int i = ; i < n; i++){
             double nxt_x = wt[i].x;
             suf_sum -= wt[i-].w;
             pre_sum += wt[i-].w;
             ans -= suf_sum * (nxt_x - cur_x);
             ans += pre_sum * (nxt_x - cur_x);
             cur_x = nxt_x;
             ret = min(ans, ret);
         }
         return ret;
     }
     void solve(int ca){
         printf("Case #%d: ", ca);
 
         WEIGHT vx[], vy[];
         for (int i = ; i < N; i++){
             vx[i].x = p[i].x;
             vx[i].w = p[i].w;
             vy[i].x = p[i].y;
             vy[i].w = p[i].w;
         }
         double sum = calc(vx, N) + calc(vy, N);
         printf("%.7f\n", sum);
     }
 };
 
 int main(){
     int T;
     cin >> T;
     for (int ca = ; ca <= T; ca++){
         Problem p;
         p.read();
         p.solve(ca);
     }
 }

附随机化模拟退火算法:

 #include <cstdio>
 #include <cstring>
 #include <cstdlib>
 #include <cmath>
 #include <vector>
 #include <map>
 #include <set>
 #include <climits>
 #include <stack>
 #include <queue>
 #include <ctime>
 #include <string>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 
 #define MEM(a,b) memset(a,b,sizeof(a))
 #define REP(i,n) for(int i=0;i<(n);++i)
 #define FOR(i,a,b) for(int i=(a);i<=(b);++i)
 #define getmid(l,r) ((l) + ((r) - (l)) / 2)
 #define MP(a,b) make_pair(a,b)
 
 typedef long long ll;
 typedef pair<int,int> pii;
 const int INF = ( << ) - ;
 const int MAXN = ;
 const double cof = 0.5;
 const double eps = 1e-;
 const double deta = 0.7;
 
 int T,N;
 double X[MAXN],Y[MAXN], W[MAXN];
 int dir[][] = {{-,},{,},{,-},{,}};
 
 double Dis(double a1,double b1,double a2,double b2){
     return max(abs(a1-a2), abs(b1-b2));
 }
 
 double Cal(double a,double b){
     double res = Dis(a,b,X[],Y[]) * W[];
     FOR(i,,N - ) res += Dis(a,b,X[i],Y[i]) * W[i];
     return res;
 }
 
 int main(){
     srand((unsigned)time(NULL));
     int a,b;
     scanf("%d",&T);
     FOR(tt,,T){
         scanf("%d",&N);
         REP(i,N) scanf("%lf%lf%lf",&X[i],&Y[i], &W[i]);
         double ans = -,ansx,ansy;
         REP(o,){
             double sx = rand() % (N + );
             double sy = rand() % (N + );
             double res = Cal(sx,sy);
             double step = N;
             while(step > eps){
                 while(){
                     bool mov = false;
                     REP(k,){
                         double tx = sx + dir[k][] * step;
                         double ty = sy + dir[k][] * step;
                         if(tx < - || tx >  || ty < - || ty > ) continue;
                         double tmp = Cal(tx,ty);
                         if(tmp < res || (double)rand()/INT_MAX > deta){
                             res = tmp;
                             sx = tx;
                             sy = ty;
                             mov = true;
                         }
                     }
                     if(mov == false) break;
                 }
                 step *= cof;
             }
             if(ans == - || res < ans){
                 ans = res;
                 ansx = sx;
                 ansy = sy;
             }
         }
         printf("Case #%d: %.6lf\n", tt, ans);
         //printf("The safest point is (%.1f, %.1f).\n",ansx,ansy);
     }
     return ;
 }