LG P1721 [NOI2016]国王饮水记

最新推荐文章于 2021-05-20 05:26:14 发布
最新推荐文章于 2021-05-20 05:26:14 发布
阅读量212 收藏
点赞数
原文链接：http://www.cnblogs.com/Anverking/p/solution-lgp1721.html
版权

题面描述

跳蚤国有\(n\)个城市，伟大的跳蚤国王居住在跳蚤国首都中，即 \(1\)号城市中。
跳蚤国最大的问题就是饮水问题，由于首都中居住的跳蚤实在太多，跳蚤国王又体恤地将分配给他的水也给跳蚤国居民饮用，这导致跳蚤国王也经常喝不上水。
于是，跳蚤国在每个城市都修建了一个圆柱形水箱，这些水箱完全相同且足够高。一个雨天后，第\(i\)个城市收集到了高度为\(h_i\) 的水。由于地理和天气因素的影响，任何两个不同城市收集到的水高度互不相同。
跳蚤国王也请来蚂蚁工匠帮忙，建立了一个庞大的地下连通系统。跳蚤国王每次使用地下连通系统时，可以指定任意多的城市，将这些城市的水箱用地下连通系统连接起来足够长的时间之后，再将地下连通系统关闭。由连通器原理，这些城市的水箱中的水在这次操作后会到达同一高度，并且这一高度等于指定的各水箱高度的平均值。
由于地下连通系统的复杂性，跳蚤国王至多只能使用 \(k\)次地下连通系统。跳蚤国王请你告诉他，首都$ 1$号城市水箱中的水位最高能有多高？

分析

\(1.\)所有积水高度小于等于\(1\)号点的点可以直接丢掉. 所以,将留下来的水的高度都改成其原本的高度\(-1\)号点高度,最后答案再加上\(1\)号点的高度.

\(2.\)假如被要求进行两次合并,有两杯水\(h _ 1<h _ 2\),则一定先合并低的,再合并高的. 证明:先合并低的:\(\frac{1}{2}(\frac{1}{2}h_1+h _ 2)=\frac{1}{4}h_1+\frac{1}{2}h_2\),先合并高的:\(\frac{1}{2}h_1+\frac{1}{4}h _ 2\).

\(3.\)若有一部分水合并了,一部分没有,那么被合并的水一定是最高的几杯.

将所有留下来的水从低到高排序,设\(h_i\)表示第\(i\)杯水的高度,\(s _ i\)表示前\(i\)杯水的高度前缀和.

合并操作一定是堆在最后面的一段一段的区间,从前往后合并.

设\(dp[i][j]\)表示前j杯水合并了\(i\)次的最大价值,则
\[ dp[i][j]=\max\left\{\frac{dp[i-1][k]+s _ j-s _ k}{j-k+1}\right\} \]
观察这个式子,发现是点\((k-1,s _ k - dp[i-1][k])\)和点\((j, s _ j)\)构成的直线的斜率.

用单调队列维护点\((k-1,s _ k - dp[i-][k])\)构成的下凸壳.因为点\((j, s _ j)\)的\(y\)坐标随\(x\)坐标递增,所以找最优决策时,将队首一段不会构成最优决策的点的弹出,队首就是最优决策.

Code

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<algorithm>

