奶牛的跳格子游戏

最新推荐文章于 2025-04-15 15:33:04 发布
最新推荐文章于 2025-04-15 15:33:04 发布
阅读量265 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/C2022lihan/article/details/114887105

前言

我也没弄懂TJ的意思

样例分析图
在这里插入图片描述

题解部分

题面略；

1.状态：dp[i]dp[i]dp[i]，表示从 000 开始走到 iii 再走回去所得的钱的最大值
2.转移
状态转移方程

记 pre[i]pre[i]pre[i] 表示 ∑j=1ia[j](a[j]>0)\sum_{j = 1}^{i} a[j](a[j] > 0)∑j=1i​a[j](a[j]>0)

则 dp[i]=a[i]+a[j+1]+dp[j]+pre[i−1]−pre[j+1]dp[i] = a[i] + a[j + 1] + dp[j] + pre[i - 1] - pre[j + 1]dp[i]=a[i]+a[j+1]+dp[j]+pre[i−1]−pre[j+1]

状态转移的证明

可以参考这张图（虽然很丑）

在这里插入图片描述

我们假设走到 iii 后开始回去的第一步是 jjj

红色部分的含义（状态转移中 dp[i]dp[i]dp[i] 和 dp[j]dp[j]dp[j] 之间的关系）：

条件

一： jjj 满足条件 i−j<=xi - j <= xi−j<=x。

二：j+1j + 1j+1 一定是我们走过的，所以我们必须选择 a[j+1]a[j + 1]a[j+1]。

三：由于我们走到了 iii， 所以我们必须选择 a[i]a[i]a[i]。

四：j+1j + 1j+1出发后走到的任何一个位置(不超过 iii)都满足要求（即可以选择任意一个不超过 iii 的点)

我们由图，我们从 jjj 走到了 j+1j + 1j+1，假设下一步走到的位置是 kkk

因为: i−j<=x,k<ii - j <= x, k < ii−j<=x,k<i

不等式缩放可知:

k−j<=xk - j <= xk−j<=x

即证

四引理：由于我们可以随意在 (j + 1, i)中选点，所以我们为了 moneymoneymoney 最多，所以肯定选择正数。

暴力枚举返回时走的第一步，暴力转移就行了，只要注意几个特殊情况：

一：直接回到 老家 000 号点.

二：返回时的第一步为 i−1i - 1i−1

O(n2)O (n ^ 2)O(n2) 暴力代码

#include <map>
#include <set>
#include <cmath>
#include <stack>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

#define int long long
#define LL long long
#define ULL unsigned long long

template <typename T> int read (T &x) {x = 0; T f = 1;char tem = getchar ();while (tem < '0' || tem > '9') {if (tem == '-') f = -1;tem = getchar ();}while (tem >= '0' && tem <= '9') {x = (x << 1) + (x << 3) + tem - '0';tem = getchar ();}x *= f; return 1;}
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> T Max (T x, T y) { return x > y ? x : y; }
template <typename T> T Min (T x, T y) { return x < y ? x : y; }
template <typename T> T Abs (T x) { return x > 0 ? x : -x; }

const int Maxn = 25 * 1e4;
const LL Inf = 1e18;

int n, x;
LL a[Maxn + 5], pre[Maxn + 5], dp[Maxn + 5];

LL Answer (int l, int r) {
	if (l <= r)
		return pre[r] - pre[l - 1];
	else
		return 0;
}

signed main () {
	scanf ("%lld %lld", &n, &x);
	for (int i = 1; i <= n; i++) {
		scanf ("%lld", &a[i]);
		pre[i] = pre[i - 1];
		if (a[i] > 0) pre[i] += a[i];
	}
	
	LL ans = 0;
	for (int i = 1; i <= n; i++) {
		
		dp[i] = -Inf;
		if (i <= x) dp[i] = Max (dp[i], a[i] + Answer (1, i - 1));
		dp[i] = Max (dp[i], a[i] + dp[i - 1]);
		for (int j = Max ((LL)0, i - x); j < i - 1; j++) {
			dp[i] = Max (dp[i], a[i] + a[j + 1] + dp[j] + Answer (j + 2, i - 1));
		}	
		ans = Max (ans, dp[i]);
	}
	
	printf ("%lld", ans);
	return 0;
}

我们考虑优化

假设有两个决策点 jjj 和 kkk

令 w(j,i)=a[i]+a[j+1]+dp[j]+pre[i−1]−pre[j+1]w (j, i) = a[i] + a[j + 1] + dp[j] + pre[i - 1] - pre[j + 1]w(j,i)=a[i]+a[j+1]+dp[j]+pre[i−1]−pre[j+1]

