P1721 [NOI2016]国王饮水记

最新推荐文章于 2020-01-02 15:11:01 发布
最新推荐文章于 2020-01-02 15:11:01 发布
阅读量707 收藏 1
点赞数 1
分类专栏： NOI

题目描述

跳蚤国有 n 个城市，伟大的跳蚤国王居住在跳蚤国首都中，即 1号城市中。

跳蚤国最大的问题就是饮水问题，由于首都中居住的跳蚤实在太多，跳蚤国王又体恤地将分配给他的水也给跳蚤国居民饮用，这导致跳蚤国王也经常喝不上水。

于是，跳蚤国在每个城市都修建了一个圆柱形水箱，这些水箱完全相同且足够高。一个雨天后，第 i个城市收集到了高度为 hi 的水。由于地理和天气因素的影响，任何两个不同城市收集到的水高度互不相同。

跳蚤国王也请来蚂蚁工匠帮忙，建立了一个庞大的地下连通系统。跳蚤国王每次使用地下连通系统时，可以指定任意多的城市，将这些城市的水箱用地下连通系统连接起来足够长的时间之后，再将地下连通系统关闭。由连通器原理，这些城市的水箱中的水在这次操作后会到达同一高度，并且这一高度等于指定的各水箱高度的平均值。

由于地下连通系统的复杂性，跳蚤国王至多只能使用 k次地下连通系统。跳蚤国王请你告诉他，首都 1号城市水箱中的水位最高能有多高？

输入输出格式

输入格式：

输入的第一行包含 3个正整数 n,k,p，分别表示跳蚤国中城市的数量，跳蚤国王能使用地下连通系统的最多次数，以及你输出的答案要求的精度。p 的含义将在输出格式中解释。

接下来一行包含 n个正整数，描述城市的水箱在雨后的水位。其中第 i 个 正整数 hi表示第 i 个城市的水箱的水位。保证 hi 互不相同，1\le h_i \le10^51≤hi​≤105。

输出格式：

输出仅一行一个实数，表示 1 号城市的水箱中的最高水位。

这个实数只可以包含非负整数部分、小数点和小数部分。其中非负整数部分为必需部分，不加正负号。若有小数部分，则非负整数部分与小数部分之间以一个小数点隔开。若无小数部分，则不加小数点。

你输出的实数在小数点后不能超过 2p 位，建议保留至少 p位。数据保证参考答案与真实答案的绝对误差小于 10^{-2p}10−2p。

你的输出被判定为正确当且仅当你的输出与参考答案的绝对误差小于 $10^{−p}$。此外，每个测试点你将有可能获得部分分。

如果你的输出与参考答案的绝对误差不小于 10^{-p}10−p 但小于 10^{-5}10−5，你可以获得该测试点 40% 的分数。

输入输出样例

输入样例#1：

3 1 3
1 4 3
输出样例#1：   
2.666667

说明

由于至多使用一次地下连通系统，有以下 5 种方案：

  1. 不使用地下连通系统：此时 1 号城市的水箱水位为 1。

  2. 使用一次连通系统，连通 1、2 号：此时 11 号城市的水箱水位为 5/2。

  3. 使用一次连通系统，连通 1、3 号：此时 1 号城市的水箱水位为 2/2。

  4. 使用一次连通系统，连通 2、3号：此时 1 号城市的水箱水位为 1。

  5. 使用一次连通系统，连通 1、2、3号：此时 11 号城市的水箱水位为 8/3。

为保证答案精度，我们一般需要尽可能地在运算过程中保留超过 p位小数。我们可以证明，在各个子任务的参考算法中都能保证，在任何时候始终保留 6/5p位小数时，对任何输入得到的输出，与参考答案的绝对误差都小于 10^−p。

为了方便选手处理高精度小数，我们提供了定点高精度小数类。选手可以根据自己的需要参考与使用该类，也可以不使用该类。其具体的使用方法请参考下发的文档 decimal.pdf。

转载自www.cnblogs.com/ljh2000-jump/p/6376109.html

代码（经过o2优化）：

