奶牛的跳格子游戏

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

前言

我也没弄懂TJ的意思

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

题解部分

题面略；

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

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

则 d p [ i ] = a [ i ] + a [ j + 1 ] + d p [ j ] + p r e [ i − 1 ] − p r e [ 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]

状态转移的证明

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

在这里插入图片描述

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

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

条件

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

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

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

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

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

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

不等式缩放可知:

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

即证

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

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

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

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

O ( n 2 ) 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;
}

我们考虑优化

假设有两个决策点 j j j 和 k k k

令 w ( j , i ) = a [ i ] + a [ j + 1 ] + d p [ j ] + p r e [ i − 1 ] − p r e [ 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 ] + d p [ j ] + p r e [ i − 1 ] − p r e [ j + 1 ] > a [ i ] + a [ k + 1 ] + d p [ k ] + p r e [ i − 1 ] − p r e [ 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 ] + d p [ j ] − p r e [ j + 1 ] > a [ k + 1 ] + d p [ k ] − p r e [ 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 ] + d p [ j ] + p r e [ i ] − p r e [ j + 1 ] > a [ i + 1 ] + a [ k + 1 ] + d p [ k ] + p r e [ i ] − p r e [ 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]

又因为 d p [ i ] = max ⁡ j i − x < = j < i − 1 w ( 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) 就可以啦。

之前未写证明的 S B SB SB 代码，有点冗长

