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 / 180 * 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[10010];
    void read(){
        cin >> N;
        for (int i = 0; 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 = 0;
        double cur_x = wt[0].x;
        double pre_sum = 0;
        double suf_sum = 0;
        for (int i = 0; i < n; i++){
            ans += (wt[i].x - cur_x) * wt[i].w;
            suf_sum += wt[i].w; 
        }
        double ret = ans;
        for (int i = 1; i < n; i++){
            double nxt_x = wt[i].x;
            suf_sum -= wt[i-1].w;
            pre_sum += wt[i-1].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[10010], vy[10010];
        for (int i = 0; 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 = 1; 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 = (1 << 30) - 1;
const int MAXN = 10010;
const double cof = 0.5;
const double eps = 1e-3;
const double deta = 0.7;

int T,N;
double X[MAXN],Y[MAXN], W[MAXN];
int dir[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};

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[0],Y[0]) * W[0];
    FOR(i,1,N - 1) 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,1,T){
        scanf("%d",&N);
        REP(i,N) scanf("%lf%lf%lf",&X[i],&Y[i], &W[i]);
        double ans = -1,ansx,ansy;
        REP(o,100){
            double sx = rand() % (N + 1);
            double sy = rand() % (N + 1);
            double res = Cal(sx,sy);
            double step = N;
            while(step > eps){
                while(1){
                    bool mov = false;
                    REP(k,4){
                        double tx = sx + dir[k][0] * step;
                        double ty = sy + dir[k][1] * step;
                        if(tx < -10000 || tx > 10000 || ty < -10000 || ty > 10000) 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 == -1 || 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 0;
}