北京信息科技大学第13届程序设计大赛题解

1. ranko的手表 思维

大意：给定时间的格式如下，xx:xx 但是有的数字并没有给出，给定两个时间 t1,t2。求t1<t2前提下可能的时间差的最大以及最小值。

思路：看了别人的代码，也有很多 dfs 过的，比赛的时候dfs没写好，T了，然后一直在想怎么去模拟，结果到最后也没想出什么好办法。

对于 dfs 的时候大可放心去赋值，我们只需要最后去判断是否合法就好了，这样代码会简单很多。

另外有个更好的办法，一天24*60 也就1440分钟，我们大可放心 $O(n^2)$ 的时间复杂度枚举，然后再去判断分钟合不合法就好了。这样写就很简单了，很典型的问题：直接求不好求，但是给定结果可以很快的判断是否正确

代码如下：

#include <bits/stdc++.h>
using namespace std;
const int N=2010;
typedef long long LL;
typedef pair<int,int> PII;
int mx=-1e9,mi=1e9;
string s1,s2;
bool check(int t1,int t2)
{
	int h1=t1/60,m1=t1%60;
	int h2=t2/60,m2=t2%60;
	for(int i=0;i<=4;i++)
	{
		if(i==2)continue;
		int d1,d2;
		if(i==0)d1=h1/10,d2=h2/10;
		if(i==1)d1=h1%10,d2=h2%10;
		if(i==3)d1=m1/10,d2=m2/10;
		if(i==4)d1=m1%10,d2=m2%10;
		if((s1[i]!='?'&&s1[i]-'0'!=d1)||(s2[i]!='?'&&s2[i]-'0'!=d2))return 0;
	}
	return 1;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin>>s1>>s2;
	for(int i=0;i<24*60;i++)
		for(int j=i+1;j<24*60;j++)
		{
			if(check(i,j))
			{
				mi=min(mi,j-i);
				mx=max(mx,j-i);
			}
		}
	cout<<mi<<" "<<mx<<"\n";
	return 0;
}

这里提一句：这样写的代码不是最优的，我们可以先根据t1,t2已经确定的数把所有可能的时间先存起来，然后再双重循环，这样时间复杂度会更低。这里的数据范围并不是极限，所以问题不大。

总结：思考问题一定要学会及时转换思考角度，不要在一个思考方向钻牛角尖。

2. lzh的蹦床 贪心、差分、思维

大意：给定n个蹦床， 每个蹦床有一个弹力值，每次可以选择任意一个蹦床作为起点进行单方向跳跃。对于每个蹦床位置为 i ,弹力值为 x 则下一步会跳到 i+x 的位置，每踩一次蹦床就会使得蹦床的弹力值减一，蹦床的弹力值变为1后将不再减小，每次单方向进行一趟算一次，问最少需要多少次可以使所有蹦床的弹力值都变成 1. n<=1e5

思路：首先得想到怎么跳是最优的，显然从从左侧开始第一个不是 1 的蹦床开始跳是最优的。证明如下：即从左边开始的第一个弹力值不为1 的蹦床位置为 i，从 i 左边开始跳，因为都是 1，总会到 i 这里，对结果无影响，从 i 右边这里开始，因为是单向跳， i 的弹力值不变，总要从 i 这里跳，所以直接从 i 开始更优。（从左边和从右边开始都是一样的，从左边更好写。严谨证明不太会）

接下来考虑怎么算次数，我们可以边更新边用树状数组维护该蹦床对于后面蹦床的贡献。

对于 蹦床 i 弹性值 为 $a_i$, 记通过在前面的蹦床进行跳跃获得的次数为 x

根据上面我们的证明，我们每次都是选择从最左边弹性不为 1的蹦床进行跳跃，但是呢，我们在往右走的过程中难免会走到弹性为 1 的蹦床。所以我们分情况讨论。

（1）只对所有 $a_i>1$ 计算对后面蹦床的贡献

（2）$a_i-1<x$ 则表示 该出的蹦床变为 1 后，有继续走在它上面，我们上面因为只维护了$a_i>1$ 的，对于这里是弹性值虽然是 1，但是无法避免还要继续走，对于对后面 i+1 有贡献，且贡献为 $x-a_i+1$

(3) 对于$a_i-1>x$ 是我们要进行选择蹦床跳跃的次数

代码如下 ：

#include <bits/stdc++.h>
using namespace std;
const int N=5010;
typedef long long LL;
int n;
LL tr[N],a[N];
void add(int x,int y)
{
	while(x<=n)tr[x]+=y,x+=x&-x;
}
LL query(int x)
{
	LL ans=0;
	while(x)ans+=tr[x],x-=x&-x;
	return ans;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	int _;
	cin>>_;
	while(_--)
	{
		memset(tr,0,sizeof tr);
		cin>>n;
		for(int i=1;i<=n;i++)cin>>a[i];
		LL ans=0;
		for(int i=1;i<=n;i++)
		{
			int x=query(i);
			if(a[i]-1>x)ans+=a[i]-1-x;
			else if(a[i]-1<x)
			{
				add(i+1,x-a[i]+1);
				add(i+2,-(x-a[i]+1));
			}
			if(a[i]>1)
			{
				add(i+2,1);
				add(min((LL)n,a[i]+i)+1,-1);
			}
		}
		cout<<ans<<"\n";
	}
	return 0;
}

总结：这个题细节还是很多的，注意细心分析

3. 旅行家问题2 贪心，思维

大意：有 n 座山 编号 1-n, 每座山有一个高度$h_i$ , 以及山顶上有高为 $x_i$ 的梯子，先规定从 i 号山到 j 号。若 $h_j<=h_i+x_i$ 花费为 $x_i$

否则花费为 $h_j-h_i$ 。求从 1号山出发，走完所有的山并回到 1 号山的最小花费。 n<=1e5

思路：显然从 1 号点出发，并且回到 1号点是一个环，所以可以看成从任意一座山出发，再回来。对于 i , j 之间的花费：

若 $h_j>h_i+x_i$ 花费为 $h_j-h_i$ 也就是 当 $x_i<h_j-h_i$ 花费为 $h_j-h_i$ 反之，当 $x_i>=h_j-h_i$ 时，花费为 $x_i$

所以从 i 到 j 花费即为 $max(x_i,h_j-h_i)$ 也可以写成 $max(x_i,x_i+h_j-h_i-x_i)$ 把 $x_i$ 提出来，因为是一个环，所以是每个梯子都会用到。即花费为：

$\sum x_i+\sum max(0,h_j-h_i-x_i)$ 前半部分是固定的，对于后半部分要想使得花费尽可能的小，即尽可能的走那些 $h_j<h_i+x_i$ 的

我们开个二元组$(x_i,x_i+h_i)$。接下来就是看怎么使得花费最小。对于下面的三组：

显然是交换下面两个的顺序使得花费更小。

代码如下：

#include <bits/stdc++.h>
using namespace std;
const int N=200010;
typedef long long LL;
typedef pair<int,int> PII;
int n;
PII a[N];
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	LL ans=0;
    cin>>n;
	for(int i=1;i<=n;i++)
	{
		int h,x;
		cin>>h>>x;
		ans+=x;
		a[i]={h,h+x};
	}
	sort(a+1,a+1+n);
	int h=a[1].second;
	for(int i=2;i<=n;i++)
	{
		if(a[i].first>h)ans+=a[i].first-h;
		h=max(h,a[i].second);
	}
	cout<<ans<<"\n";
	return 0;
}