// luogu-judger-enable-o2
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <ctime>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <string>
#include <complex>
using namespace std;
typedef long long LL;
 
// ---------- decimal lib start ----------
const int PREC = 3000;//!!!
class Decimal {
    public:
        Decimal();
        Decimal(const std::string &s);
        Decimal(const char *s);
        Decimal(int x);
        Decimal(long long x);
        Decimal(double x);
         
        bool is_zero() const;
         
        // p (p > 0) is the number of digits after the decimal point
        std::string to_string(int p) const;
        double to_double() const;
         
        friend Decimal operator + (const Decimal &a, const Decimal &b);
        friend Decimal operator + (const Decimal &a, int x);
        friend Decimal operator + (int x, const Decimal &a);
        friend Decimal operator + (const Decimal &a, long long x);
        friend Decimal operator + (long long x, const Decimal &a);
        friend Decimal operator + (const Decimal &a, double x);
        friend Decimal operator + (double x, const Decimal &a);
         
        friend Decimal operator - (const Decimal &a, const Decimal &b);
        friend Decimal operator - (const Decimal &a, int x);
        friend Decimal operator - (int x, const Decimal &a);
        friend Decimal operator - (const Decimal &a, long long x);
        friend Decimal operator - (long long x, const Decimal &a);
        friend Decimal operator - (const Decimal &a, double x);
        friend Decimal operator - (double x, const Decimal &a);
         
        friend Decimal operator * (const Decimal &a, int x);
        friend Decimal operator * (int x, const Decimal &a);
         
        friend Decimal operator / (const Decimal &a, int x);
         
        friend bool operator < (const Decimal &a, const Decimal &b);
        friend bool operator > (const Decimal &a, const Decimal &b);
        friend bool operator <= (const Decimal &a, const Decimal &b);
        friend bool operator >= (const Decimal &a, const Decimal &b);
        friend bool operator == (const Decimal &a, const Decimal &b);
        friend bool operator != (const Decimal &a, const Decimal &b);
         
        Decimal & operator += (int x);
        Decimal & operator += (long long x);
        Decimal & operator += (double x);
        Decimal & operator += (const Decimal &b);
         
        Decimal & operator -= (int x);
        Decimal & operator -= (long long x);
        Decimal & operator -= (double x);
        Decimal & operator -= (const Decimal &b);
         
        Decimal & operator *= (int x);
         
        Decimal & operator /= (int x);
         
        friend Decimal operator - (const Decimal &a);
         
        // These can't be called
        friend Decimal operator * (const Decimal &a, double x);
        friend Decimal operator * (double x, const Decimal &a);
        friend Decimal operator / (const Decimal &a, double x);
        Decimal & operator *= (double x);
        Decimal & operator /= (double x);
         
    private:
        static const int len = PREC / 9 + 1;
        static const int mo = 1000000000;
         
        static void append_to_string(std::string &s, long long x);
         
        bool is_neg;
        long long integer;
        int data[len];
         
        void init_zero();
        void init(const char *s);
};
 
Decimal::Decimal() {
    this->init_zero();
}
 
Decimal::Decimal(const char *s) {
    this->init(s);
}
 
Decimal::Decimal(const std::string &s) {
    this->init(s.c_str());
}
 
Decimal::Decimal(int x) {
    this->init_zero();
     
    if (x < 0) {
        is_neg = true;
        x = -x;
    }
     
    integer = x;
}
 
Decimal::Decimal(long long x) {
    this->init_zero();
     
    if (x < 0) {
        is_neg = true;
        x = -x;
    }
     
    integer = x;
}
 
Decimal::Decimal(double x) {
    this->init_zero();
     
    if (x < 0) {
        is_neg = true;
        x = -x;
    }
     
    integer = (long long)x;
    x -= integer;
     
    for (int i = 0; i < len; i++) {
        x *= mo;
        if (x < 0) x = 0;
        data[i] = (int)x;
        x -= data[i];
    }
}
 
void Decimal::init_zero() {
    is_neg = false;
    integer = 0;
    memset(data, 0, len * sizeof(int));
}
 
