hdu5073 简单枚举+精度处理

其实这题还是挺简单的，因为移动k个星球后，这k个星球的权值就可以变为0，所以只有剩下的本来就是连着的才是最优解，也就是说要动也是动两端的，那么就O(N)枚举一遍动哪些就好了。

我是在杭电oj题目重现的比赛上做这题，因为之前听人说现场赛时有人用n^2的算法蹭过了，所以我不断蹭，蹭了一个小时都没蹭过。。。~！@#￥%……

先贴一份乱七八糟想蹭过的代码

/*
 * Author    : ben
 */
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <queue>
#include <set>
#include <map>
#include <stack>
#include <string>
#include <vector>
#include <deque>
#include <list>
#include <functional>
#include <numeric>
#include <cctype>
using namespace std;
typedef long long LL;
const double eps = 1e-;
int get_int() {
    int res = , ch;
    while (!((ch = getchar()) >= '' && ch <= '')) {
        if (ch == EOF)
            return  << ;
    }
    res = ch - '';
    while ((ch = getchar()) >= '' && ch <= '')
        res = res *  + (ch - '');
    return res;
}
//输入整数(包括负整数)，用法int a = get_int2();
int get_int2() {
    int res = , ch, flag = ;
    while (!((ch = getchar()) >= '' && ch <= '')) {
        if (ch == '-')
            flag = ;
        if (ch == EOF)
            return  << ;
    }
    res = ch - '';
    while ((ch = getchar()) >= '' && ch <= '')
        res = res *  + (ch - '');
    if (flag == )
        res = -res;
    return res;
}
const int MAXN = ;
int N, K, data[MAXN];
int ndata[MAXN];
LL sum[MAXN];
double ans;

inline double getCenter(int s, int e) {
    LL su = sum[e];
    if (s > ) {
        su -= sum[s - ];
    }
    double ret = su / (e - s + 1.0);
    return ret;
}

void comput(int s, int e, double c) {
    double ret = ;
    for (int i = s; i <= e; i++) {
        ret += (data[i] - c) * (data[i] - c);
        if (ret > ans) {
            return;
        }
    }
    if (ret < ans) {
        ans = ret;
    }
}

double comput(double c) {
    double ret = ;
    for (int i = ; i < N; ) {
        ret += (data[i] - c) * (data[i] - c) * ndata[i];
        i += ndata[i];
    }
    return ret;
}

void work() {
    double cen = getCenter(, N - );
//    printf("cen = %f\n", cen);
    ans = comput(cen);
    for (int a = K; a >= ; a--) {
        if (ans < eps) {
            break;
        }
        int e = N + a - K - ;
        double tmpc = getCenter(a, e);
        comput(a, e, tmpc);
    }
}

void treat() {
    for (int i = ; i < N; i++) {
        int d = data[i];
        int j = i + ;
        while (j < N && data[j] == d) {
            j++;
        }
        int num = j - i;
        for (j--; j >= i; j--) {
            ndata[j] = num - j + i;
        }
    }
}

int main() {
    int T = get_int();
    while (T--) {
        N = get_int();
        K = get_int();
        for (int i = ; i < N; i++) {
            data[i] = get_int2();
        }
        sort(data, data + N);
        treat();
        sum[] = data[];
        for (int i = ; i < N; i++) {
            sum[i] = sum[i - ] + data[i];
        }
        work();
        printf("%.10lf\n", ans);
    }
    return ;
}

下面是正常做法，其实相对于上面的代码也就只有一处改进，因为上面那份代码求解(xi-x)^2的时候是依次计算累加的，可以通过展开公式，通过预存前n项平方和的方式来计算，把这个计算过程从O(N)变成O(1)，就可以过了。

不过我还是wa了几发，原因是一开始忘了对N==K和N-1==K的情况作特殊处理了，因为我后面的代码这个地方没单独考虑。

 /*
  * Author    : ben
  */
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <cmath>
 #include <ctime>
 #include <iostream>
 #include <algorithm>
 #include <queue>
 #include <set>
 #include <map>
 #include <stack>
 #include <string>
 #include <vector>
 #include <deque>
 #include <list>
 #include <functional>
 #include <cctype>
 using namespace std;
 typedef long long LL;
 const double eps = 1e-;
 const int MAXN = ;
 int N, K;
 LL data[MAXN], sum[MAXN], sum2[MAXN];
 double ans;
 int get_int() {
     int res = , ch;
     while (!((ch = getchar()) >= '' && ch <= '')) {
         if (ch == EOF)
             return  << ;
     }
     res = ch - '';
     while ((ch = getchar()) >= '' && ch <= '')
         res = res *  + (ch - '');
     return res;
 }

 //输入整数(包括负整数)，用法int a = get_int2();
 int get_int2() {
     int res = , ch, flag = ;
     while (!((ch = getchar()) >= '' && ch <= '')) {
         if (ch == '-')
             flag = ;
         if (ch == EOF)
             return  << ;
     }
     res = ch - '';
     while ((ch = getchar()) >= '' && ch <= '')
         res = res *  + (ch - '');
     if (flag == )
         res = -res;
     return res;
 }
 inline LL getSum(int from, int to) {
     LL ret = sum[to];
     if (from > ) {
         ret -= sum[from - ];
     }
     return ret;
 }

 inline LL getSum2(int from, int to) {
     LL ret = sum2[to];
     if (from > ) {
         ret -= sum2[from - ];
     }
     return ret;
 }

 inline double getCenter(int s, int e) {
     LL su = sum[e];
     if (s > ) {
         su -= sum[s - ];
     }
     double ret = su / (e - s + 1.0);
     return ret;
 }

 inline double comput(int s, int e, double c) {
     LL s1 = getSum(s, e);
     LL s2 = getSum2(s, e);
     double ret = s2 + (e - s + 1.0) * c * c - 2.0 * c * s1;
     return ret;
 }

 void work() {
     double cen = getCenter(, N - );
     ans = comput(, N - , cen);
     for (int a = ; a <= K; a++) {
         int e = N + a - K - ;
         double tmpc = getCenter(a, e);
         double ret = comput(a, e, tmpc);
         if (ret < ans) {
             ans = ret;
         }
     }
 }

 int main() {
 #ifndef ONLINE_JUDGE
     freopen("data.in", "r", stdin);
 #endif
     int T= get_int();
     while (T--) {
         N = get_int();
         K = get_int();
         for (int i = ; i < N; i++) {
             data[i] = get_int2();
         }
         if (K == N || N -  == K) {
             printf("0\n");
             continue;
         }
         sort(data, data + N);
         sum[] = data[];
         sum2[] = data[] * data[];
         for (int i = ; i < N; i++) {
             sum[i] = sum[i - ] + data[i];
             sum2[i] = sum2[i - ] + data[i] * data[i];
         }
         work();
         printf("%.10lf\n", ans);
     }
     return ;
 }