【USACO】2019 February Contest, Platinum题解

其他 2019-03-22 14:11:14 阅读次数: 0
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_39972971/article/details/87967914

**【T1】**Cow Dating

【题目链接】

【题解链接】

【思路要点】

  • 考虑如何快速计算一个区间 [ l , r ] [l,r] 的价值。
  • 定义二元组 ( x , y ) (x,y) 来描述一个区间， x x 表示区间中恰好有一个关键点的概率， y y 表示区间中没有关键点的概率。显然，对于两个区间 ( x 1 , y 1 ) , ( x 2 , y 2 ) (x_1,y_1),(x_2,y_2) ，上述信息是可以合并的，即 ( x 1 , y 1 ) + ( x 2 , y 2 ) = ( x 1 y 2 + x 2 y 1 , y 1 y 2 ) (x_1,y_1)+(x_2,y_2)=(x_1y_2+x_2y_1,y_1y_2) ，并且，该运算存在逆运算，即 ( x 1 , y 1 ) − ( x 2 , y 2 ) = ( x 1 − y 1 ∗ x 2 y 2 y 2 , y 1 y 2 ) (x_1,y_1)-(x_2,y_2)=(\frac{x_1-y_1*\frac{x_2}{y_2}}{y_2},\frac{y_1}{y_2}) 。
  • 那么，记录二元组的前缀和数组 s i s_i ，区间 [ l , r ] [l,r] 对应的二元组即为 s r − s l − 1 s_r-s_{l-1} 。
  • 考虑枚举 r r ，最优化 l l 的选取，即我们需要找到 l l ，最大化 x 1 − y 1 ∗ x 2 y 2 y 2 \frac{x_1-y_1*\frac{x_2}{y_2}}{y_2} 。记 k = x 2 y 2 k=\frac{x_2}{y_2} ，即最大化 x 1 − k ∗ y 1 x_1-k*y_1 ，注意到 k = x 2 y 2 k=\frac{x_2}{y_2} 是单调的，因此采用朴素的斜率优化即可。
  • 时间复杂度 O ( N ) O(N) 。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 5;
const long double eps = 1e-8;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
int n, l, r, st[MAXN];
ld a[MAXN], x[MAXN], y[MAXN];
bool exclude(int a, int b, int c) {
	return (y[b] - y[a]) * (x[c] - x[b]) - (y[c] - y[b]) * (x[b] - x[a]) > 0;
}
int main() {
	freopen("cowdate.in", "r", stdin);
	freopen("cowdate.out", "w", stdout);
	read(n), x[0] = 0, y[0] = 1;
	for (int i = 1; i <= n; i++) {
		int v; read(v);
		a[i] = v * 0.000001;
		x[i] = a[i] * y[i - 1] + (1 - a[i]) * x[i - 1];
		y[i] = y[i - 1] * (1 - a[i]);
	}
	ld res = 0;
	for (int i = n; i >= 0; i--) {
		ld k = x[i] / y[i];
		while (r - l + 1 >= 2 && x[st[l + 1]] - y[st[l + 1]] * k > x[st[l]] - y[st[l]] * k) l++;
		if (r > l) chkmax(res, (x[st[l]] - y[st[l]] * k) / y[i]);
		while (r - l + 1 >= 2 && exclude(st[r - 1], st[r], i)) r--;
		st[++r] = i;
	}
	int finalans = (res + eps) * 1000000;
	printf("%d\n", finalans);
	return 0;
}

**【T2】**Moorio Kart

【题目链接】

【题解链接】

【思路要点】

  • 考虑用所有的路径减去不合法的路径的长度。
  • 所有路径的长度是容易计算的，只需要考虑每一条边被统计了多少次。
  • 不合法的路径即长度不足 Y Y 的路径，可以通过每一个联通块内路径的数组卷积得到。
  • 注意到当且仅当联通块大小达到 O ( V ) O(\sqrt{V}) 的级别，不足 Y Y 的所有路径长度才有可能被全部取到，因此在卷积时特判数组中为 0 0 的位置跳过即可。
  • 时间复杂度 O ( N V V ) O(NV\sqrt{V}) 。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 3005;