bool Decimal::is_zero() const {
    if (integer) return false;
    for (int i = 0; i < len; i++) {
        if (data[i]) return false;
    }
    return true;
}
 
void Decimal::init(const char *s) {
    this->init_zero();
     
    is_neg = false;
    integer = 0;
     
    // find the first digit or the negative sign
    while (*s != 0) {
        if (*s == '-') {
            is_neg = true;
            ++s;
            break;
        } else if (*s >= 48 && *s <= 57) {
            break;
        }
        ++s;
    }
     
    // read the integer part
    while (*s >= 48 && *s <= 57) {
        integer = integer * 10 + *s - 48;
        ++s;
    }
     
    // read the decimal part
    if (*s == '.') {
        int pos = 0;
        int x = mo / 10;
         
        ++s;
        while (pos < len && *s >= 48 && *s <= 57) {
            data[pos] += (*s - 48) * x;
            ++s;
            x /= 10;
            if (x == 0) {
                ++pos;
                x = mo / 10;
            }
        }
    }
}
 
void Decimal::append_to_string(std::string &s, long long x) {
    if (x == 0) {
        s.append(1, 48);
        return;
    }
     
    char _[30];
    int cnt = 0;
    while (x) {
        _[cnt++] = x % 10;
        x /= 10;
    }
    while (cnt--) {
        s.append(1, _[cnt] + 48);
    }
}
 
std::string Decimal::to_string(int p) const {
    std::string ret;
     
    if (is_neg && !this->is_zero()) {
        ret = "-";
    }
     
    append_to_string(ret, this->integer);
     
    ret.append(1, '.');
     
    for (int i = 0; i < len; i++) {
        // append data[i] as "%09d"
        int x = mo / 10;
        int tmp = data[i];
        while (x) {
            ret.append(1, 48 + tmp / x);
            tmp %= x;
            x /= 10;
            if (--p == 0) {
                break;
            }
        }
        if (p == 0) break;
    }
     
    if (p > 0) {
        ret.append(p, '0');
    }
     
    return ret;
}
 
double Decimal::to_double() const {
    double ret = integer;
     
    double k = 1.0;
    for (int i = 0; i < len; i++) {
        k /= mo;
        ret += k * data[i];
    }
     
    if (is_neg) {
        ret = -ret;
    }
     
    return ret;
}
 
bool operator < (const Decimal &a, const Decimal &b) {
    if (a.is_neg != b.is_neg) {
        return a.is_neg && (!a.is_zero() || !b.is_zero());
    } else if (!a.is_neg) {
        // a, b >= 0
        if (a.integer != b.integer) {
            return a.integer < b.integer;
        }
        for (int i = 0; i < Decimal::len; i++) {
            if (a.data[i] != b.data[i]) {
                return a.data[i] < b.data[i];
            }
        }
        return false;
    } else {
        // a, b <= 0
        if (a.integer != b.integer) {
            return a.integer > b.integer;
        }
        for (int i = 0; i < Decimal::len; i++) {
            if (a.data[i] != b.data[i]) {
                return a.data[i] > b.data[i];
            }
        }
        return false;
    }
}
 
bool operator > (const Decimal &a, const Decimal &b) {
    if (a.is_neg != b.is_neg) {
        return !a.is_neg && (!a.is_zero() || !b.is_zero());
    } else if (!a.is_neg) {
        // a, b >= 0
        if (a.integer != b.integer) {
            return a.integer > b.integer;
        }
        for (int i = 0; i < Decimal::len; i++) {
            if (a.data[i] != b.data[i]) {
                return a.data[i] > b.data[i];
            }
        }
        return false;
    } else {
        // a, b <= 0
        if (a.integer != b.integer) {
            return a.integer < b.integer;
        }
        for (int i = 0; i < Decimal::len; i++) {
            if (a.data[i] != b.data[i]) {
                return a.data[i] < b.data[i];
            }
        }
        return false;
    }
}
 