有这样一个结论：

若 w(j,i)>w(k,i)w(j, i) > w (k, i)w(j,i)>w(k,i)， 则 w(j,i+1)>w(k,i+1)w (j, i + 1) > w (k, i + 1)w(j,i+1)>w(k,i+1)

其实这个证明真的非常简单，但担心有人说我水题解，我还是写一些吧

由题意得:

a[i]+a[j+1]+dp[j]+pre[i−1]−pre[j+1]>a[i]+a[k+1]+dp[k]+pre[i−1]−pre[k+1]a[i] + a[j + 1] + dp[j] + pre[i - 1] - pre[j + 1] > a[i] + a[k + 1] + dp[k] + pre[i - 1] - pre[k + 1]a[i]+a[j+1]+dp[j]+pre[i−1]−pre[j+1]>a[i]+a[k+1]+dp[k]+pre[i−1]−pre[k+1]

则：

a[j+1]+dp[j]−pre[j+1]>a[k+1]+dp[k]−pre[k+1]a[j + 1] + dp[j] - pre[j + 1] > a[k + 1] + dp[k] - pre[k + 1]a[j+1]+dp[j]−pre[j+1]>a[k+1]+dp[k]−pre[k+1]

所以：

a[i+1]+a[j+1]+dp[j]+pre[i]−pre[j+1]>a[i+1]+a[k+1]+dp[k]+pre[i]−pre[k+1]a[i + 1] + a[j + 1] + dp[j] +pre[i] - pre[j + 1] > a[i + 1] + a[k + 1] + dp[k] + pre[i] - pre[k + 1]a[i+1]+a[j+1]+dp[j]+pre[i]−pre[j+1]>a[i+1]+a[k+1]+dp[k]+pre[i]−pre[k+1]

又因为 dp[i]=max⁡ji−x<=j<i−1w(j)dp[i] = \max_{j}^{i - x <= j < i - 1}{w (j)}dp[i]=maxji−x<=j<i−1​w(j).

所以我们可以用单调队列维护一个下降的 w(j)w (j)w(j) 就可以啦。

之前未写证明的 SBSBSB 代码，有点冗长

时间复杂度: O(n)

#include <map>
#include <set>
#include <cmath>
#include <stack>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

#define int long long
#define LL long long
#define ULL unsigned long long

template <typename T> int read (T &x) {x = 0; T f = 1;char tem = getchar ();while (tem < '0' || tem > '9') {if (tem == '-') f = -1;tem = getchar ();}while (tem >= '0' && tem <= '9') {x = (x << 1) + (x << 3) + tem - '0';tem = getchar ();}x *= f; return 1;}
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> T Max (T x, T y) { return x > y ? x : y; }
template <typename T> T Min (T x, T y) { return x < y ? x : y; }
template <typename T> T Abs (T x) { return x > 0 ? x : -x; }

const int Maxn = 25 * 1e4;
const LL Inf = 1e18;

int n, x;
LL a[Maxn + 5], pre[Maxn + 5], dp[Maxn + 5];

LL Answer (int l, int r) {
	if (l <= r)
		return pre[r] - pre[l - 1];
	else
		return 0;
}

int Get_Val (int j, int i) {
	return a[j + 1] + dp[j] + Answer (j + 2, i - 1);
}

int hh = 1, tt = 0, q[Maxn + 5];
void add (int j, int i) {
	while (hh <= tt && Get_Val (q[tt], i) <= Get_Val (j, i)) {
		tt--;
	}
	q[++tt] = j;
}

signed main () {
	scanf ("%lld %lld", &n, &x);
	for (int i = 1; i <= n; i++) {
		scanf ("%lld", &a[i]);
		pre[i] = pre[i - 1];
		if (a[i] > 0) pre[i] += a[i];
	}
	
	LL ans = 0;
	for (int i = 1; i <= n; i++) {
		dp[i] = -Inf;
		if (i <= x) dp[i] = Max (dp[i], a[i] + Answer (1, i - 1));
		dp[i] = Max (dp[i], a[i] + dp[i - 1]);	
		while (hh <= tt && q[hh] < i - x) hh++;
		if (hh < tt) dp[i] = Max (dp[i], a[i] + Get_Val (q[hh], i));
		add (i - 1, i + 1);
		ans = Max (ans, dp[i]);
	}
	
	printf ("%lld", ans);
	return 0;
}