using namespace std;

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;

        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);

        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;

    while (*s != 0)
    {
        if (*s == '-')
        {
            is_neg = true;
            ++s;
            break;
        }
        else if (*s >= 48 && *s <= 57)
        {
            break;
        }
        ++s;
    }

    while (*s >= 48 && *s <= 57)
    {
        integer = integer * 10 + *s - 48;
        ++s;
    }

    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++)
    {
        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)
    {
        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
    {
        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)
    {
        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
    {
        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)
    {
        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
    {
        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)
    {
        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
    {
        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;
    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)
    {
        return a - -b;
    }
    else
    {
        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)
    {
        return -b - -a;
    }
    else if (a.is_neg)
    {
        return -(-a + b);
    }
    else
    {
        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;
}

/*以上为高精度浮点数模板*/

const int Maxn=8007;

inline int input()
{
    register int x=0,c=getchar(),s=1;
    
    while(c<'0'||c>'9')
        (c=='-')&&(s=-1),
        c=getchar();
    
    while(c>='0'&&c<='9')
        x=(x<<1)+(x<<3)+(c^48),
        c=getchar();
    
    return c*s;
}


Decimal ans;

int n,K,p,h[Maxn],zy[Maxn][15],s[Maxn],tot;
int Q[Maxn],H,T;
double dp[Maxn][15];

struct Point
{
    double x,y;
}q[Maxn];

inline double slope(Point a,Point b)
{
    return (a.y-b.y)/(a.x-b.x);
}

inline Decimal calc(int i,int j)
{
    if(!j)
        return h[1];
        
    return (calc(zy[i][j],j-1)+s[i]-s[zy[i][j]])/(i-zy[i][j]+1);
}
int main()
{
    n=input();
    K=input();
    p=input();
    h[tot=1]=input();
    
    for(int i=2;i<=n;++i)
    {
        h[i]=input();
        
        if(h[i]>h[1])
            h[++tot]=h[i];
    }
    
    n=tot;
    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)
        dp[i][0]=h[1];
        
    int lim=min(K,14);
    
    for(int j=1;j<=lim;++j)
    {
        Q[H=T=1]=1;
        
        for(int i=1;i<=n;++i)
            q[i]=(Point)
            {
                i-1,s[i]-dp[i][j-1]
            };
            
        for(int i=2;i<=n;++i)
        {
            Point u=(Point)
            {
                i,s[i]
            };
            
            while(H<T&&slope(u,q[Q[H]])<slope(u,q[Q[H+1]]))
                ++H;
            
            zy[i][j]=Q[H];
            dp[i][j]=(s[i]-s[Q[H]]+dp[Q[H]][j-1])/(i-Q[H]+1);
            
            while(H<T&&slope(q[Q[T]],q[Q[T-1]])>slope(q[Q[T]],q[i]))
                --T;
                
            Q[++T]=i;
        }
    }
    int m=n-K+lim,pos;
    double mx=0;
    
    for(int j=0;j<=lim;++j)
        if(dp[m][j]>mx)
            mx=dp[m][j],
            pos=j;
            
    ans=calc(m,pos);
    
    for(int i=m+1;i<=n;++i)
        ans=(ans+h[i])/2;
        
    cout<<ans.to_string(p<<1)<<endl;
}

转载于:https://www.cnblogs.com/Anverking/p/solution-lgp1721.html

delitun2798
关注
[NOI2016] 国王饮水记（luogu P1721）（超长慎入）
wizard_gray的博客
05-22 525
Description 跳蚤国有 n 个城市，伟大的跳蚤国王居住在跳蚤国首都中，即 1 号城市中。跳蚤国最大的问题就是饮水问题，由 于首都中居住的跳蚤实在太多，跳蚤国王又体恤地将分配给他的水也给跳蚤国居民饮用，这导致跳蚤国王也经常喝 不上水。于是，跳蚤国在每个城市都修建了一个圆柱形水箱，这些水箱完全相同且足够高。一个雨天后，第 i 个 城市收集到了高度为 hi 的水。由于地理和天气因素的影响，任何两个不同城市收集到的水高度互不相同。跳蚤国 王也请来蚂蚁工匠帮忙，建立了一个庞大的地下连通系统。跳蚤国王每次使用
P1173 [NOI2016] 网格 题解
ApocalypseTq的博客
08-20 480
一个显而易见的性质是答案不大于2（角上的跳蚤最多与两个相邻） 继而发现答案其实只可能是-1，0，1，2~~（废话）~~，分类讨论： -1：nm-c<2nm−c<2或者nm-c=2nm−c=2且剩下的两只跳蚤相邻； 0：原图不连通； 1：原图联通且有割顶； 否则为2。 但n,m\le 10^9n,m≤109这种数据范围肯定不能直接做了，发现只有蚱蜢周围的跳蚤可能是割顶，是不是可以把它们选出来建图呢？ .** .*# .** 中间的*成为假的割顶。因此，我们要向外扩展两圈，然后
[Noi2016]国王饮水记
weixin_34204722的博客
06-14 320
传送门 Description 有\(n\)个数，最多\(k\)次操作，每次可选择一些数，使得它们全都变成它们的平均数 最大化第一个数的值 保留\(p\)位小数 \(n\leq 8000,p\leq3000\) Solution 因为对精度的要求，套用高精度小数类的话，单次计算为\(O(p)\) 因此我们动规的过程中，采用记录决策点，并用long double记录\(F\)数组的值...
NOI2016 国王饮水记
andy_zeng123456的博客
10-23 163
NOI2016 国王饮水记 题意： ​ 自己看 题解： ​ 这题是大结论题，推荐这篇博客 ​ 结论找出来后不难做，但是，他卡你有没有看说明书！！！ #include<cstdio> #include<cstring> #include<iostream> #include<algorithm> #define fo(i,l,r) for(i...
P1721 [NOI2016]国王饮水记
qq_40511169的博客
01-21 801
题目描述 跳蚤国有 n 个城市，伟大的跳蚤国王居住在跳蚤国首都中，即 1号城市中。 跳蚤国最大的问题就是饮水问题，由于首都中居住的跳蚤实在太多，跳蚤国王又体恤地将分配给他的水也给跳蚤国居民饮用，这导致跳蚤国王也经常喝不上水。 于是，跳蚤国在每个城市都修建了一个圆柱形水箱，这些水箱完全相同且足够高。一个雨天后，第 i个城市收集到了高度为 hi 的水。由于地理和天气因素的影响，任何两
「BZOJ4654」「NOI2016」国王饮水记
infinity_edge的博客
06-30 488
题目描述 跳蚤国有 nnn 个城市，伟大的跳蚤国王居住在跳蚤国首都中，即 111 号城市中。 跳蚤国最大的问题就是饮水问题，由于首都中居住的跳蚤实在太多，跳蚤国王又体恤地将分配给他的水也给跳蚤国居民饮用，这导致跳蚤国王也经常喝不上水。 于是，跳蚤国在每个城市都修建了一个圆柱形水箱，这些水箱完全相同且足够高。一个雨天后，第 iii 个城市收集到了高度为 hihih_i 的水。由于地理和天气因素...
[NOI2016]优秀的拆分_C++_优秀的拆分_
09-30
【NOI2016】优秀的拆分是一个编程竞赛题目，主要涉及的编程语言是C++，并采用了后缀自动机（Suffix Automaton）和点分治（Pointwise Divide and Conquer）这两种高级算法。这里我们将深入探讨这两个算法以及它们在...
NOI2016DAY2试题
10-24
以上是对NOI2016 Day2试题中“区间”和“国王饮水记”两道题目的详细分析。通过对题目背景、输入输出格式、样例说明以及解题思路的深入探讨，可以更好地理解这两道题目的解题方法和技术要点。希望这份分析能帮助参赛...
[NOI 2016]国王饮水记
weixin_30872733的博客
07-05 167
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 377
题面 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 ...
[NOI2016]国王饮水记
weixin_30740295的博客
07-07 158
[NOI2016]国王饮水记 .....无话可说 小于h1的直接扔掉 其他的从小到大排序 k>n的时候,手玩可以发现,每次选择2个合并最优 k<n?一段合并答案更优 DP,f[i][j]前i个,合并了j次最大值 可以推出斜率优化的式子,(这个有所不同!这玩意是分式,最优化斜率,交叉项才是最优化截距!) 也具有决策单调性,下凸壳队列维护 n<=...
[loj2087][NOI2016]国王饮水记
zhouyuheng2003的博客
07-05 480
前言 回归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,...
C语言西塔国王编程,[NOI2016] 国王饮水记
weixin_33489687的博客
05-20 272
题意：有 (n) 个城市，每个城市有个相同的蓄水池，第 (i) 个城市的水池中的水位高度为 (a_i)((a_i) 互不相同) ，你可以执行 (k) 次操作，每次操作可以将任意多个城市的蓄水池相连(根据连通器原理，这些城市的水池的水位高度会变成他们的平均数)，最后输出第一个城市的蓄水池的水位能达到的最大高度。 (nleq 8000, kleq 1e9)首先，只有水位比 (a_1) 高的城市才能对答...
国王饮水记 题解(
jiangtaizhe的博客
10-07 196
题目传送门 step1:暴力 对于每次询问，都进行一次krusal计算。 #include<cstdio> #include<algorithm> #define maxn 5039 using namespace std; inline int read(){ char c=getchar(); int sum=0,flag=0; while((c<'0'||c>'9')&&c!='-') c=getchar(); if(c=='-') c=
洛谷 P1721 国王饮水记 —— 斜率dp + 性质 + 高精度
Scar_Halo
04-10 280
题目链接：点我啊╭(╯^╰)╮ 题目大意：     nnn 个城市，每个城市有高为 hih_ihi​ 的水     使用 kkk 次地下连通系统，使得 111 号城市水位最高     使用一次地下连通系统，可以任意指定城市，水位然后保持一致    &...
*UOJ#223. 【NOI2016】国王饮水记
a2850363633的博客
07-03 171
$n \leq 8000$的数列，问不超过$m \leq 1e9$次操作后第一个数字最大是多少。操作：选一些数，把他们变成他们的平均值。需要保留$p \leq 3000$位小数，提供了一个小数高精度库。 太长懒得写了。。总之就是个斜率优化DP，然后有奇怪性质 原题解 基本能猜到定理八，十至今没理解QAQ 用前八个定理写了一份被卡精度的代码。就是DP的时候记决策点，然后最后用决策点...
洛谷P1721/bzoj4654/loj2087/uoj223 [NOI2016]国王饮水记 斜率优化
litble的成(tui)长(fei)史
04-30 545
题目分析 性质： 所有积水高度小于等于1号点的点可以直接丢掉。 所以，将留下来的水的高度都改成其原本的高度-1号点高度，最后答案再加上1号点的高度。 假如被要求进行两次合并，有两杯水h1&lt;h2h _ 1&lt;h _ 2h1​<h2​，则一定先合并低的，再合并高的。 证明：先合并低的：12(12h1+h2)=14h1+12h2\frac{1}{2}(\frac{1}{...
【KD-tree】[NOI2019]弹跳
Brute♂force
10-16 423
题目 题目描述 跳蚤国有 nn 座城市，分别编号为 1 - n1−n，11 号城市为首都。所有城市分布在一个w \times hw×h 范围的网格上。每座城市都有一个整数坐标 (x, y) (1 \leq x \leq w, 1 \leq y \leq h)(x,y)(1≤x≤w,1≤y≤h)，不同城市的坐标不相同。 在跳蚤国中共有 mm 个弹跳装置，分别编号为 1 - m1−m，其中 ii 号弹跳装置位于 p_ip i ​ 号城市，并具有参数 t_i, L_i, R_i, D_i, U_it i ​
NOI2016 DAY2：区间选择最小花费问题
NOI2016（中国国家青少年信息学奥林匹克竞赛）的第二天竞赛中，有一个传统型题目叫做“区间”（Interval），其主要涉及了数轴上的区间选择问题。给定的数轴上有 n 个闭区间 [l1, r1], [l2, r2], ..., [ln, rn]，参赛...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值