bool operator <= (const Decimal &a, const Decimal &b) {
    if (a.is_neg != b.is_neg) {
        return a.is_neg || (a.is_zero() && b.is_zero());
    } else if (!a.is_neg) {
        // a, b >= 0
        if (a.integer != b.integer) {
            return a.integer < b.integer;
        }
        for (int i = 0; i < Decimal::len; i++) {
            if (a.data[i] != b.data[i]) {
                return a.data[i] < b.data[i];
            }
        }
        return true;
    } else {
        // a, b <= 0
        if (a.integer != b.integer) {
            return a.integer > b.integer;
        }
        for (int i = 0; i < Decimal::len; i++) {
            if (a.data[i] != b.data[i]) {
                return a.data[i] > b.data[i];
            }
        }
        return true;
    }
}
 
bool operator >= (const Decimal &a, const Decimal &b) {
    if (a.is_neg != b.is_neg) {
        return !a.is_neg || (a.is_zero() && b.is_zero());
    } else if (!a.is_neg) {
        // a, b >= 0
        if (a.integer != b.integer) {
            return a.integer > b.integer;
        }
        for (int i = 0; i < Decimal::len; i++) {
            if (a.data[i] != b.data[i]) {
                return a.data[i] > b.data[i];
            }
        }
        return true;
    } else {
        // a, b <= 0
        if (a.integer != b.integer) {
            return a.integer < b.integer;
        }
        for (int i = 0; i < Decimal::len; i++) {
            if (a.data[i] != b.data[i]) {
                return a.data[i] < b.data[i];
            }
        }
        return true;
    }
}
 
bool operator == (const Decimal &a, const Decimal &b) {
    if (a.is_zero() && b.is_zero()) return true;
    if (a.is_neg != b.is_neg) return false;
    if (a.integer != b.integer) return false;
    for (int i = 0; i < Decimal::len; i++) {
        if (a.data[i] != b.data[i]) return false;
    }
    return true;
}
 
bool operator != (const Decimal &a, const Decimal &b) {
    return !(a == b);
}
 
Decimal & Decimal::operator += (long long x) {
    if (!is_neg) {
        if (integer + x >= 0) {
            integer += x;
        } else {
            bool last = false;
            for (int i = len - 1; i >= 0; i--) {
                if (last || data[i]) {
                    data[i] = mo - data[i] - last;
                    last = true;
                } else {
                    last = false;
                }
            }
            integer = -x - integer - last;
            is_neg = true;
        }
    } else {
        if (integer - x >= 0) {
            integer -= x;
        } else {
            bool last = false;
            for (int i = len - 1; i >= 0; i--) {
                if (last || data[i]) {
                    data[i] = mo - data[i] - last;
                    last = true;
                } else {
                    last = false;
                }
            }
            integer = x - integer - last;
            is_neg = false;
        }
    }
    return *this;
}
 
Decimal & Decimal::operator += (int x) {
    return *this += (long long)x;
}
 
Decimal & Decimal::operator -= (int x) {
    return *this += (long long)-x;
}
 
Decimal & Decimal::operator -= (long long x) {
    return *this += -x;
}
 
Decimal & Decimal::operator /= (int x) {
    if (x < 0) {
        is_neg ^= 1;
        x = -x;
    }
     
    int last = integer % x;
    integer /= x;
     
    for (int i = 0; i < len; i++) {
        long long tmp = 1LL * last * mo + data[i];
        data[i] = tmp / x;
        last = tmp - 1LL * data[i] * x;
    }
     
    if (is_neg && integer == 0) {
        int i;
        for (i = 0; i < len; i++) {
            if (data[i] != 0) {
                break;
            }
        }
        if (i == len) {
            is_neg = false;
        }
    }
     
    return *this;
}
 
Decimal & Decimal::operator *= (int x) {
    if (x < 0) {
        is_neg ^= 1;
        x = -x;
    } else if (x == 0) {
        init_zero();
        return *this;
    }
     
    int last = 0;
    for (int i = len - 1; i >= 0; i--) {
        long long tmp = 1LL * data[i] * x + last;
        last = tmp / mo;
        data[i] = tmp - 1LL * last * mo;
    }
    integer = integer * x + last;
     
    return *this;
}
 