写了证明后，发现有些东西可以约掉，维护的单调队列的对象更加简洁了。

#include <map>
#include <set>
#include <cmath>
#include <stack>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

#define int long long
#define LL long long
#define ULL unsigned long long

template <typename T> int read (T &x) {x = 0; T f = 1;char tem = getchar ();while (tem < '0' || tem > '9') {if (tem == '-') f = -1;tem = getchar ();}while (tem >= '0' && tem <= '9') {x = (x << 1) + (x << 3) + tem - '0';tem = getchar ();}x *= f; return 1;}
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> T Max (T x, T y) { return x > y ? x : y; }
template <typename T> T Min (T x, T y) { return x < y ? x : y; }
template <typename T> T Abs (T x) { return x > 0 ? x : -x; }

const int Maxn = 25 * 1e4;
const LL Inf = 1e18;

int n, x;
LL a[Maxn + 5], pre[Maxn + 5], dp[Maxn + 5];

LL Answer (int l, int r) {
	if (l <= r)
		return pre[r] - pre[l - 1];
	else
		return 0;
}

int Get_Val (int j) {
	return a[j + 1] + dp[j];
}

int hh = 1, tt = 0, q[Maxn + 5];
void add (int j) {
	while (hh <= tt && Get_Val (q[tt]) + Answer (q[tt] + 2, j + 1) <= Get_Val (j)) {
		tt--;
	}
	q[++tt] = j;
}

