【NOI2016】国王饮水记【贪心】【斜率优化】【决策单调性】

最新推荐文章于 2020-04-10 00:18:11 发布
最新推荐文章于 2020-04-10 00:18:11 发布
阅读量231 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luositing/article/details/103804149
版权

传送门

首先比 h 1 h_1 h1​小的肯定没用，直接无视

然后考虑合并的顺序

①在无限制的情况下，合并多个不如一个一个合并

a < b < c a<b<c a<b<c时， a + b 2 + c 2 > a + b + c 3 {{a+b \over 2}+c\over 2}>{{a+b+c}\over 3} 22a+b​+c​>3a+b+c​

②先合并小的比先合并大的优

整理一下，就是把 > h 1 > h_1 >h1​的从小到大排序，然后每次把当前的和序列中靠前的若干个合并

显然是个斜率优化的模型

设 f k , n f_{k,n} fk,n​表示前 n n n个合并 k k k次的最大值

f k , n = max ⁡ 1 ≤ i < n f i + S n − S i n − i + 1 f_{k,n}=\max_{1\leq i<n}\frac{f_i+S_n-S_i}{n-i+1} fk,n​=1≤i<nmax​n−i+1fi​+Sn​−Si​​

推一下式子发现很恶心

但注意到这个式子本身就是斜率的形式

可以看成所有 ( i − 1 , S i − f i ) (i-1,S_i-f_i) (i−1,Si​−fi​)到 ( n , S n ) (n,S_n) (n,Sn​)的最大斜率

意识流一波，维护一个下凸壳，每次最优决策是过 ( n , S n ) (n,S_n) (n,Sn​)的一条与凸壳切于端点的直线，可以三分一下……

注意到 h h h严格单调增，所以 ( n , S n ) (n,S_n) (n,Sn​)本身就组成了下凸壳

对于两个决策 k 1 , k 2 k_1,k_2 k1​,k2​,设 i i i是 k 2 k_2 k2​优于 k 1 k_1 k1​的 ( i , S i ) (i,S_i) (i,Si​),即 ( k 1 − 1 , S k 1 − f k 1 ) , ( k 2 − 1 , S k 2 − f k 2 ) , ( i , S i ) (k_1-1,S_{k_1}-f_{k_1}),(k_2-1,S_{k_2}-f_{k_2}),(i,S_i) (k1​−1,Sk1​​−fk1​​),(k2​−1,Sk2​​−fk2​​),(i,Si​)往上翘

在这里插入图片描述
如图， k i − 1 , i > k k 2 , i k_{i-1,i}>k_{k_2,i} ki−1,i​>kk2​,i​,又因为 k i , i + 1 > k i − 1 , i k_{i,i+1}>k_{i-1,i} ki,i+1​>ki−1,i​,所以对于 i + 1 i+1 i+1 k 2 k_2 k2​仍然更优

所以可以把 k 1 k_1 k1​弹掉

这样可以做到 O ( n k p ) O(nkp) O(nkp) 这里因为最多只能取 n − 1 n-1 n−1次合并，所以 n , k n,k n,k是同阶的

然后可以用低精度算 d p dp dp并记录决策，最后用高精度算一次 复杂度 O ( n k + n p ) O(nk+np) O(nk+np)

// This is an empty program with decimal lib

#include <cstdlib>
#include <cstring>
#include <string>
#include <cctype>
#include <cstdio>
// ---------- decimal lib start ----------

const int PREC = 3500;