时间复杂度: 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;
}
IDSY QAQ
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BZOJ1915 [Usaco2010 Open]奶牛的跳格子游戏
老臣
05-18 693
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 308
题目 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 169
BZOJ_1915     如果我们把一对相邻的来去经过的格子看成一个研究对象的话，那么相邻研究对象之间距离不超过K，而且相邻研究对象之间所有正数的格子都可以在向前跳的过程中经过。抽象成这样的模型之后就可以用单调队列+dp搞定最后一个研究对象在位置i时的最优解。这时由于在向前跳的过程中还可能经过最右边研究对象的右边的一些距离不超过K-1的正数的格子，最后扫一遍dp出的最优解，将这些格子一并加起来...
【BZOJ1915】[Usaco2010 Open]奶牛的跳格子游戏 DP+单调队列
aodanchui1057的博客
02-18 219
【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 228
传送门 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 310
Description 奶牛们正在回味童年，玩一个类似跳格子的游戏，在这个游戏里，奶牛们在草地上画了一行N个格子，(3 <=N <= 250,000)，编号为1…N。 就像任何一个好游戏一样，这样的跳格子游戏也有奖励！第i个格子标有一个数字V_i(-2,000,000,000 <=V_i <= 2,000,000,000)表示这个格子的钱。奶牛们想看看最后谁能得到最多的钱。...
跳房子
huangja的博客
10-06 2183
奶牛们按不太传统的方式玩起了小孩子们玩的"跳房子"游戏。奶牛们创造了一个5x5的、由与x,y轴平行的数字组成的直线型网格，而不是用来在里面跳的、线性排列的、带数字的方格。然后他们熟练地在网格中的数字中跳：向前跳、向后跳、向左跳、向右跳(从不斜过来跳)，跳到网格中的另一个数字上。他们再这样跳啊跳(按相同规则)，跳到另外一个数字上(可能是已经跳过的数字)。一共在网格内跳过五次后，他们的跳跃构建了一个六
6.7练习赛题解
蒟蒻午时已到的博客
06-08 401
C题下标打错错90分5555 A.移棋子游戏 问题描述 猫王和老板在玩一个游戏。桌面上一行有n个格子，一些格子中放着棋子。猫王和老板轮流选择如下方式中的一种移动棋子（图示中o表示棋子，*表示空着的格子）: 1）当一枚棋子的右边是空格子的话，可以将这枚棋子像右移动一格。 o* -&gt; *o 2）当一枚棋子的右边连续两个都有棋子，并且这个棋子往右边数第3格没有棋子，那...
2021.07.07【普及组】模拟赛C组比赛解析
Don't Carry
07-07 483
2021.07.07【普及组】模拟赛C组比赛解析 谷仓的安保(passwd) 题目描述 Farmer John给谷仓安装了一个新的安全系统，并且要给牛群中的每一个奶牛分配一个有效的密码。一个有效的密码由L(3 <= L <= 15)个小写字母(来自传统的拉丁字母集’a’…‘z’)组成，至少有一个元音(‘a’, ‘e’, ‘i’, ‘o’, 或 ‘u’)和两个辅音(除去元音以外的音节)，并且是按字母表顺序出现的(例如，'abc’是有效的，而’bac’不是) 。给定一个期望长度L和C个小写字母，写一
BZOJ 1915: [Usaco2010 Open]奶牛的跳格子游戏 单调队列优化dp
BlackJack
05-19 693
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 270
奶牛跳一跳 描述 每年奶牛们都会举行一个特别的跳房子的活动，其中包括在河中小心地从石头跳到另一块石头上。这次发生在一条长而直的河流上，在河的一端有一块石头，另一端有一块石头，两者相聚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 206
题目大意 就像人类喜欢跳格子游戏一样，FJ的奶牛们发明了一种新的跳格子游戏。虽然这种接近一吨的笨拙的动物玩跳格子游戏几乎总是不愉快地结束，但是这并没有阻止奶牛们在每天下午参加跳格子游戏 游戏在一个R*C (2 <= R <= 750, 2 <= C <= 750)的网格上进行，每个格子有一个取值在1-k之间的整数标号，奶牛开始在左上角的格子，目的是通过若干次跳...
C++动态规划及单调队列的优化—————拥挤的奶牛（挤奶牛Crowded Cows）和弹簧高跷（POGO的牛Pogo-Cow）
C2020lax的博客
01-03 1609
题目描述： 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 206
题目描述 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 217
P3120 【USACO15FEB】牛跳房子（金）Cow Hopscotch (Gold) 就像人类喜欢跳格子游戏一样，FJ的奶牛们发明了一种新的跳格子游戏。虽然这种接近一吨的笨拙的动物玩跳格子游戏几乎总是不愉快地结束，但是这并没有阻止奶牛们在每天下午参加跳格子游戏 游戏在一个R×C的网格上进行，每个格子有一个取值在1-k之间的整数标号，奶牛开始在左上角的格子，目的是通过若干次跳跃后到达右下角的格...
[C/C++]跳格子游戏 - 2019校招编程刷题
weixin_43545225的博客
04-26 6255
[C/C++]跳格子游戏 - 2019校招编程刷题 参考链接 题目描述 假设你正在玩跳格子（所有格子排成一个纵列）游戏。需要 跳完n 个格子你才能抵达终点。 每次你可以跳 1 或 2 个格子。你有多少种不同的方法可以到达终点呢？ 注意：给定 n 是一个正整数。 输入描述 格子数n 输出描述 跳完n个格子到达终点的方法 输入例子1: 2 输出例子1: 2 思路： 列举不同n值的方法...
模拟题 ： 棋盘游戏
Heret1c
03-31 2836
【题目描述】Alice 和 Bob 在玩一个游戏，给出一张 n × m 的棋盘，上面有一些点是障碍，游戏的开始，Alice 选定棋盘 上任意一个不是障碍的格子，并且将一枚棋子放在其中，然后 Bob 先手，两人轮流操作棋子，每次操作必 须将棋子从当前位置移动到一个相邻的无障碍且未经过的格子（即每个格子不允许经过两次），不能操作的 人输，如果两人都按照最优策略操作，请问初始时 Alice 将棋子放
序列的计算 (图解
C2022lihan的博客
01-14 1450
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)
「CSP-S 2021 括号序列」题解
C2022lihan的博客
10-27 960
考场挂分器，送分题变成送命题。 一、状态： 令 dp[i][j]dp[i][j]dp[i][j] 表示 [i,j][i, j][i,j] 这个区间内组成超级括号序列的方案数 令 f[i][j]f[i][j]f[i][j] 表示在 dp[i][j]dp[i][j]dp[i][j] 的要求上，添加限制：方案中，括号 iii, jjj 匹配。 令 ans[i][j]ans[i][j]ans[i][j] 表示 [i,j][i, j][i,j] 这个区间能不能做到 [l,r][l, r][l,r] 全为 “*”。
奶牛的跳房子游戏：解题报告与代码
这个问题是关于解决一个非传统方式的跳房子游戏，其中奶牛们在一个5x5的数字网格上进行跳跃，并生成六位数的整数。游戏规则是奶牛可以从网格中的任意数字开始，然后按照前后左右（不允许对角线）的方向跳跃到其他...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值