uoj233/BZOJ4654/洛谷P1721 [Noi2016]国王饮水记 【dp + 斜率优化】

最新推荐文章于 2022-07-19 11:48:14 发布
最新推荐文章于 2022-07-19 11:48:14 发布
阅读量74 收藏
点赞数
原文链接：http://www.cnblogs.com/Mychael/p/9305315.html
版权

题目链接

uoj233

题解

下面不加证明地给出几个性质：

  1. 小于\(h[1]\)的城市一定是没用的
  2. 任何城市联通包含\(1\)且只和\(1\)联通一次
  3. 联通顺序从小到大最优
  4. 单个联通比多个一起联通要优
  5. 最优解中多个一起联通不超过\(14\)次

除了最后一个外还是很显然的
\(K\)足够大肯定逐个联通，否则有一些还是需要一起联通的
我们可以设\(f[i][j]\)表示前\(i\)个城市，联通\(j\)次\(h[1]\)的最高高度
那么，去掉小于\(h[1]\)的城市，将\(h[i]\)排序，记\(s[i]\)为\(h[i]\)前缀和
\[f[i][j] = max\{\frac{f[k][j - 1] + s[i] - s[k]}{i - k + 1}\}\]
可以斜率优化且具有决策单调性
又由于最多不超过\(14\)次多个联通，所以找到\(14\)次中最优决策之后剩余的就可以逐个联通了
复杂度\(O(np)\)

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;

// ---------- 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 ----------
inline int read(){
    int out = 0,flag = 1; char c = getchar();
    while (c < 48 || c > 57){if (c == '-') flag = 0; c = getchar();}
    while (c >= 48 && c <= 57){out = (out << 1) + (out << 3) + c - 48; c = getchar();}
    return flag ? out : -out;
}
const int maxn = 8005;
Decimal ans;
int n,K,P,tot,h[maxn],pre[maxn][15],S[maxn];
int q[maxn],head,tail;
double f[maxn][15];
struct point{double x,y;}p[maxn];
double slope(const point& a,const point& b){
    return (a.y - b.y) /(a.x - b.x);
}
Decimal calc(int i,int j){
    if (!j) return h[1];
    return (calc(pre[i][j],j - 1) + S[i] - S[pre[i][j]]) / (i - pre[i][j] + 1);
}
int main(){
    //freopen("1.in","r",stdin);
    //freopen("1.out","w",stdout);
    n = read(); K = read(); P = read(); h[tot = 1] = read();
    for (int i = 2; i <= n; i++){
        h[i] = read();
        if (h[i] > h[1]) h[++tot] = h[i];
    }
    n = tot; sort(h + 1,h + 1 + n);
    for (int i = 1; i <= n; i++) S[i] = S[i - 1] + h[i];
    K = min(n,K);
    int E = min(K,14);
    for (int i = 1; i <= n; i++) f[i][0] = h[1];
    for (int j = 1; j <= E; j++){
        f[1][j] = h[1];
        q[head = tail = 1] = 1;
        for (int i = 1; i <= n; i++) p[i] = (point){i - 1,S[i] - f[i][j - 1]};
        for (int i = 2; i <= n; i++){
            point u = (point){i,S[i]};
            while (head < tail && slope(u,p[q[head]]) < slope(u,p[q[head + 1]])) head++;
            pre[i][j] = q[head];
            int v = q[head];
            f[i][j] = (f[v][j - 1] + S[i] - S[v]) / (i - v + 1);
            while (head < tail && slope(p[i],p[q[tail]]) < slope(p[q[tail - 1]],p[q[tail]])) tail--;
            q[++tail] = i;
        }
    }
    int m = n - K + E;
    double mx = 0; int pos;
    for (int i = 0; i <= E; i++)
        if (f[m][i] > mx) mx = f[m][i],pos = m;
    ans = calc(pos,E);
    for (int i = pos + 1; i <= n; i++)
        ans = (ans + h[i]) / 2;
    cout << ans.to_string(P << 1) << endl;
    return 0;
}

转载于:https://www.cnblogs.com/Mychael/p/9305315.html