Decimal operator - (const Decimal &a) {
    Decimal ret = a;
    // -0 = 0
    if (!ret.is_neg && ret.integer == 0) {
        int i;
        for (i = 0; i < Decimal::len; i++) {
            if (ret.data[i] != 0) break;
        }
        if (i < Decimal::len) {
            ret.is_neg = true;
        }
    } else {
        ret.is_neg ^= 1;
    }
    return ret;
}
 
Decimal operator + (const Decimal &a, int x) {
    Decimal ret = a;
    return ret += x;
}
 
Decimal operator + (int x, const Decimal &a) {
    Decimal ret = a;
    return ret += x;
}
 
Decimal operator + (const Decimal &a, long long x) {
    Decimal ret = a;
    return ret += x;
}
 
Decimal operator + (long long x, const Decimal &a) {
    Decimal ret = a;
    return ret += x;
}
 
Decimal operator - (const Decimal &a, int x) {
    Decimal ret = a;
    return ret -= x;
}
 
Decimal operator - (int x, const Decimal &a) {
    return -(a - x);
}
 
Decimal operator - (const Decimal &a, long long x) {
    Decimal ret = a;
    return ret -= x;
}
 
Decimal operator - (long long x, const Decimal &a) {
    return -(a - x);
}
 
Decimal operator * (const Decimal &a, int x) {
    Decimal ret = a;
    return ret *= x;
}
 
Decimal operator * (int x, const Decimal &a) {
    Decimal ret = a;
    return ret *= x;
}
 
Decimal operator / (const Decimal &a, int x) {
    Decimal ret = a;
    return ret /= x;
}
 
Decimal operator + (const Decimal &a, const Decimal &b) {
    if (a.is_neg == b.is_neg) {
        Decimal ret = a;
        bool last = false;
        for (int i = Decimal::len - 1; i >= 0; i--) {
            ret.data[i] += b.data[i] + last;
            if (ret.data[i] >= Decimal::mo) {
                ret.data[i] -= Decimal::mo;
                last = true;
            } else {
                last = false;
            }
        }
        ret.integer += b.integer + last;
        return ret;
    } else if (!a.is_neg) {
        // a - |b|
        return a - -b;
    } else {
        // b - |a|
        return b - -a;
    }
}
 
Decimal operator - (const Decimal &a, const Decimal &b) {
    if (!a.is_neg && !b.is_neg) {
        if (a >= b) {
            Decimal ret = a;
            bool last = false;
            for (int i = Decimal::len - 1; i >= 0; i--) {
                ret.data[i] -= b.data[i] + last;
                if (ret.data[i] < 0) {
                    ret.data[i] += Decimal::mo;
                    last = true;
                } else {
                    last = false;
                }
            }
            ret.integer -= b.integer + last;
            return ret;
        } else {
            Decimal ret = b;
            bool last = false;
            for (int i = Decimal::len - 1; i >= 0; i--) {
                ret.data[i] -= a.data[i] + last;
                if (ret.data[i] < 0) {
                    ret.data[i] += Decimal::mo;
                    last = true;
                } else {
                    last = false;
                }
            }
            ret.integer -= a.integer + last;
            ret.is_neg = true;
            return ret;
        }
    } else if (a.is_neg && b.is_neg) {
        // a - b = (-b) - (-a)
        return -b - -a;
    } else if (a.is_neg) {
        // -|a| - b
        return -(-a + b);
    } else {
        // a - -|b|
        return a + -b;
    }
}
 
Decimal operator + (const Decimal &a, double x) {
    return a + Decimal(x);
}
 
Decimal operator + (double x, const Decimal &a) {
    return Decimal(x) + a;
}
 
Decimal operator - (const Decimal &a, double x) {
    return a - Decimal(x);
}
 
Decimal operator - (double x, const Decimal &a) {
    return Decimal(x) - a;
}
 
Decimal & Decimal::operator += (double x) {
    *this = *this + Decimal(x);
    return *this;
}
 