const int P = 1e9 + 7;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
int n, m, x, y, ans, f[MAXN];
int cnt[MAXN][MAXN], res[MAXN];
vector <pair <int, int> > a[MAXN];
int power(int x, int y) {
	if (y == 0) return 1;
	int tmp = power(x, y / 2);
	if (y % 2 == 0) return 1ll * tmp * tmp % P;
	else return 1ll * tmp * tmp % P * x % P;
}
int F(int x) {
	if (f[x] == x) return x;
	else return f[x] = F(f[x]);
}
void update(int &x, int y) {
	x += y;
	if (x >= P) x -= P;
}
void calccnt(int pos, int fa, int from, int len) {
	if (pos > from) cnt[F(pos)][max(len, 0)]++;
	for (auto x : a[pos])
		if (x.first != fa) calccnt(x.first, pos, from, min(len + x.second, y));
}
int dfs(int pos, int fa, int out, int tot) {
	int res = 1;
	calccnt(pos, pos, pos, 0);
	for (auto x : a[pos])
		if (x.first != fa) {
			int tmp = dfs(x.first, pos, out, tot);
			update(ans, 1ll * tmp * (tot - tmp) * out % P * x.second % P);
			res += tmp;
		}
	return res;
}
int main() {
	freopen("mooriokart.in", "r", stdin);
	freopen("mooriokart.out", "w", stdout);
	read(n), read(m), read(x), read(y);
	for (int i = 1; i <= n; i++)
		f[i] = i;
	for (int i = 1; i <= m; i++) {
		int x, y, z;
		read(x), read(y), read(z);
		a[x].emplace_back(y, z);
		a[y].emplace_back(x, z);
		f[F(x)] = F(y);
	}
	static int cntp[MAXN], valp[MAXN];
	for (int i = 1; i <= n; i++)
		cntp[F(i)]++;
	int tmp = 1, com = 0, inv2 = power(2, P - 2);
	for (int i = 1; i <= n; i++)
		if (cntp[i]) {
			valp[i] = 1ll * cntp[i] * (cntp[i] - 1) % P * inv2 % P;
			tmp = 1ll * tmp * valp[i] % P, com++;
		}
	y -= x * com;
	for (int i = 1; i <= n; i++)
		if (cntp[i]) {
			dfs(i, i, 1ll * tmp * power(valp[i], P - 2) % P, cntp[i]);
			update(ans, 1ll * tmp * x % P);
		}
	if (y >= 0) {
		res[0] = 1;
		static int tmp[MAXN];
		for (int i = 1; i <= n; i++) {
			if (cntp[i] == 0) continue;
			memset(tmp, 0, sizeof(tmp));
			for (int j = 0; j <= y; j++) {
				int tnp = cnt[i][j];
				if (tnp == 0) continue;
				for (int k = 0; j + k <= y; k++)
					update(tmp[j + k], 1ll * tnp * res[k] % P);
			}
			memcpy(res, tmp, sizeof(tmp));
		}
		for (int i = 1; i <= y - 1; i++)
			update(ans, P - 1ll * res[i] * (i + x * com) % P);
	}
	for (int i = 1; i <= com - 1; i++)
		ans = 2ll * ans * i % P;
	writeln(ans);
	return 0;
}

**【T3】**Mowing Mischief

【题目链接】

【题解链接】

【思路要点】

  • 将所有点按照其横坐标为第一关键字，纵坐标为第二关键字排序，靠前的点无法转移到靠后的点。用树状数组进行动态规划，我们可以得到以每个点为结尾的选取序列的最优长度，并借此对点进行分层。
  • 属于同一层的点横坐标递增，纵坐标递减。
  • 接下来，我们只需要考虑层与层之间的转移。
  • 转移方程大致如下：
    d p i = M i n j   i n   t h e   p r e v i o u s   l a y e r   a n d   x j ≤ x i , y j ≤ y i { d p j + ( x i − x j ) ∗ ( y i − y j ) } dp_i=Min_{j\ in\ the\ previous\ layer\ and\ x_j\leq x_i,y_j\leq y_i}\{dp_j+(x_i-x_j)*(y_i-y_j)\}
    d p i = M i n j   i n   t h e   p r e v i o u s   l a y e r   a n d   x j ≤ x i , y j ≤ y i { d p j + x j y j − x i y j − x j y i ) } + x i y i dp_i=Min_{j\ in\ the\ previous\ layer\ and\ x_j\leq x_i,y_j\leq y_i}\{dp_j+x_jy_j-x_iy_j-x_jy_i)\}+x_iy_i
  • 考虑 j , k j,k 两处转移，令 j j 优于 k k ，则
    d p j + x j y j − x i y j − x j y i ≤ d p k + x k y k − x i y k − x k y i dp_j+x_jy_j-x_iy_j-x_jy_i\leq dp_k+x_ky_k-x_iy_k-x_ky_i
    ( y k − y j ) x i + ( x k − x j ) y i ≤ d p k + x k y k − d p j − x j y j (y_k-y_j)x_i+(x_k-x_j)y_i\leq dp_k+x_ky_k-dp_j-x_jy_j
  • 注意到 y k − y j y_k-y_j 和 x k − x j x_k-x_j 必然一正一负，因此这个半平面是一个斜率为正的半平面，一定会将下一层的点分为前后两部分，因而若排除掉 x j ≤ x i , y j ≤ y i x_j\leq x_i,y_j\leq y_i 的限制，该 d p dp 的转移具有决策单调性。
  • 那么，先用线段树分治处理转移，再用决策单调性优化转移即可。
  • 时间复杂度 O ( N L o g 2 N ) O(NLog^2N) 。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