weixin_30838873
关注
[NOI2016] 国王饮水记（luogu P1721）（超长慎入）
wizard_gray的博客
05-22 468
Description 跳蚤国有 n 个城市，伟大的跳蚤国王居住在跳蚤国首都中，即 1 号城市中。跳蚤国最大的问题就是饮水问题，由 于首都中居住的跳蚤实在太多，跳蚤国王又体恤地将分配给他的水也给跳蚤国居民饮用，这导致跳蚤国王也经常喝 不上水。于是，跳蚤国在每个城市都修建了一个圆柱形水箱，这些水箱完全相同且足够高。一个雨天后，第 i 个 城市收集到了高度为 hi 的水。由于地理和天气因素的影响，任何两个不同城市收集到的水高度互不相同。跳蚤国 王也请来蚂蚁工匠帮忙，建立了一个庞大的地下连通系统。跳蚤国王每次使用
uoj240【IOI2016】aliens（斜率优化dp+wqs二分）
Icefox的博客
05-16 1258
这是强行交互么qaq 我们可以把所有点都对称到主对角线下方。 然后每个点如果想被覆盖都会有一个最小的三角形，我们可以贪心的只留必须选的点。如果把剩下的点按x坐标升序排序，可以发现他们的y坐标也是升序排序的。 记剩余点个数为n，显然每个点都选自己的最小三角形最好。但是有可能n&gt;K，即我们不得不合并一些连续的最小三角形。可以dp，f[i][k]表示覆盖前i个点，用了k个三角形的最少覆盖点。...
[Noi2016]国王饮水记
weixin_34204722的博客
06-14 294
传送门 Description 有\(n\)个数，最多\(k\)次操作，每次可选择一些数，使得它们全都变成它们的平均数 最大化第一个数的值 保留\(p\)位小数 \(n\leq 8000,p\leq3000\) Solution 因为对精度的要求，套用高精度小数类的话，单次计算为\(O(p)\) 因此我们动规的过程中，采用记录决策点，并用long double记录\(F\)数组的值...
[NOI 2016]国王饮水记
weixin_30872733的博客
07-05 129
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...
【BZOJ4654】【NOI2016】国王饮水记（动态规划，斜率优化）
小蒟蒻yyb的博客
07-12 350
题面 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 ...
洛谷 P1117 [NOI2016] 优秀的拆分 题解
KaiserWilheim的博客
07-19 640
Luogu P1117 LibreOJ #2083 AcWing 1006 UOJ #219
uoj#57./bzoj3051 【WC2013】平面图 //平面图转对偶图
蒟蒻名曰Starria
01-16 782
uoj#57. 【WC2013】平面图 题意 给出由M( Q( 要求画一条不经过无界区域或顶点的曲线连接A,B，并使得其横穿的线段权值最大的最小。 判断是否有解，输出最优解下经过线段的最大权值。 题解 这道题的题解还是暑假学网络流的时候看到的…。 是一个听起来很高端实际上很暴力的东西。 几周前的模拟考了类似的东西，是平面图转对
P1173 [NOI2016] 网格 题解
Sinnan
03-15 500
跳蚤国王和蛐蛐国王在玩一个游戏。 他们在一个nn行mm列的网格上排兵布阵。其中的cc个格子中(0 \leq c \leq n\cdot m)(0≤c≤n⋅m)，每个格子有一只蛐蛐，其余的格子中，每个格子有一只跳蚤。 我们称占据的格子有公共边的两只跳蚤是相邻的。 我们称两只跳蚤是连通的，当且仅当这两只跳蚤相邻，或存在另一只跳蚤与这两只跳蚤都连通。 现在，蛐蛐国王希望，将某些（零个，一个或多个）跳蚤替换成蛐蛐，使得在此之后存在至少两只跳蚤不连通。
[BZOJ4585][Apio2016]Fireworks 烟火表演（树形 DP + 凸包 + 左偏树）
女装的你，如此好看！
11-15 498
Address 洛谷 P3642 BZOJ 4585 UOJ #205 LOJ #2568 Solution NOIP 2018 之后 A 掉的第一道题，祭 看上去是水题，但是发现边权可以减一之后就不是那么容易了 很容易想到状态： f[u][i]f[u][i]f[u][i] 表示把 uuu 到子树内所有叶子的距离都调成 iii 的最小代价（下面 len(u,v)len(u,v)len(u,v) ...
P1721 [NOI2016]国王饮水记
qq_40511169的博客
01-21 758
题目描述 跳蚤国有 n 个城市，伟大的跳蚤国王居住在跳蚤国首都中，即 1号城市中。 跳蚤国最大的问题就是饮水问题，由于首都中居住的跳蚤实在太多，跳蚤国王又体恤地将分配给他的水也给跳蚤国居民饮用，这导致跳蚤国王也经常喝不上水。 于是，跳蚤国在每个城市都修建了一个圆柱形水箱，这些水箱完全相同且足够高。一个雨天后，第 i个城市收集到了高度为 hi 的水。由于地理和天气因素的影响，任何两
NOI2016 国王饮水记
andy_zeng123456的博客
10-23 158
NOI2016 国王饮水记 题意： ​ 自己看 题解： ​ 这题是大结论题，推荐这篇博客 ​ 结论找出来后不难做，但是，他卡你有没有看说明书！！！ #include<cstdio> #include<cstring> #include<iostream> #include<algorithm> #define fo(i,l,r) for(i...
[NOI2016]国王饮水记
weixin_30740295的博客
07-07 144
[NOI2016]国王饮水记 .....无话可说 小于h1的直接扔掉 其他的从小到大排序 k>n的时候,手玩可以发现,每次选择2个合并最优 k<n?一段合并答案更优 DP,f[i][j]前i个,合并了j次最大值 可以推出斜率优化的式子,(这个有所不同!这玩意是分式,最优化斜率,交叉项才是最优化截距!) 也具有决策单调性,下凸壳队列维护 n<=...
「BZOJ4654」「NOI2016」国王饮水记
infinity_edge的博客
06-30 443
题目描述 跳蚤国有 nnn 个城市，伟大的跳蚤国王居住在跳蚤国首都中，即 111 号城市中。 跳蚤国最大的问题就是饮水问题，由于首都中居住的跳蚤实在太多，跳蚤国王又体恤地将分配给他的水也给跳蚤国居民饮用，这导致跳蚤国王也经常喝不上水。 于是，跳蚤国在每个城市都修建了一个圆柱形水箱，这些水箱完全相同且足够高。一个雨天后，第 iii 个城市收集到了高度为 hihih_i 的水。由于地理和天气因素...
[loj2087][NOI2016]国王饮水记
zhouyuheng2003的博客
07-05 454
前言 回归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,...
LG P1721 [NOI2016]国王饮水记
delitun2798的博客
08-12 187
题面描述 跳蚤国有\(n\)个城市，伟大的跳蚤国王居住在跳蚤国首都中，即 \(1\)号城市中。 跳蚤国最大的问题就是饮水问题，由于首都中居住的跳蚤实在太多，跳蚤国王又体恤地将分配给他的水也给跳蚤国居民饮用，这导致跳蚤国王也经常喝不上水。 于是，跳蚤国在每个城市都修建了一个圆柱形水箱，这些水箱完全相同且足够高。一个雨天后，第\(i\)个城市收集到了高度为\(h_i\) 的水。由于地理和天...
UOJ223 NOI2016 国王饮水记
Rayment的博客
03-22 384
Problem UOJ Solution 经过 瞎猜 思考可以得到以下性质： 所有高度小于首都的水箱肯定不会参与联通。 选择联通的水箱必然是从某一个水箱开始的连续的知道选到最高的水箱。因为如果中间有间隔，那么完全可以把前面的水箱舍弃掉最小的，然后换成间隔的较大的。 如果要联通多次水箱，必然是先与相对较低的水箱联通，再与相对较高的水箱联通。否则交换顺序更优，可以推推式子证明。 kkk 最大取 n−...
洛谷 P1721 国王饮水记 —— 斜率dp + 性质 + 高精度
Scar_Halo
04-10 255
题目链接：点我啊╭(╯^╰)╮ 题目大意：     nnn 个城市，每个城市有高为 hih_ihi​ 的水     使用 kkk 次地下连通系统，使得 111 号城市水位最高     使用一次地下连通系统，可以任意指定城市，水位然后保持一致    &...
*UOJ#223. 【NOI2016】国王饮水记
a2850363633的博客
07-03 157
$n \leq 8000$的数列，问不超过$m \leq 1e9$次操作后第一个数字最大是多少。操作：选一些数，把他们变成他们的平均值。需要保留$p \leq 3000$位小数，提供了一个小数高精度库。 太长懒得写了。。总之就是个斜率优化DP，然后有奇怪性质 原题解 基本能猜到定理八，十至今没理解QAQ 用前八个定理写了一份被卡精度的代码。就是DP的时候记决策点，然后最后用决策点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值