Decimal & Decimal::operator -= (double x) {
    *this = *this - Decimal(x);
    return *this;
}
 
Decimal & Decimal::operator += (const Decimal &b) {
    *this = *this + b;
    return *this;
}
 
Decimal & Decimal::operator -= (const Decimal &b) {
    *this = *this - b;
    return *this;
}
 
// ---------- decimal lib end ----------
 
const int MAXN = 8011;
Decimal ans;
int n,k,p,h[MAXN],dui[MAXN],head,tail,from[MAXN][20],s[MAXN];
double f[MAXN][20];
 
struct Point{
    double x,y;
}ljh,b[MAXN];
 
inline int getint(){
    int w=0,q=0; char c=getchar(); while((c<'0'||c>'9') && c!='-') c=getchar();
    if(c=='-') q=1,c=getchar(); while (c>='0'&&c<='9') w=w*10+c-'0',c=getchar(); return q?-w:w;
}
 
inline double K(Point q,Point qq){
    return (qq.y-q.y)/(qq.x-q.x);
}
 
inline Decimal calc(int i,int j){
    if(j==0) return h[1];
    return ( calc(from[i][j],j-1) + s[i]-s[from[i][j]] ) / (i-from[i][j]+1);
}
 
inline void work(){
    n=getint(); k=getint(); p=getint(); h[1]=getint();
    for(int i=2;i<=n;i++) { h[i]=getint(); if(h[i]<=h[1]) i--,n--; }
    sort(h+1,h+n+1); for(int i=1;i<=n;i++) s[i]=s[i-1]+h[i];
    k=min(k,n); for(int i=1;i<=n;i++) f[i][0]=h[1];//不操作的话就是1本身
    int lim;
    if(k>14) lim=14; else lim=k;
    for(int j=1;j<=lim;j++) {//最多lim个长度超过1的区间
        head=tail=0; dui[tail]=1;
        b[1].x=0; b[1].y=s[1]-f[1][j-1];
        for(int i=2;i<=n;i++) {
            ljh.x=i; ljh.y=s[i];
            while(head<tail && K(b[dui[head]],ljh)<K(b[dui[head+1]],ljh)) head++;
            b[i].x=i-1; b[i].y=s[i]-f[i][j-1]; from[i][j]=dui[head];
            f[i][j]=s[i]-s[dui[head]]+f[dui[head]][j-1]; f[i][j]/=(double)(i-dui[head]+1);
            while(head<tail && K(b[dui[tail-1]],b[dui[tail]])>K(b[dui[tail]],b[i])) tail--;
            dui[++tail]=i;
        }
    }
 
    //要选lim个长度大于等于1的区间
    //而如果k>14则必须要选若干长度只有1的区间，否则我每次都可以选长度大于1的区间，也就是k(lim)次
 
    int u=n-(k-lim);//最后k-lim个必定是只选1个
    //所以u就是长度大于等于1操作区间的结束位置，必然也是最后一个决策点
 
    //枚举从u往前的所有区间中操作多少次
    double suan=0; int star;
    for(int j=0;j<=lim;j++) if(f[u][j]>suan) suan=f[u][j],star=j;
    ans=calc(u,star);
    for(int i=u+1;i<=n;i++) ans=(ans+h[i])/2;
    cout<<ans.to_string(p*2);
}
 
int main()
{
    work();
    return 0;
}