const int MAXV = 1e6 + 5;
const long long INF = 1e18;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
struct BinaryIndexTree {
	int n, a[MAXV];
	void init(int x) {
		n = x;
		memset(a, 0, sizeof(a));
	}
	void modify(int x, int d) {
		for (int i = x; i <= n; i += i & -i)
			chkmax(a[i], d);
	}
	int query(int x) {
		int ans = 0;
		for (int i = x; i >= 1; i -= i & -i)
			chkmax(ans, a[i]);
		return ans;
	}
} BIT;
int n, m, t, s, layer[MAXN];
ll dp[MAXN];
pair <int, int> p[MAXN];
vector <int> pos[MAXN];
struct SegmentTree {
	struct Node {
		int lc, rc;
		vector <int> trans;
	} a[MAXN * 2];
	int n, size, root;
	vector <int> point, tmp;
	void build(int &root, int l, int r) {
		root = ++size;
		a[root].lc = a[root].rc = 0;
		a[root].trans.clear();
		if (l == r) return;
		int mid = (l + r) / 2;
		build(a[root].lc, l, mid);
		build(a[root].rc, mid + 1, r);
	}
	void init(vector <int> tmp) {
		point = tmp;
		n = tmp.size();
		root = size = 0;
		build(root, 0, n - 1);
	}
	void modify(int root, int l, int r, int x) {
		if (p[x].first >= p[point[r]].first && p[x].second >= p[point[l]].second) {
			a[root].trans.push_back(x);
			return;
		}
		if (p[x].first <= p[point[l]].first || p[x].second <= p[point[r]].second) return;
		int mid = (l + r) / 2;
		modify(a[root].lc, l, mid, x);
		modify(a[root].rc, mid + 1, r, x);
	}
	void modify(int x) {
		modify(root, 0, n - 1, x);
	}
	void solve(int l, int r, int ql, int qr) {
		ll ans = INF; int from = 0;
		int mid = (l + r) / 2, now = tmp[mid];
		for (int i = ql; i <= qr; i++) {
			int pos = point[i];
			ll res = dp[pos] + 1ll * (p[now].first - p[pos].first) * (p[now].second - p[pos].second);
			if (res < ans) {
				ans = res;
				from = i;
			}
		}
		chkmin(dp[now], ans);
		if (l < mid) solve(l, mid - 1, from, qr);
		if (mid < r) solve(mid + 1, r, ql, from);
	}
	void work(int root, int l, int r) {
		if (a[root].trans.size()) {
			tmp = a[root].trans;
			solve(0, tmp.size() - 1, l, r); 
		}
		if (l == r) return;
		int mid = (l + r) / 2;
		work(a[root].lc, l, mid);
		work(a[root].rc, mid + 1, r);
	}
	void work() {
		work(root, 0, n - 1);
	}
} ST;
int main() {
	freopen("mowing.in", "r", stdin);
	freopen("mowing.out", "w", stdout);
	read(n), read(t);
	for (int i = 1; i <= n; i++)
		read(p[i].first), read(p[i].second);
	sort(p + 1, p + n + 1), BIT.init(t);
	for (int i = 1; i <= n; i++) {
		layer[i] = BIT.query(p[i].second) + 1;
		BIT.modify(p[i].second, layer[i]);
		pos[layer[i]].push_back(i);
		chkmax(m, layer[i]);
	}
	for (auto x : pos[1])
		dp[x] = 1ll * p[x].first * p[x].second;
	for (int i = 2; i <= m; i++) {
		ST.init(pos[i - 1]);
		for (auto x : pos[i]) {
			dp[x] = INF;
			ST.modify(x);
		}
		ST.work();
	}
	ll ans = INF;
	for (auto x : pos[m])
		chkmin(ans, dp[x] + 1ll * (t - p[x].first) * (t - p[x].second));
	writeln(ans);
	return 0;
}

猜你喜欢

转载自blog.csdn.net/qq_39972971/article/details/87967914
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
BPM为企业带来的实际利益
好程序员web前端分享css常用属性缩写
Java文件下载（excel）
css样式的动态添加及显示和隐藏等零碎用法
axios全局配置以及拦截器
使用Logstash来实时同步MySQL和log日志数据到ES
C++获取当前时间（年月日、时分秒、毫秒）
Odoo产品分析 (四) -- 工具板块(11) -- 网站即时聊天(1)
Java环境配置正确，但是java、javac、java -version均返回“不是内部或外部命令，也不是可运行的程序或批处理文件”？
01 官网下载各种CentOS教程（超详细版）
每日归档
更多
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022