signed main () {
	scanf ("%lld %lld", &n, &x);
	for (int i = 1; i <= n; i++) {
		scanf ("%lld", &a[i]);
		pre[i] = pre[i - 1];
		if (a[i] > 0) pre[i] += a[i];
	}
	
	LL ans = 0;
	for (int i = 1; i <= n; i++) {
		
		dp[i] = -Inf;
		if (i <= x) dp[i] = Max (dp[i], a[i] + Answer (1, i - 1));
		dp[i] = Max (dp[i], a[i] + dp[i - 1]);
		
		while (hh <= tt && q[hh] < i - x) hh++;
		if (hh < tt) dp[i] = Max (dp[i], a[i] + a[q[hh] + 1] + dp[q[hh]] + Answer (q[hh] + 2, i - 1));
		add (i - 1);
		
		ans = Max (ans, dp[i]);
	}
	
	printf ("%lld", ans);
	return 0;
}
BZOJ1915 [Usaco2010 Open]奶牛的跳格子游戏
老臣
05-18 729
gold组好多单调队列优化的dp啊，感觉自己可以搞个爽了。 用f[i]表示既在去的时候跳到i，又在回来时跳到i-1的最大钱数，再维护一个前缀和s[i]，记录从1到i所有钱数大于0的格子的钱数和，可以列出方程 f[i]=max(f[i],f[j]+v[i]+v[i-1]+s[i-2]-s[j]) 然后用单调队列维护一下j就好了。#include<cstdio> #include<cstring>
【Usaco2010 Open Gold-1】奶牛的跳格子游戏
weixin_43823476的博客
09-21 356
题目 Description 奶牛们正在回味童年，玩一个类似跳格子的游戏，在这个游戏里，奶牛们在草地上画了一行N个格子，(3 <=N <= 250,000)，编号为1..N。就像任何一个好游戏一样，这样的跳格子游戏也有奖励！第i个格子标有一个数字V_i(-2,000,000,000 <=V_i <= 2,000,000,000)表示这个格子的钱。奶牛们想看看最后谁能得到最多的钱。规则很简单： * 每个奶牛从0号格子出发。(0号格子在1号之前，那里没钱) * 她向N号格子进行一系列
BZOJ 1915 [Usaco2010 Open]奶牛的跳格子游戏
weixin_34032827的博客
10-17 204
BZOJ_1915     如果我们把一对相邻的来去经过的格子看成一个研究对象的话，那么相邻研究对象之间距离不超过K，而且相邻研究对象之间所有正数的格子都可以在向前跳的过程中经过。抽象成这样的模型之后就可以用单调队列+dp搞定最后一个研究对象在位置i时的最优解。这时由于在向前跳的过程中还可能经过最右边研究对象的右边的一些距离不超过K-1的正数的格子，最后扫一遍dp出的最优解，将这些格子一并加起来...
【BZOJ1915】[Usaco2010 Open]奶牛的跳格子游戏 DP+单调队列
aodanchui1057的博客
02-18 256
【BZOJ1915】[Usaco2010 Open]奶牛的跳格子游戏 Description 奶牛们正在回味童年，玩一个类似跳格子的游戏，在这个游戏里，奶牛们在草地上画了一行N个格子，(3 <=N <= 250,000)，编号为1..N。就像任何一个好游戏一样，这样的跳格子游戏也有奖励！第i个格子标有一个数字V_i(-2,000,000,000 <=V_i <...
2018.10.14 bzoj1915: 奶牛的跳格子游戏（单调队列优化dp）
苟为蒟蒻又何妨
10-14 257
传送门 NOIP练习题。 f[i]f[i]f[i]表示去的时候选了iii且回来的时候第一步走的是i−1i-1i−1的最优值。 显然f[i]=maxf[i]=maxf[i]=max{f[j]−sum[j]f[j]-sum[j]f[j]−sum[j]}+sum[i−2]+a[i]+a[i−1]+sum[i-2]+a[i]+a[i-1]+sum[i−2]+a[i]+a[i−1] 直接上单调队列优化就行...
【JZOJ3128】跳格子
路人黑的纸巾
04-22 345
Description 奶牛们正在回味童年，玩一个类似跳格子的游戏，在这个游戏里，奶牛们在草地上画了一行N个格子，(3 <=N <= 250,000)，编号为1…N。 就像任何一个好游戏一样，这样的跳格子游戏也有奖励！第i个格子标有一个数字V_i(-2,000,000,000 <=V_i <= 2,000,000,000)表示这个格子的钱。奶牛们想看看最后谁能得到最多的钱。...
【DFS】[Usaco2015 Feb]Cow Hopscotch（C++）
liuzich的博客
08-23 413
Description 正如人们喜欢玩游戏“跳房子”一样，农夫John的奶牛也发明了一些适合它们玩的“跳房子”游戏。尽管这些重达 近一吨的笨拙动物玩游戏总是以灾难结束，但这并不妨碍它们每天下午玩游戏的热情。这个游戏在一个R*C的网格 （2≤R≤15,2≤C≤15）中进行，其中每一个方格是红色或者蓝色。奶牛一开始在左上角的格子中，通过一系列有 效的跳跃，移动到右下角格子中。一个跳跃是有效的，当且仅当...
【教学类-32-05】20250414十二生肖3.0中2班游戏
最新发布
reasonsummer的博客
04-15 720
【教学类-32-05】20250414十二生肖3.0中2班游戏
2021.07.07【普及组】模拟赛C组比赛解析
Don't Carry
07-07 597
2021.07.07【普及组】模拟赛C组比赛解析 谷仓的安保(passwd) 题目描述 Farmer John给谷仓安装了一个新的安全系统，并且要给牛群中的每一个奶牛分配一个有效的密码。一个有效的密码由L(3 <= L <= 15)个小写字母(来自传统的拉丁字母集’a’…‘z’)组成，至少有一个元音(‘a’, ‘e’, ‘i’, ‘o’, 或 ‘u’)和两个辅音(除去元音以外的音节)，并且是按字母表顺序出现的(例如，'abc’是有效的，而’bac’不是) 。给定一个期望长度L和C个小写字母，写一
2020.5.6 C组模拟赛题解
绫
07-05 1502
目录： T1：移动奶牛 T2：电压放大器 T3：步行 T4：数数 第一题USACO 后三题是市选…… 正题： T1：移动奶牛 题目描述 Farmer John的三头获奖奶牛Bessie、Elsie和Mildred，总是会迷路走到农场上遥远的地方去！他需要你帮助将她们一起赶回来。 农场的草地大体是一块狭长的区域——我们可以将其想象成一条数轴，奶牛可以占据数轴上的任意整数位置。这3头奶牛现在正位于不同的整数位置，Farmer John想要移动她们，使得她们占据三个相邻的位置（例如，位置6、7、8）。 不幸的是
BZOJ 1915: [Usaco2010 Open]奶牛的跳格子游戏 单调队列优化dp
BlackJack
05-19 751
1915: [Usaco2010 Open]奶牛的跳格子游戏 Time Limit: 4 Sec  Memory Limit: 64 MB Submit: 281  Solved: 110 [Submit][Status][Discuss] Description 奶牛们正在回味童年，玩一个类似跳格子的游戏，在这个游戏里，奶牛们在草地上画了一行N个格子，(3 <=N <= 250,0
奶牛跳一跳
qq_43544587的博客
01-04 312
奶牛跳一跳 描述 每年奶牛们都会举行一个特别的跳房子的活动，其中包括在河中小心地从石头跳到另一块石头上。这次发生在一条长而直的河流上，在河的一端有一块石头，另一端有一块石头，两者相聚L(1&lt;=L&lt;=1000000000）。在开始和结束的岩石之间的河流中，N（0&lt;=N＜=50000）出现更多的岩石，每一个距离开始的岩石di（0＜DI＜L）。 为了玩游戏，每头奶牛依次从起始岩石开始，...
USACO 2015 February Contest Gold T1: Cow Hopscotch
bane4238的博客
07-19 244
题目大意 就像人类喜欢跳格子游戏一样，FJ的奶牛们发明了一种新的跳格子游戏。虽然这种接近一吨的笨拙的动物玩跳格子游戏几乎总是不愉快地结束，但是这并没有阻止奶牛们在每天下午参加跳格子游戏 游戏在一个R*C (2 <= R <= 750, 2 <= C <= 750)的网格上进行，每个格子有一个取值在1-k之间的整数标号，奶牛开始在左上角的格子，目的是通过若干次跳...
C++动态规划及单调队列的优化—————拥挤的奶牛（挤奶牛Crowded Cows）和弹簧高跷（POGO的牛Pogo-Cow）
C2020lax的博客
01-03 1743
题目描述： FJ的n头奶牛（1<=n<=50000）在被放养在一维的牧场。第i头奶牛站在位置x(i)，并且x(i)处有一个高度值h(i)（1<=x(i),h(i)<=1000000000）。 一头奶牛感觉到拥挤当且仅当它的左右两端都有一头奶牛所在的高度至少是它的2倍，且和它的距离最多为D。尽管感到拥挤的奶牛会产生更少的牛奶，FJ还是想知道一共有多上感到拥挤的奶牛。请你帮...
洛谷P3120 [USACO15FEB]Cow Hopscotch
dezhen7015的博客
03-11 256
题目描述 Just like humans enjoy playing the game of Hopscotch, Farmer John&apos;s cows have invented a variant of the game for themselves to play. Being played by clumsy animals weighing nearly ...
洛谷 P3120 [USACO15FEB]牛跳房子（金）Cow Hopscotch (Gold)
weixin_30507481的博客
07-02 246
P3120 【USACO15FEB】牛跳房子（金）Cow Hopscotch (Gold) 就像人类喜欢跳格子游戏一样，FJ的奶牛们发明了一种新的跳格子游戏。虽然这种接近一吨的笨拙的动物玩跳格子游戏几乎总是不愉快地结束，但是这并没有阻止奶牛们在每天下午参加跳格子游戏 游戏在一个R×C的网格上进行，每个格子有一个取值在1-k之间的整数标号，奶牛开始在左上角的格子，目的是通过若干次跳跃后到达右下角的格...
[C/C++]跳格子游戏 - 2019校招编程刷题
weixin_43545225的博客
04-26 6646
[C/C++]跳格子游戏 - 2019校招编程刷题 参考链接 题目描述 假设你正在玩跳格子（所有格子排成一个纵列）游戏。需要 跳完n 个格子你才能抵达终点。 每次你可以跳 1 或 2 个格子。你有多少种不同的方法可以到达终点呢？ 注意：给定 n 是一个正整数。 输入描述 格子数n 输出描述 跳完n个格子到达终点的方法 输入例子1: 2 输出例子1: 2 思路： 列举不同n值的方法...
模拟题 ： 棋盘游戏
Heret1c
03-31 3021
【题目描述】Alice 和 Bob 在玩一个游戏，给出一张 n × m 的棋盘，上面有一些点是障碍，游戏的开始，Alice 选定棋盘 上任意一个不是障碍的格子，并且将一枚棋子放在其中，然后 Bob 先手，两人轮流操作棋子，每次操作必 须将棋子从当前位置移动到一个相邻的无障碍且未经过的格子（即每个格子不允许经过两次），不能操作的 人输，如果两人都按照最优策略操作，请问初始时 Alice 将棋子放
序列的计算 (图解
C2022lihan的博客
01-14 1615
1.前言 被初一巨佬吊打 2. 1.状态转移方程 dp[i][j]=dp[i−1][j]∗(i−j)+dp[i−1][j]∗jdp[i][j] = dp[i - 1][j] * (i - j) + dp[i - 1][j] * jdp[i][j]=dp[i−1][j]∗(i−j)+dp[i−1][j]∗j 2.推导 分两种情况 ①： ②: 综上所述： dp[i+1][j]=dp[i][j]∗(j+1)+dp[i][j−1]∗(i−j+1)dp[i + 1][j] = dp[i][j] * (j + 1)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值