第一届梦羽杯题目（后六题）浅析
G 爱女装的社长
题目大意：
n个位置排成一列，每个位置可以填1,2,3，要求不能有连续三个位置填相同的数，求方案数
\(n<=10^5\)
算法思路
看完题，似乎是个数学题？不太会
不急，观察数据范围，或许可以想一种稍微慢一点的办法
考虑DP
先谈一谈个人对DP的理解：DP，其实利用的是无后效性的特点，把对之前处理完的所有数据，进行一定的归纳，再集中处理。
比如在此题中，若是没有“要求不能有连续三个位置相同”的限制，答案是什么？
毫无疑问\(3^n\)!!!,其实在这个过程中就运用到了无后效性的特点:
每个位置都有三种选择,若是没有限制,则每个位置之间互不影响,所以可以对每个位置进行相似的计算
那么我们再回到原题目,现在有了限制.
若还是从前往后填那么每个位置填数时的选择就会被前两个数影响,即:前两个数产生了后效性。
如何消除后效性呢？
我们采取枚举+记录的办法即可，也是动态规划题的通用套路：把后效性的部分记为状态
观察到1,2，3三种数字其实是等价的，不妨设：\(f_{i,1/2}\) 表示第i个位置末尾连续的数字已经有 \(1 or 2\)个连续的相同数字
那么递推式有：
代码
/*********************************************************************
WRITER:YZHX
DATE:2023.9.12
*********************************************************************/
#include <bits/stdc++.h>
using namespace std;
#define re register
#define in inline
#define ll long long
#define get getchar()
#define db double
in int read() {
int t = 0, x = 1;
char ch = get;
while ((ch < '0' || ch > '9') && ch != '-')
ch = get;
if (ch == '-')
ch = get, x = -1;
while (ch <= '9' && ch >= '0')
t = t * 10 + ch - '0', ch = get;
return t * x;
}
const int mod = 1e9 + 7;
ll f[100100][3];
in void pre() {
int n = 100000;
f[1][1] = 3;
for (re int i = 2; i <= n; ++i)
{
f[i][1] = (f[i - 1][1] * 2 % mod + f[i - 1][2] * 2 % mod) % mod;
f[i][2] = f[i - 1][1];
}
}
int main() {
// freopen(".in","r",stdin);
// freopen(".out","w",stdout);
int T = read();
pre();
while (T--) {
int n = read();
cout << (f[n][1] + f[n][2]) % mod << endl;
}
return 0;
}
H女装社长的威胁
题目大意
给定一个n个元素的集合，可以进行k次操作，每次操作可以对一个元素 \(+1\) or \(-1\) (可以重复对一个数进行操作)，之后要求 最大化 众数个数
\(n<=10^5, k<=10^{12}, a_i<=10^9\)
算法解析
思路一：
通过简单思考发现，最后的众数一定是原先存在的数，那么从小到大排序后，直接枚举最后的众数，再通过二分，找到左右能够变成选中数的最大边界。最后在n个答案中取最值即可
思路二：
明显可以得出答案与操作次数k是单调相关的，即操作次数越多，答案一定不会更小，那么考虑二分答案：
二分最后的答案，再进行check，是否能在k次操作内做到。
关于check：双指针+前缀和即可
/*********************************************************************
WRITER:YZHX
DATE:2023.9.12
*********************************************************************/
#include <bits/stdc++.h>
using namespace std;
#define re register
#define in inline
#define ll long long
#define get getchar()
#define db double
in int read() {
int t = 0, x = 1;
char ch = get;
while ((ch < '0' || ch > '9') && ch != '-')
ch = get;
if (ch == '-')
ch = get, x = -1;
while (ch <= '9' && ch >= '0')
t = t * 10 + ch - '0', ch = get;
return t * x;
}
const int _ = 1e5 + 23;
ll n, k, a[_], b[_];
in int check(int mid) {
int l, r, t;
for (re int i = 1; i <= n - mid + 1; ++i) {
l = i, r = i + mid - 1, t = (l + r) >> 1;
ll w = a[t] * (t - l + 1) - (b[t] - b[l - 1]) + (b[r] - b[t]) - a[t] * (r - t);
if (w < k)
return 1;
}
return 0;
}
int main() {
// freopen(".in","r",stdin);
// freopen(".out","w",stdout);
n = read(), k = read();
for (re int i = 1; i <= n; ++i)
a[i] = read();
sort(a + 1, a + n + 1);
for (re int i = 1; i <= n; ++i)
b[i] = b[i - 1] + a[i];
ll sum = 0, l = 1, r = n, ans = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
l = mid + 1, ans = mid;
else
r = mid - 1;
}
printf("%lld\n", ans);
return 0;
}
I教你如何签到的签到题
01背包模板题，使用任意搜索引擎输入01背包点击回车键即可获取详解
J模拟跑酷
题目描述
现在有一条宽度为n的跑道，跑道上有如下几种地形：
1、普通跑道，用'.'表示，通过一个单位的普通跑道需要1s
2、上坡，用‘&’表示，通过一个单位的上坡跑道需要2s
3、下坡，用‘%’表示，通过一个单位的下坡跑道需要0.5s
4、障碍跑道,用‘$’表示，通过障碍跑道需要5s
你可以在每个单位长度跑道尽头处切换跑道，但是切换到相邻的跑道需要2s，可以连续切换跑道但是切换跑道时不能前进。
最开始你处在1号跑道的跑道开始处。
请计算通过这条跑道需要的最短时间。
输入格式
第一行一个整数，n
接下来n行，每行一个字符串代表第i道的跑道情况
输出格式
一个浮点数，代表跑到跑到尽头需要的时间（每一道跑道尽头都是跑道头）。保留两位小数
数据范围
n不大于5
跑道长度不大于10000
解题思路
先观察数据范围，发现n非常小，说明在考虑时间复杂度时n几乎可以忽略
直接猜出拿n作为DP中的一维状态
因为我们无法直接想出一个通解找到走线方案，不妨考虑动态规划。
我们在任何时候能对之后决策造成影响的只有我们所处的位置（横纵坐标），而与我们走过了什么障碍物并无关联。那么直接设\(f_{i,j}\)表示当前在第i个位置，第j条赛道，花费的最少的时间，接下来直接递推转移即可，相邻赛道的切换，多跑几次循环就可以啦，反正n是常数
（因为yzhx太饿了，代码被吃了奥）
K拔萝卜
题目描述
数轴上有n个机器，第i个机器位于 \(dis_i\) 每秒会产生 \(a_i\) 的开销，初始时你在第c个机器旁，你移动的速度是 \(1m/s\),走到一个机器旁可以瞬间关闭它，要求最小化关闭所有机器的代价
\(1<=c<=n<=100\) \(x_i,a_i<=10^9\)
解题思路
做题先看数据范围
n<100???这种数据通常是很暧昧的，既不会要求太高的数据结构和算法板子，也不会是暴力能过的，所以，继续考虑动态规划(DP)。
DP题最关键几点就是：
1.怎样记录状态
2.怎样通过已知状态合理转移 (考虑复杂度) 到未知状态
3.如何通过记录的状态获取答案
考虑第一个问题：
此题中，每个机器只有两个状态，打开和关闭，但是如何用尽量少的空间记录所有状态呢？
我们从c机器开始左右横跳时，因为关机器不需要时间，所以肯定路过的任何一台机器都会被顺手关闭。那么，被关闭的机器肯定是连续的，不妨记录已关闭的机器的区间是\([l,r]\)。
当然，除了机器的状态，我们自身的位置在DP中也是至关重要的。
显然，在两个机器中间掉头换方向，绝对不是最优的，因此我们只可能在有机器的位置切换方向。
状态已经呼之欲出啦：
设\(f_{l,r,0/1}\)表示当前已关闭的机器区间是[l,r],我们自身的位置是l或者r（用0/1表示）。
第二个问题：如何转移状态呢
既然产生代价的机器区间是开头和结尾两段连续的机器，那么一次次求和不太现实，直接上前缀和
即： \(sum_i\) 表示 \(\sum_{i=1}^n a_i\)
然后转移式：
dp[i][j][1]=min( dp[i][j-1][0]+(dis[j]-dis[i])*(sum[n]+sum[i-1]-sum[j-1]),dp[i][j-1][1]+(dis[j]-dis[j-1])*(sum[n]+sum[i-1]-sum[j-1]) );
dp[i][j][0]=min( dp[i+1][j][0]+(dis[i+1]-dis[i])*(sum[n]+sum[i]-sum[j]),dp[i+1][j][1]+(dis[j]-dis[i])*((sum[n]+sum[i]-sum[j]) ) ) ;
最后一个问题：怎样计算答案
这点其实就无需多言了，直接在 \(dp_{i,j,0}\)与\(dp_{i,j,1}\)中取min值就好
代码
/*********************************************************************
WRITER:YZHX
DATE:2023.9.12
*********************************************************************/
#include<bits/stdc++.h>
using namespace std;
#define re register
#define ll long long
#define in inline
#define get getchar()
in int read()
{
int t=0; char ch=get;
while(ch<'0' || ch>'9') ch=get;
while(ch<='9' && ch>='0') t=t*10+ch-'0', ch=get;
return t;
}
int n,c;
const int _=101;
ll sum[_],dp[_][_][2],dis[_],v[_];
int main()
{
n=read(),c=read();
for(re int i=1;i<=n;i++)
dis[i]=read(),v[i]=read(),sum[i]=sum[i-1]+v[i];
memset(dp,0x3f,sizeof(dp));
dp[c][c][1]=0,dp[c][c][0]=0;
for(re int j=c;j<=n;j++)
for(re int i=j-1;i;i--)
{
dp[i][j][1]=min( dp[i][j-1][0]+(dis[j]-dis[i])*
(sum[n]+sum[i-1]-sum[j-1]),
dp[i][j-1][1]+(dis[j]-dis[j-1])*(sum[n]+sum[i-1]-sum[j-1]) );
dp[i][j][0]=min( dp[i+1][j][0]+(dis[i+1]-dis[i])*
(sum[n]+sum[i]-sum[j]),
dp[i+1][j][1]+(dis[j]-dis[i])*((sum[n]+sum[i]-sum[j]) ) ) ;
}
cout<<min(dp[1][n][0],dp[1][n][1]);
}
L养一群龙吧
题目描述
自己去DPOJ官网找吧
题解
（没写不想动）
自己yy的，应该没问题，听嘉佑姐姐说有简单做法。。。但我不会/kk
先离散化
思路一： 用线段树模拟
思路二： 用莫队模拟
思路三： 暴力模拟+卡常