class Decimal {
	public:
		Decimal();
		Decimal(const std::string &s);
		Decimal(const char *s);
		Decimal(int x);
		Decimal(long long x);
		Decimal(long 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;
		long 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, long double x);
		friend Decimal operator + (long 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, long double x);
		friend Decimal operator - (long 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 += (long double x);
		Decimal & operator += (const Decimal &b);
		
		Decimal & operator -= (int x);
		Decimal & operator -= (long long x);
		Decimal & operator -= (long 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, long double x);
		friend Decimal operator * (long double x, const Decimal &a);
		friend Decimal operator / (const Decimal &a, long double x);
		Decimal & operator *= (long double x);
		Decimal & operator /= (long 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(long 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;
}

long double Decimal::to_double() const {
	long double ret = integer;
	
	long 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, long double x) {
	return a + Decimal(x);
}

Decimal operator + (long double x, const Decimal &a) {
	return Decimal(x) + a;
}

Decimal operator - (const Decimal &a, long double x) {
	return a - Decimal(x);
}

Decimal operator - (long double x, const Decimal &a) {
	return Decimal(x) - a;
}

Decimal & Decimal::operator += (long double x) {
	*this = *this + Decimal(x);
	return *this;
}

Decimal & Decimal::operator -= (long 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 ans=0;
     char c=getchar();
     while (!isdigit(c)) c=getchar();
     while (isdigit(c)) ans=(ans<<3)+(ans<<1)+(c^48),c=getchar();
     return ans;
}
#include <algorithm>
#include <iostream>
#define MAXN 8005
using namespace std;
int s[MAXN],tot;
long double f[2][MAXN];
short key[MAXN][MAXN];
int q[MAXN],head,tail;
inline long double calc(int n,int i,int t){return (s[n]-s[i]+f[t^1][i])/(n-i+1);}
inline bool cmp(int i,int j,int k,int t){return (s[i]-f[t^1][i]-s[j]+f[t^1][j])*(i-k)<(s[i]-f[t^1][i]-s[k]+f[t^1][k])*(i-j);}
Decimal getans(int k,int n)
{
     if (!k) return s[1];
     return (s[n]-s[key[k][n]]+getans(k-1,key[k][n]))/(n-key[k][n]+1);
}
long double ans=0;
int pos;
int main()
{
     int n,k,p;
     n=read(),k=read(),p=read();
     s[tot=1]=read();
     for (int i=1;i<n;i++)
     {
	  int t=read();
	  if (t>s[1]) s[++tot]=t;
     }
     n=tot;
     sort(s+1,s+n+1);
     if (k>=n) k=n-1;
     for (int i=1;i<=n;i++) s[i]+=s[i-1],f[0][i]=s[1];
     f[1][1]=s[1];
     for (int i=1,t=1;i<=k;i++,t^=1)
     {
	  head=1,tail=1;
	  q[1]=1;
	  for (int j=2;j<=n;j++)
	  {
	       while (head<tail&&calc(j,q[head],t)<calc(j,q[head+1],t)) ++head;
	       f[t][j]=calc(j,key[i][j]=q[head],t);
	       while (head<tail&&cmp(j,q[tail],q[tail-1],t)) --tail;
	       q[++tail]=j;
	  }
     }
     cout<<getans(k,n).to_string(2*p);
     return 0;
}
Lstdo
关注
[NOI2016] 国王饮水记（luogu P1721）（超长慎入）
wizard_gray的博客
05-22 525
Description 跳蚤国有 n 个城市，伟大的跳蚤国王居住在跳蚤国首都中，即 1 号城市中。跳蚤国最大的问题就是饮水问题，由 于首都中居住的跳蚤实在太多，跳蚤国王又体恤地将分配给他的水也给跳蚤国居民饮用，这导致跳蚤国王也经常喝 不上水。于是，跳蚤国在每个城市都修建了一个圆柱形水箱，这些水箱完全相同且足够高。一个雨天后，第 i 个 城市收集到了高度为 hi 的水。由于地理和天气因素的影响，任何两个不同城市收集到的水高度互不相同。跳蚤国 王也请来蚂蚁工匠帮忙，建立了一个庞大的地下连通系统。跳蚤国王每次使用
决策单调性优化dp
Edward The Bunny 的博客
10-26 376
1D/1D。
[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...
P1721 [NOI2016]国王饮水记
qq_40511169的博客
01-21 801
题目描述 跳蚤国有 n 个城市，伟大的跳蚤国王居住在跳蚤国首都中，即 1号城市中。 跳蚤国最大的问题就是饮水问题，由于首都中居住的跳蚤实在太多，跳蚤国王又体恤地将分配给他的水也给跳蚤国居民饮用，这导致跳蚤国王也经常喝不上水。 于是，跳蚤国在每个城市都修建了一个圆柱形水箱，这些水箱完全相同且足够高。一个雨天后，第 i个城市收集到了高度为 hi 的水。由于地理和天气因素的影响，任何两
【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<=...
[Noi2016]国王饮水记
weixin_30847939的博客
05-12 66
来自FallDream的博客，未经允许，请勿转载，谢谢。 跳蚤国有 n 个城市，伟大的跳蚤国王居住在跳蚤国首都中，即 1 号城市中。跳蚤国最大的问题就是饮水问题，由于首都中居住的跳蚤实在太多，跳蚤国王又体恤地将分配给他的水也给跳蚤国居民饮用，这导致跳蚤国王也经常喝不上水。于是，跳蚤国在每个城市都修建了一个圆柱形水箱，这些水箱完全相同且足够高。一个雨天后，第 i 个城市收集到了高度为 hi 的...
动态规划优化探析：四边形不等式、斜率优化与单调队列
本文主要探讨动态规划的优化技术，包括四边形不等式、斜率优化、单调队列优化以及状态压缩动态规划。 一、动态规划基础 1.1 动态规划定义 动态规划是一种通过分解问题并存储子问题的解来求解最优化问题的方法。它...
[NOI2016]优秀的拆分_C++_优秀的拆分_
09-30
【NOI2016】优秀的拆分是一个编程竞赛题目，主要涉及的编程语言是C++，并采用了后缀自动机（Suffix Automaton）和点分治（Pointwise Divide and Conquer）这两种高级算法。这里我们将深入探讨这两个算法以及它们在...
NOI2016DAY2试题
10-24
以上是对NOI2016 Day2试题中“区间”和“国王饮水记”两道题目的详细分析。通过对题目背景、输入输出格式、样例说明以及解题思路的深入探讨，可以更好地理解这两道题目的解题方法和技术要点。希望这份分析能帮助参赛...
「BZOJ4654」「NOI2016」国王饮水记
infinity_edge的博客
06-30 488
题目描述 跳蚤国有 nnn 个城市，伟大的跳蚤国王居住在跳蚤国首都中，即 111 号城市中。 跳蚤国最大的问题就是饮水问题，由于首都中居住的跳蚤实在太多，跳蚤国王又体恤地将分配给他的水也给跳蚤国居民饮用，这导致跳蚤国王也经常喝不上水。 于是，跳蚤国在每个城市都修建了一个圆柱形水箱，这些水箱完全相同且足够高。一个雨天后，第 iii 个城市收集到了高度为 hihih_i 的水。由于地理和天气因素...
NOI2016 国王饮水记
andy_zeng123456的博客
10-23 163
NOI2016 国王饮水记 题意： ​ 自己看 题解： ​ 这题是大结论题，推荐这篇博客 ​ 结论找出来后不难做，但是，他卡你有没有看说明书！！！ #include<cstdio> #include<cstring> #include<iostream> #include<algorithm> #define fo(i,l,r) for(i...
[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,...
洛谷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}{...
NOI2016
weixin_30419799的博客
05-05 87
luoguP1712 [NOI2016]区间 这是一道送分题． 对于我这种每天抄题解不动脑子思维僵化得厉害的智障选手就是送命题． 一直在想端点排序各种Treap搞．．． 正解： 已知一些区间，如何判断是否满足条件？满足条件是有一个点被覆盖的次数大于m,那么用线段树可以解决这个问题．把区间按长度排序，从小往大考虑答案中选中最长区间的最大值．加入一个新的区间，线段树上区间加，当最大值仍大于m...
洛谷 P1721 国王饮水记 —— 斜率dp + 性质 + 高精度
Scar_Halo
04-10 280
题目链接：点我啊╭(╯^╰)╮ 题目大意：     nnn 个城市，每个城市有高为 hih_ihi​ 的水     使用 kkk 次地下连通系统，使得 111 号城市水位最高     使用一次地下连通系统，可以任意指定城市，水位然后保持一致    &...
蚯蚓(noip2016,贪心，单调性)
weixin_30826095的博客
07-27 145
题目描述 本题中，我们将用符号⌊c⌋表示对c向下取整，例如：⌊3.0⌋=⌊3.1⌋=⌊3.9⌋=3。 蛐蛐国最近蚯蚓成灾了！隔壁跳蚤国的跳蚤也拿蚯蚓们没办法，蛐蛐国王只好去请神刀手来帮他们消灭蚯蚓。 蛐蛐国里现在共有n只蚯蚓（n为正整数）。每只蚯蚓拥有长度，我们设第ii只蚯蚓的长度为ai​(i=1,2,…,n)，并保证所有的长度都是非负整数（即：可能存在长度为0...
小C饮水记
Freopen的博客
03-05 283
题目描述小C虽然没有参加NOI2016, 但当他看到"国王饮水记"这题时还是迅速秒掉了.小C认为这题太水了,于是他决定对这题进行加强.现在小C桌上有n杯水排成一行,第i杯水中有wi 单位体积的水. 他会选择一个区间[l, r],并拿一个初始为空的杯子(杯子的容积无限大),他可以重复无限次以下操作:• 选定任意一杯水i,i ∈ [l, r].• 使i和它拿着的杯子里的水的体积变为它们的平均值.小C希...
*UOJ#223. 【NOI2016】国王饮水记
a2850363633的博客
07-03 171
$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、付费专栏及课程。

余额充值