论猿
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[NOI2016] 国王饮水记（luogu P1721）（超长慎入）
wizard_gray的博客
05-22 397
Description 跳蚤国有 n 个城市，伟大的跳蚤国王居住在跳蚤国首都中，即 1 号城市中。跳蚤国最大的问题就是饮水问题，由 于首都中居住的跳蚤实在太多，跳蚤国王又体恤地将分配给他的水也给跳蚤国居民饮用，这导致跳蚤国王也经常喝 不上水。于是，跳蚤国在每个城市都修建了一个圆柱形水箱，这些水箱完全相同且足够高。一个雨天后，第 i 个 城市收集到了高度为 hi 的水。由于地理和天气因素的影响，任何两个不同城市收集到的水高度互不相同。跳蚤国 王也请来蚂蚁工匠帮忙，建立了一个庞大的地下连通系统。跳蚤国王每次使用
NOI2016DAY2试题
10-24
NOI2016第二天的试题
NOI2016部分题解
L_0_Forever_LF的专栏
06-16 459
D1T1优秀的拆分 枚举AABB中AB的交界处，其实就是要计算每个位置AA的数量，算这个东西有个经典套路： 枚举A的长度，每A个字符设置一个关键点，任意一个A一定覆盖且仅覆盖1个关键点，枚举相邻的两个关键点，后缀数组上st表O(1) lcp求他们往左往右匹配长度 O(nlogn)O(nlogn)O(nlogn) code： #include&lt;set&gt; #include&l...
[NOI 2016]国王饮水记
weixin_30872733的博客
07-05 119
Description 题库链接 给出 \(n\) 个水杯，每个水杯装有不同高度的水 \(h_i\) ，每次可以指定任意多水杯用连通器连通后断开，问不超过 \(k\) 次操作之后 \(1\) 号水杯的最高水量。需要输出 \(q\) 位小数。（提供高精度小数库，单次计算 \(O(q)\) ） \(1\leq n\leq 8000,1\leq k\leq 10^9,1\leq h_i\leq 10^5...
[loj2087][NOI2016]国王饮水记
zhouyuheng2003的博客
07-05 445
前言 回归OI，随便找一道清真dp题写写吧 做完发现一点都不清真 题目相关 链接 题目大意 现在有nnn个数，每次可以取若干个数，将每个数赋成平均值，限制kkk次，问第一个数最大能变成多少 数据范围 n≤1000,k≤109n\le1000,k\le10^9n≤1000,k≤109 另外，精度要求ppp位，3≤p≤30003\le p\le30003≤p≤3000 题解 设nnn个数为h1,h2,...
「BZOJ4654」「NOI2016」国王饮水记
infinity_edge的博客
06-30 427
题目描述 跳蚤国有 nnn 个城市，伟大的跳蚤国王居住在跳蚤国首都中，即 111 号城市中。 跳蚤国最大的问题就是饮水问题，由于首都中居住的跳蚤实在太多，跳蚤国王又体恤地将分配给他的水也给跳蚤国居民饮用，这导致跳蚤国王也经常喝不上水。 于是，跳蚤国在每个城市都修建了一个圆柱形水箱，这些水箱完全相同且足够高。一个雨天后，第 iii 个城市收集到了高度为 hihih_i 的水。由于地理和天气因素...
搜索讲座-清华大学，NOI2016金
02-12
【标题】"搜索讲座-清华大学，NOI2016金"揭示了这是一场关于搜索算法的专题讲座，由清华大学主办，并且与2016年的全国奥林匹克信息学竞赛（NOI）有关，其中吕同学是该讲座的主讲人，他还曾担任APIO（亚洲和太平洋...
数据结构专题-清华大学NOI2016金牌讲座
02-11
在这个专题讲座中，汪同学，一位来自清华大学的NOI2016金牌获得者，将为我们深入讲解数据结构的重要概念和应用。 首先，我们要理解数据结构的基本概念。数据结构可以看作是数据的集合，以及这些数据之间的关系。...
NOI2016 day1试题
07-26
全国信息学奥林匹克决赛 NOI 2016 第一试 试题
NOI2009.rar_.noi20_Noi2009 P_noi20
09-23
【标题】"NOI2009.rar_.noi20_Noi2009 P_noi20" 涉及的是2009年全国青少年信息学奥林匹克（NOI）的比赛资料，其中包含了选手的解题报告，源代码，问题注解以及解答。 【描述】"最新noi2099解题报告.包含源程序.标注...
[Noi2016]国王饮水记
weixin_34204722的博客
06-14 281
传送门 Description 有\(n\)个数，最多\(k\)次操作，每次可选择一些数，使得它们全都变成它们的平均数 最大化第一个数的值 保留\(p\)位小数 \(n\leq 8000,p\leq3000\) Solution 因为对精度的要求，套用高精度小数类的话，单次计算为\(O(p)\) 因此我们动规的过程中，采用记录决策点，并用long double记录\(F\)数组的值...
NOI 2016
chrt's blog
07-27 2892
NOIP和省选失败后意外地以A类选手的身份参加了NOI 2016。在这里写写游记。
[NOI2016]国王饮水记
weixin_30740295的博客
07-07 128
[NOI2016]国王饮水记 .....无话可说 小于h1的直接扔掉 其他的从小到大排序 k>n的时候,手玩可以发现,每次选择2个合并最优 k<n?一段合并答案更优 DP,f[i][j]前i个,合并了j次最大值 可以推出斜率优化的式子,(这个有所不同!这玩意是分式,最优化斜率,交叉项才是最优化截距!) 也具有决策单调性,下凸壳队列维护 n<=...
NOI2016 国王饮水记
andy_zeng123456的博客
10-23 128
NOI2016 国王饮水记 题意： ​ 自己看 题解： ​ 这题是大结论题，推荐这篇博客 ​ 结论找出来后不难做，但是，他卡你有没有看说明书！！！ #include<cstdio> #include<cstring> #include<iostream> #include<algorithm> #define fo(i,l,r) for(i...
【BZOJ4654】【NOI2016】国王饮水记（动态规划，斜率优化）
小蒟蒻yyb的博客
07-12 342
题面 BZOJ 洛谷 题解 首先肯定是找性质。 明确一点，比h1h1h_1小的没有任何意义。 所以我们按照hhh排序，那么h1h1h_1就是当前111号位置的水量。 假设我们使用的次数不受到任何限制，我们思考怎么样才是最优。 首先每次只和一个合并一定比和多个合并更优。 假设有三个位置h1&amp;lt;h2&amp;lt;h3h1&amp;lt;h2&amp;lt;h3h_1\lt h_2\lt h_3 ...
小C饮水记
Freopen的博客
03-05 267
题目描述小C虽然没有参加NOI2016, 但当他看到"国王饮水记"这题时还是迅速秒掉了.小C认为这题太水了,于是他决定对这题进行加强.现在小C桌上有n杯水排成一行,第i杯水中有wi 单位体积的水. 他会选择一个区间[l, r],并拿一个初始为空的杯子(杯子的容积无限大),他可以重复无限次以下操作:• 选定任意一杯水i,i ∈ [l, r].• 使i和它拿着的杯子里的水的体积变为它们的平均值.小C希...
【NOI2016】国王饮水记【贪心】【斜率优化】【决策单调性】
Lstdo的博客
01-02 203
传送门 首先比h1h_1h1​小的肯定没用，直接无视 然后考虑合并的顺序 ①在无限制的情况下，合并多个不如一个一个合并 a<b<ca<b<ca<b<c时，a+b2+c2>a+b+c3{{a+b \over 2}+c\over 2}>{{a+b+c}\over 3}22a+b​+c​>3a+b+c​ ②先合并小的比先合并大的优 整理一下，就是把&...
LG P1721 [NOI2016]国王饮水记
delitun2798的博客
08-12 178
题面描述 跳蚤国有\(n\)个城市，伟大的跳蚤国王居住在跳蚤国首都中，即 \(1\)号城市中。 跳蚤国最大的问题就是饮水问题，由于首都中居住的跳蚤实在太多，跳蚤国王又体恤地将分配给他的水也给跳蚤国居民饮用，这导致跳蚤国王也经常喝不上水。 于是，跳蚤国在每个城市都修建了一个圆柱形水箱，这些水箱完全相同且足够高。一个雨天后，第\(i\)个城市收集到了高度为\(h_i\) 的水。由于地理和天...
P1737 [NOI2016] 旷野大计算
最新发布
07-28
对于题目 P1737 [NOI2016] 旷野大计算，我将为您提供一些信息。这是一道关于计算几何的题目，出现在2016年全国青少年信息学奥林匹克竞赛（NOI）中。 题目描述大致如下：给定一个平面上的点集，您需要确定一个点，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值