Codeforces on Zs's Blog

Codeforces#620 (Div.2)

Wed, 19 Feb 2020 01:02:00 +0000

A. Two Rabbits

题意

两个兔子分别位于 $(x,0)$ 和 $(y,0)$ ，两个人对头蹦，前者往前蹦 $a$ ，后者往前蹦 $b$ ，问两人是否能恰好相遇。

思路

算一下两个人直接得距离 $s$ ，每次两者距离减少 $a+b$ ，看 $s$ 是否能被 $a+b$ 整除，如果可以就能够相遇。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

int t;
int x,y,a,b;
int main()
{
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d%d%d%d",&x,&y,&a,&b);
		int p=a+b;
		int f=y-x;
		if(f%p==0)
		{
			printf("%d\n",f/p);
		}
		else printf("-1\n");
	}
	return 0;
}

B. Longest Palindrome

题意

给出 $n$ 段长度为 $m$ 的字符串，从中挑选出一些组成最长的回文字串，输出这个回文子串的长度和内容，如果有多种情况输出一种即可。如果没有符合的，就输出0 。$(1\le n\le 100,1\le m\le 50)$

思路

因为这个数据规模非常小，所以 $O(n^2m)$ 也是可以接受的（说实话我不是很会算，大概是个差不多的式子），那么我们可以选择暴力匹配，用每个字符串去匹配后面的，如果是两个互为回文串，那么就把其中任何一个计入到sub字符串中，然后用一个 vis 数组来标记他们两个已经被使用过了，最终一个字符串匹配完后面所有的发现没有合适的，那么就考虑他自己是不是一个回文串，如果是一个回文串，单独标记它是放在中间。最后我们的sub是存放了一半回文串。统计答案的时候，先将sub加到答案ans中，检查一下是否中间有合适的回文串，如果有的话也加到ans里面，最后讲sub逆序一下，加到ans里面。最终输出答案的时候，看一下ans是不是空串，如果是空串，就输出0，否则输出长度和ans。（string是真的好用！！！）

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=105;
int n,m;
string ans,sub,mid;
bool ifmid;
string str[maxn];
bool vis[maxn];
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++) cin>>str[i];
	for(int i=1;i<=n;i++)
	{
		for(int j=i+1;j<=n;j++)
		{
			if(vis[j]) continue;
			bool flag=true;
			for(int k=0;k<m;k++)
			{
				if(str[i][k]==str[j][m-k-1]) 
				{
					continue;
				}
				else
				{
					flag=false;
					break;
				}
			}
			if(flag)
			{
				vis[i]=vis[j]=true;
				sub+=str[i];
			}
		}
		if(!vis[i])
		{
			bool flag=true;
			for(int j=0;j<m;j++)
			{
				if(str[i][j]!=str[i][m-1-j])
				{
					flag=false;
					break;
				}
			}
			if(flag)
			{
				mid=str[i];
				ifmid=true;
			}
		}
	}
	ans+=sub;
	reverse(sub.begin(),sub.end());
	if(ifmid) ans+=mid;
	ans+=sub;
	if(!ans.empty())
	{
		cout<<ans.length()<<endl<<ans;
	}
	else cout<<0;
	return 0;
}

C. Air Conditioner

题意

餐厅老板有一个空调，餐厅初始温度为 $m$ ，会陆续来 $n$ 个顾客。餐厅老板每分钟可以控制空调的温度+1，-1，或者是不变。这 $n$ 个顾客会按来的时间顺序给出，每个人有一个感到舒适的温度范围，如果空调的温度在这个范围里面，那么顾客就会满意。问餐厅老板是否可以达到让每个人都满意。

思路

首先我们先思考从餐厅开始到第一个客人来临的时候，假设第一个人来临的时间是 $t$ ，舒适区间为 $[l,r]$，那么我们可以很容易发现只要 $[l,r]$ 与 $[m-t,m+t]$ 有交集，那么就是可以满足第一个客人条件。如果第二个和第一人的时间差为 $\Delta t$ ，那么这个时候要计算可达到的舒适区间就是在上次交集的区间上左右变化 $\Delta t$ ，为什么是交集呢。我一开始想错了。。一直写成并集，然后一直调不出来。但实际上不是这样的，我们可以理解为只有交集那部分才是符合上个顾客要求的，如果超出那个范围，就不能够满足上个顾客要求。所以挨个顾客扫一遍就行了。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

int q,n,m;
int last,l,h,t;
int nowl,nowr,delt;
int lef,righ;
bool flag;
int main()
{
	scanf("%d",&q);
	while(q--)
	{
		scanf("%d%d",&n,&m);
		lef=righ=m;
		last=0;
		flag=true;
		for(int i=1;i<=n;i++)
		{
			scanf("%d%d%d",&t,&l,&h);
			delt=t-last;
			nowl=lef-delt;
			nowr=righ+delt;
			last=t;
			if(nowl>h||nowr<l) flag=false;
			else 
			{
				lef=max(nowl,l);
				righ=min(nowr,h);
			}
		}
		if(flag)
		{
			printf("YES\n");
		}
		else printf("NO\n");
	}
}

杂题训练

Sat, 15 Feb 2020 00:52:00 +0000

A. 配对

题意

给定含有 $n$ 个正整数的集合 $A$ 和 $B$ ，你需要建立他们之间的一一映射。将配对的两个数相加可以得到 $n$ 个和，问第 $k$ 大的和最大为多少。

思路

首先我们可以确定，组成前 $k$ 个最大的和一定用的是两个序列里面前 $k$ 大的数字。那么我们只需要知道如何配对能使第 $k$ 大的和最大。我们把问题简化一下如果 $A_1 < A_2$ ，$B_1 < B_2$ ，那么如果想要第二个和最大，肯定是需要 $A_1$ 和 $B_2$ 匹配，$A_2$ 和 $B_1$ 匹配，然后两个选一个最小的。所以这个问题我们类推一下，就是将 $A$ 和 $B$ 序列进行排序，然后取两个里面前 $k$ 个数，$A$ 中大的依次匹配 $B$ 中小的。然后在这 $k$ 个和中取一个最小值即可。

代码实现

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>

using namespace std;

const int maxn=1e5+5;
int a[maxn];
int b[maxn];
int n,k,ans=1e9+7;
int cmp(int a,int b)
{
	return a>b;
} 
int main()
{
	scanf("%d%d",&n,&k);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
	}
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&b[i]);
	}
	sort(a+1,a+1+n,cmp);
	sort(b+1,b+1+n,cmp);
	for(int i=1;i<=k;i++)
	{
		ans=min(ans,a[i]+b[k-i+1]);
	}
	printf("%d",ans);
}

B. 十字阵列

题意

给定一个 $n\times m$ 的网格，每一个交点都一个敌人。你可以使用共 $h$ 次魔法，第 $i$ 次魔法能对第 $x_i$ 行和第 $y_i$ 列的所有敌人造成 $w_i$ 点伤害，交界点的伤害只计算一次。。如果施放完所有所有魔法后，如果一个点 $(i,j)$ 共受到 $z_i$ 点伤害，问 $\sum{z_i(i+j)}$ 为多少。

思路

无脑的计数题QAQ..真的是水题啊，我们只需要给每次魔法施放的 $w_i$ 乘上一个 $(i,j)$ 即可，但是因为是一行一列都会变化，那么其实我们可以优化一下，先把一行一列的 $\sum(i+j)$ 给求出来，然后施法的时候直接乘上这个常数就可以了。（这个题还有个很神奇的地方就是，我明明算的不会爆int然后开的int，然后就错了，后来一直找问题没找出来，后来全改成long long就AC了，太奇怪了。。）

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=2005;
typedef long long ll;
int mod = 1e9+7;
ll row[maxn];
ll col[maxn];
ll x,y,z;
ll n,m,h;
ll ans,now;
int main()
{
	scanf("%lld%lld%lld",&n,&m,&h);
	for(int i=1;i<=n;i++) 
	{
		row[i]=(m*i)%mod+(m)*(m+1)/2;
		row[i]%=mod;
	}
	for(int j=1;j<=m;j++)
	{
		col[j]=(n*j)%mod+(n)*(n+1)/2;
		col[j]%=mod;
	}
	for(int i=1;i<=h;i++)
	{
		scanf("%lld%lld%lld",&x,&y,&z);
		now=((row[x]+col[y]-(x+y))%mod)*(z%mod);
		now%=mod;
		ans+=now;
		ans%=mod;
	}
	printf("%lld\n",ans);
}

C. 垃圾陷阱

题意

奶牛卡门想要从垃圾井底上到地面，对于一个垃圾它可以吃掉，或者是堆起来。初始卡门有10个小时的能量，吃掉一个垃圾会给他提供 $f_i$ 个小时的能量，叠起来一个垃圾会获得 $h_i$ 点高度，当垃圾总高度超过井的深度 $D$ 的时候，卡门就能上到地面。一个垃圾当 $t_i$ 小时时会到达井底。给出所有垃圾的状态，问奶牛能否到达地面。

思路

~~这个题面被我翻译的屎一样，QAQ，如果看不懂还是去看原题叭。。~~ 这是一个类似于背包的题，对于一个垃圾，我们有两种选择，一个是吃掉它，一个是把他堆起来。。这个状态其实我没找好，看了题解发现可以设 $f[i][j]$ 来表示当用了前 $i$ 个垃圾时，当高度为 $j$ 的时候的最大的体力值（体力值就是还能继续活动多长时间）。我们用结构体数组 $a$ 来表示垃圾，写出如下转移方程。

如果选择把这个垃圾吃掉，那么 $f[i][j]=max(f[i-1][j]+a[i].f,f[i][j])$
如果选择把这个垃圾搭起来，那么$f[i][j+a[i].h]=max(f[i-1][j+a[i].h],f[i-1][j])$

我们发现边界就是 $f[0][0]=10$ ，也就是用了0个垃圾，高度为0的时候体力值为10。

注意一个地方我们如果到达了地面，就直接输出时间，然后退出程序即可，如果没有的话，我们可以选择遍历每一个垃圾下的 $0$ 高度，也就是说所有垃圾都不叠是最长的寿命，所以输出一个其中的最大值即可。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>
using namespace std;

const int maxn=105;
struct node
{
	int t,f,h;
}a[maxn];
int cmp(node a,node b)
{
	return a.t<b.t;
}
int d,g;
int dp[maxn][maxn]; //dp[i][j] 用i个垃圾，当高度为j时所具备的最高生命值 
int main()
{
	freopen("test.in","r",stdin);
	scanf("%d%d",&d,&g);
	for(int i=1;i<=g;i++)
	{
		scanf("%d%d%d",&a[i].t,&a[i].f,&a[i].h); 
	}
	sort(a+1,a+1+g,cmp);
	memset(dp,-1,sizeof(dp));
	dp[0][0]=10;
	for(int i=1;i<=g;i++)
	{
		for(int j=0;j<=d;j++)
		{
			if(dp[i-1][j]>=a[i].t)
			{
				if(j+a[i].h>=d)
				{
					printf("%d",a[i].t);
					return 0;
				}
				dp[i][j]=max(dp[i-1][j]+a[i].f,dp[i][j]);
				dp[i][j+a[i].h]=max(dp[i-1][j+a[i].h],dp[i-1][j]);
			}
		}
	}
	int ans=0;
	for(int i=1;i<=g;i++) ans=max(ans,dp[i][0]);
	printf("%d",ans);
}

Codeforces#619 (Div.2)

Fri, 14 Feb 2020 00:51:00 +0000

A. Three Strings

题意

给定三个长度为 $n$ 的字符串 $a$ , $b$ , $c$ ，遍历每个 $c$ 中每个字符 $c_i$，可以将其替换成 $a_i$ 或者 $b_i$ ，必须操作其中一个，问能否通过此操作使得字符串 $a$ , $b$ 相同。

思路

仔细思考一下，如果要使得最终两个字符串相同的话，必须字符串 $c$ 中出现的字符，在 $a$ 或者 $b$ 字符串出现过，如果每个位置都出现过，那么就是可以的，否则不行。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=105;
char a[maxn],b[maxn],c[maxn];
int t;
int main()
{
	scanf("%d",&t);
	while(t--)
	{
		scanf("%s",a);
		scanf("%s",b);
		scanf("%s",c);
		int len=strlen(c);
		bool flag=true;
		for(int i=0;i<len;i++)
		if(c[i]!=a[i]&&c[i]!=b[i])
		{
			flag=false;
		}
		if(flag)
		{
			printf("YES\n");
		}
		else printf("NO\n");
	}
	return 0;
}

B. Motarack’s Birthday

题意

给定一个含有 $n$ 个整数的序列 $a$ ，其中有一些数丢失，问将丢失的数赋值为多少才能使得相邻两数之差的绝对值的最大值的最小。

思路

我们想一下首先不缺失的数相邻两数之差是一定，无论赋值前后都不影响。而如果两个相邻的数都缺失的话，那么他们之间差的绝对值一定是0，也不用去看。这样的话我们就看一下，不缺失和缺失两数之间差的绝对值如何能够最小。因为最终所有的缺失的数都是赋值为同一个数，所以我们考虑一下发现需要考虑一下缺失和不缺失的数相邻的时候，不缺失的那个数的最大值和最小值，我们只需要取他们的和的平均，那么绝对值就可以最小了。所以最终我们就把缺失的值赋为两数均值，然后求一遍相邻数之差绝对值的最大值就好了。（好像这道题难点不是思路，而是实现起来有很多边界等乱七八糟的要自习考虑一下。）

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=100005;
const int inf=1000000000;
int n,t;
int a[maxn];
int minn,maxx,ans,anss;
int main()
{
	scanf("%d",&t);
	while(t--)
	{
		minn=inf,maxx=-inf,anss=-inf;
		scanf("%d",&n);
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&a[i]);
			if(i>1&&a[i]==-1&&a[i-1]!=-1)
			{
				minn=min(minn,a[i-1]);
				maxx=max(maxx,a[i-1]);
			}
		}
		for(int i=1;i<=n;i++)
		{
			if(i<n&&a[i]==-1&&a[i+1]!=-1)
				{
					minn=min(minn,a[i+1]);
					maxx=max(maxx,a[i+1]);
				}	
		}
		ans=(minn+maxx)/2;
		for(int i=1;i<=n;i++)
		{
			if(a[i]==-1) a[i]=ans;
			if(i>1) anss=max(anss,abs(a[i]-a[i-1]));
		}
		printf("%d %d\n",anss,ans);
	}
	return 0;
}

C. Ayoub’s function

题意

给定一个01字符串 $s$ ，其中含有 $m$ 个1，用 $f(s)$ 来表示字符串 $s$ 的有多少个字串其中含有1，求出符合条件的字符串 $s$ 中， $f(s)$ 的最大值是多少。

思路

这题正着想不太好想，含有1的子串可以有很多种情况，但是正难则反，我们可以求出不含1的字串有多少情况，也就是全0的字串有多少种情况，然后用所有情况减去这个就行。首先可以发现字符串 $s$ 一共有 $\binom{n}{2}+n$ 种连续子串，那么如果一些0是连续的，那么好比有连续 $l$ 个0的话，我们可以发现他是有 $\binom{l}{2}+l$ 种情况的。这个字符串一共是含有 $n-m$ 个0的，现在我们思考一下如何摆放这 $(n-m)$ 个0，才能使得 $f(s)$ 最大。那么如果 $f(s)$ 要尽量大，也就是说全0对应的情况就要尽可能的少，所以我们需要将这 $n-m$ 尽可能的均分成 $m+1$ 份，类似于排列组合的插空法，将他们插到其中，但是我们发现有很大的可能是不能均分的，也就是说可能会有余数，那么我们就把余数均匀的分给前面余数个空，这样其实每个多贡献了 $(n-m)/(m+1) +1 $ 个。所以答案也就不难写出来了。不过不要忘了开long long。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

typedef long long ll;
ll n,m;
ll t;
int main()
{
	scanf("%lld",&t);
	while(t--)
	{
		scanf("%lld%lld",&n,&m);
		ll sum=n*(n+1)/2;
		ll p=n-m;
		ll mod=p%(m+1);
		ll k=p/(m+1);
		printf("%lld\n",sum-(m+1)*k*(k+1)/2-(k+1)*mod);
	}
	return 0;
}

Codeforces #618 (Div.2)

Mon, 10 Feb 2020 00:39:00 +0000

A. Non-zero

题意

给出一段含有 $n$ 个数的序列 $a$ ，可以对其中任何数加一，问最少操作多少次让每一个数和序列和都不为0。

思路

输入的时候如果输入的是 $0$ 就将答案加一，最后如果序列和为 $0$ 的话答案加一。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

int t,n,sum,p,ans;
int main()
{
	scanf("%d",&t);
	while(t--)
	{
		sum=ans=0;
		scanf("%d",&n);
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&p);
			if(p==0)
			{
				ans++;
				sum+=1;
			}
			else sum+=p;
		}
		if(sum==0) printf("%d\n",ans+1);
		else printf("%d\n",ans);
	}
}

B. Assigning to Classes

题意

将 $2n$ 个数分成个奇数序列，问两个奇数序列的中位数之差最小为多少。

思路

直接就将序列排序然后输出中间两个数之差即可。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn = 100005;
int t,n,a[maxn<<1];
int main()
{
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&n);
		int p=n<<1;
		for(int i=1;i<=p;i++)
		{
			scanf("%d",&a[i]);
		}
		sort(a+1,a+1+p);
		printf("%d\n",abs(a[n]-a[n+1]));
	}
	return 0;
}

C. Anu Has a Function

题意

给出函数 $f: f(x,y)=(x|y)-y $ ，给出序列 $a$，序列 $a$ 中含有 $n$ 个数，可以表示为$[a_1,a_2\cdots,a_n ]$ ，定义 $x=f(f(…f(f(a_1,a_2),a_3),…a_{n-1}),a_n)$ ，你可以对序列 $a$ 中元素进行重排，求使得 $x$ 最大的序列 $a$ 。如果有多种情况，输出一种即可。

思路

第一种思路是因为 $f(x,y)=(x|y)-y$ ，我们可以发现对于经过这样的运算之后，如果 $x$ 的某一位是1，如果 $y$ 的相应位是0，那么运算出来的 $f(x,y)$ 对应位就是1，如果 $y$ 对应位是1，那么运算出来就是0。那么对于 $x$ 的计算过程中的每一位这个规律都是适应的。因此我们只需要将位数从高到低依次扫一遍，如果这个位数为1的情况在序列所有元素中只出现了一次，那么就将唯一出现1的那个数放到第一位即可。
第二种思路 $$ \because f(x,y)=(x|y) - y {\Longleftrightarrow} f(x,y) = x&({\sim} y) \therefore x=(a_1)&({\sim}a_2)&({\sim} a_3){\cdots}({\sim}a_n) $$ 我们发现后面其实都是可交换的，所以第一个只有第一个是起决定作用的，那么我们就可以处理一个前缀和后缀的 and 数组，这样我们就可以 $O(1)$ 的计算出后面那部分，然后遍历序列 $a$ 找到最合适的 $a_1$。

代码实现

第一种思路

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=100005;
int n,a[maxn],maxk;
int cnt;
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		maxk=max(maxk,a[i]);
	}
	int p=1,k=0;
	while(p<=maxk)
	{
		k++;
		p<<=1;
	}
	for(int i=k;i>=0;i--)
	{
		cnt=0;
		for(int j=1;j<=n;j++)
		{
			if(a[j]&(1<<i))
			{
				cnt++;
				if(cnt==1) swap(a[j],a[1]);
			}
		}
//		printf("%d %d\n",i,cnt);
		if(cnt==1)
		{
			for(int j=1;j<=n;j++)
			{
				printf("%d ",a[j]);
			}
			return 0;
		}
	}
	for(int i=1;i<=n;i++)
	{
		printf("%d ",a[i]);
	}
	return 0;
}

第二种思路

#include<cstdio>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=100005;
int n,a[maxn];
int ans;
int pre[maxn],suf[maxn]; //pre is prefix,suf is suffix
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		a[i]=~a[i];
		if(i==1) pre[i]=a[i];
		else pre[i]=pre[i-1]&a[i];
	}
	suf[n]=a[n];
	for(int i=n-1;i>=1;i--)
	{
		suf[i]=suf[i+1]&a[i];
	}
	for(int i=1;i<=n;i++)
	{
		int p=a[i];
		p=~a[i];
		if(i==1)
		{
			int now=suf[i+1]&p;
			ans=max(ans,now);
		}
		else if(i==n)
		{
			int now=pre[i-1]&p;
			if(now>ans)
			{
				swap(a[i],a[1]);
				ans=now;
			}
		}
		else 
		{
			int now=pre[i-1]&suf[i+1]&p;
			if(now>ans)
			{
				swap(a[i],a[1]);
				ans=now;
			}
		}
	}
	for(int i=1;i<=n;i++)
	{
		printf("%d ",~a[i]);
	}
	return 0;
}

D. Aerodynamic

题意

给定一个凸多边形 $P$ 的所有顶点，可以将凸多边形沿向量 $(x,y)$ 平移，我们定义多边形 $T$ 是所有 $P$ 平移到与原点有交点后所构成的点集所形成的图形（我知道这句话有点绕，我实在是解释不明白，实在不行康康原题吧）。那么问这个 $T$ 是否是和 $P$ 相似的，如果是输出YES，不是输出NO。

思路

就是判断这个图形是不是中心对称图形就行了，证明还不会，暂且放一下，会了再写QAQ..

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=100005;
int n;
int x[maxn],y[maxn];
bool check()
{
	int p=n/2;
//	printf("%d",p);
	int x1=x[1]+x[1+p];
	int y1=y[1]+y[1+p];
	for(int i=2;i<=p;i++)
	{
		if(x1!=x[i]+x[i+p]||y1!=y[i]+y[i+p])
		{
			return false;
		}
	}
	return true;
}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d%d",&x[i],&y[i]);
	}
	if(n&1)
	{
		printf("NO");
	}
	else
	{
		if(check())
		{
			printf("YES");
		}
		else printf("NO");
	}
	return 0;
}

Codeforces#617(Div.3)

Wed, 05 Feb 2020 23:18:00 +0000

A. Array with Odd Sum

题意

给出包含 n 个正整数的序列 a ，你可以把任何一个元素 $a_i$ ，赋值给另一个元素 $a_j$ ($i\neq j$) ，问通过任意此操作能否将序列 a 的和变为奇数。可以输出 YES ,不可以输入 NO.

思路

首先当起始和为奇数的时候，就直接可输出 YES 了，如果是偶数的话，我们可以发现，如果序列元素中同时包含奇数和偶数，那么就是可以的，否则不可以。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>

using namespace std;

int t,n,flag,sum,p,flag1,flag2;
int main()
{
	scanf("%d",&t);
	while(t--)
	{
		flag=false;
		flag2=flag1=false;
		sum=0;
		scanf("%d",&n);
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&p);
			sum+=p;
			if(p%2==1) flag1=true;
			if(p%2==0) flag2=true;
		}
		if(flag1&&flag2) flag=true;
		if(sum%2==1) printf("YES\n");
		else 
		{
			if(flag) printf("YES\n");
			else printf("NO\n");
		}
	}
}

B. Food Buying

题意

初始有 s 个货币，每次花费 x 个货币会返还 $\lfloor{\frac{x}{10}}\rfloor$ 个货币，问最多共能花费多少货币。

思路

贪心即可。剩余的货币一直除10累加，注意最终剩余不足10的处理。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>

using namespace std;

int t,s;
int main()
{
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&s);
		{
			int p=s;
			int now=0;
			while(p)
			{
				if(p<10) break;
				now=p/10;
				s+=now;
				p%=10;
				p+=now;
			}
		}
		printf("%d\n",s);
	}
}

C. Yet Another Walking Robot

题意

一个机器人初始在 $(0,0)$ 点，规定 ‘L’ ，‘R’ ，‘U’ ，‘D’ 分别对应向左，向右，向上和向下。给定一段包含上述字母的序列 s ，机器人遵循指引序列移动。如果删除一段连续序列可使得机器人最终到达终点不变，问删除的最短序列的起始和终点为多少。

思路

想了半天想了错误的解法。。一直在考虑 L 和 R 数相等，U 和 D 相等，通过这个方法来找序列。看了题解才发现是通过坐标来看。我们可以开一个map记录坐标和步数的关系，从左到右扫序列，如果没有到达过这个坐标，就记录当前是第几次移动到达这个坐标的，如果到达过的话，就看上一次到达这个坐标时的步数，计算他们的序列长度，如果小于计算的就更新答案。因为是需要找最小的，因此只需要记录上一次到达的步数即可。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>

using namespace std;

const int maxn=200005;
int t,n;
char s[maxn];
bool flag;
int main()
{
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&n);
		int l=-1,r=n;
		scanf("%s",s+1);
		pair<int,int> pos; //first为x second为y
		map<pair<int,int>,int> last;  
		pos.first=pos.second=0;
		last[pos]=0;
		for(int i=1;i<=n;i++)
		{
			if(s[i]=='L') pos.first--;
			if(s[i]=='R') pos.first++;
			if(s[i]=='U') pos.second++;
			if(s[i]=='D') pos.second--;
/*			
			if(i==2)
			{
				printf("%d %d\n",pos.first,pos.second);
			}
*/			
			if(last.count(pos)!=0)
			{
				int p=i-last[pos];
//				if(i==2) printf("%d %d\n",i,last[pos]);
				if(p<r-l)
				{
					l=last[pos];
					r=i;	
				}	
//				if(i==2 )printf("%d %d\n",l,r);
			}
			last[pos]=i;
		}
		if(l==-1)
		{
			printf("-1\n");
		}
		else
		{
			printf("%d %d\n",l+1,r);
		}
	}
	return 0;
}

D. Fight with Monsters

题意

由你先手和对手轮流击打 $n$ 个血量为 $h_i$ 的小怪兽，你可以对怪物造成 $a$ 点伤害，对手可以造成 $b$ 点伤害。你有 $k$ 次机会使对手跳过他的回合。当小怪兽血量 $h\le0$ 时视为被击杀，当你击杀怪兽，你获得一分，当对手击杀，你不得分。求你最多能获得多少分数。

思路

先看一下对于每个怪兽我们要击杀需要花费多少机会，你和对手一个回合会击杀怪兽 $a+b$ 点血量，因此你可以一直将回合进行到怪兽血量小于$a+b$，接下来我们可以分两种情况讨论。

怪兽血量为0，那么我们就需要回溯对手最后一个回合，然后需要使用的机会就是 $\lceil\frac{h_i}{a}\rceil$ 次
怪兽血量不为0，我们需要使用的机会就是 $\lceil\frac{h_i}{a}\rceil-1$ 次，注意这里不能直接写 $\lfloor\frac{h_i}{a}\rfloor$ 次，因为如果 $h_i$ 刚好能被 $a$ 整除，后面这个写法就错了。

计算出了每个怪兽需要花费的机会那么就好做了，就变成了一个贪心问题，我们去尽可能得击杀需要的机会少的，当机会消耗完毕，得到的就是答案了。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=200005;
int n,a,b,k;
int f[maxn];
int cmp(int a,int b)
{
	return a<b;
}
int h[maxn],ans;
int main()
{
	scanf("%d%d%d%d",&n,&a,&b,&k);
	int p=a+b;
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&h[i]);
		h[i]%=p;
		if(h[i]==0)
		{
			h[i]+=b;
			f[i]=ceil((double)h[i]/a);
		}
		else f[i]=ceil((double)h[i]/a)-1;
	}
	sort(f+1,f+1+n,cmp);
	for(int i=1;i<=n;i++)
	{
		if(k-f[i]<0) break;
		ans++;
		k-=f[i];
	}
	printf("%d\n",ans);
}

CodeforcesER #81

Sun, 02 Feb 2020 21:53:00 +0000

A : Display The Number

题意

用一定数目的灯管，显示尽可能大的数

思路

因为位数多的肯定更大，所以肯定用尽量少的灯管搭建单个数字更好，最少的两个分别是两个灯管显示的1，以及三个灯管显示的7，所以就是尽可能的用1，如果最后剩余正好三个就显示7。这就转化成了判断奇数还是偶数的题，奇数就显示7111····，偶数就是1111···。注意要把7放在前面（我就踩坑了）。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
int t,n;
int cnt=0;
int main()
{
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&n);
		if(n%2==0)
		{
			int p=n/2;
			for(int i=1;i<=p;i++) printf("1");
		}
		else
		{
			printf("7");
			n-=3;
			int p=n/2;
			for(int i=1;i<=p;i++) printf("1");
		}
		printf("\n");
	}
	return 0;
}

B : Infinite Prefixes

题意

给定一段01字符串 s 为循环节，得到无限循环的01字符串 t，求 t 中有多少前缀满足0个数-1个数等于期望值x （空前缀也算是一个前缀）

前缀：例如"abcd"的前缀包括 " “,“a”,“ab”,“abc”,“abcd”.

思路

首先我们先记录循环节 s 中每个位置对应的01个数差，记为$num_i，i\in[1,n]$ （ s 长度记为n）

首先我们可以发现当 x=0 的时候，空前缀也会有贡献，因此不能忽略空前缀。
如果循环节 s 的01数相等，那么我们可以发现最后循环节一位$num_n$总为0，那么可以分两种情况来讨论
- 如果循环节中存在大于等于1个前缀满足期望值x，那么就有无限个满足，因此输出-1
- 如果循环节 s 中不存在满足期望值的前缀，那么 t 中也一定不存在
再来看一般情况，如果一个前缀中包含多个循环节 s ,那么前面每个循环节对于最终01个数差的贡献总为$num_n$，因此我们可以用所期望的值 x，利用1~n 循环减去每一位的 $num_i$，如果所得是$num_n$的非负倍数，那么就是符合期望的，否则不是。(本来一直这里不太明白，后来发现对于循环节中的每一个位置，在后续循环的过程中，如果$num_n$不为0，那么这个位置每次对应的值总是唯一的)

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
int num[100005];
int t,cnt,n,x;
bool flag=false;
char s[100005];
int main()
{
	scanf("%d",&t);
	while(t--)
	{
		cnt=0;
		flag=false;
		scanf("%d%d",&n,&x);
		scanf("%s",s+1);
		for(int i=1;i<=n;i++)
		{
			if(s[i]=='0')
			{
				num[i]=num[i-1]+1;				
			}
			else num[i]=num[i-1]-1;
			if(num[i]==x) flag=true;
		}
		int p=num[n];
		if(p==0)
		{
			if(flag==true)
			{
				printf("-1\n");
				continue;
			}
			else
			{
				printf("0\n");
				continue;
			}
		}
		else 
		{
			for(int i=1;i<=n;i++)
			{
				int m=x-num[i];
				if(m%p==0&&m/p>=0) 
				{
					cnt++;
				}
			}
		}
		if(x==0) cnt++;
		printf("%d\n",cnt);
	}
}

C : Obtain The String

题意

给定字符串 s 和 t ，每次从 s 中选取子序列放入起始为空串的 z 后，问最少需要多少次操作使得 z=t

思路

看了小姜老师的博客解法说是贪心，想了好一会，好像确实是可以贪心的···? 设置两个指针从 s 和 t 串的头部开始扫，对于 t 串中的每个字母，循环扫 s 串在其中找与它相同的，最终的答案就是扫 s 串的次数。(小姜老师说这个实质上就是每次尽可能找尽可能多的后缀，仔细想想确实是这样。)不过这么一直暴力扫下去肯定不是最优的方法，想办法去优化。还是借鉴大佬的想法用一个lens*26的跳表，然后O(lent)扫一遍 t 即可.

跳表nxt的作用，用于寻找下一个所寻找字符在s中的位置。

nxt[x][y]用于指向从x位置开始下一个y的位置+1 （next在C++属于保留字，注意不要踩坑）

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cstring>
#include<iostream>
using namespace std;

const int maxn=100005;
char s[maxn],t[maxn];
int nxt[maxn][30];
int p,lens,lent;
int pos,ans; 
int main()
{
	scanf("%d",&p);
	while(p--)
	{
		ans=1;
		scanf("%s",s+1);
		scanf("%s",t);
		lent=strlen(t),lens=strlen(s+1);
//		printf("%d",lens);
		for(int c=0;c<26;c++)
		{
			nxt[lens+1][c]=-1;
			for(int i=lens;i>=1;i--)
			{
				if(s[i]-'a'==c)
				{
					nxt[i][c]=i+1;
				}
				else nxt[i][c]=nxt[i+1][c];
			}
		}
		pos=1;
		for(int i=0;i<lent;i++)
		{
			pos=nxt[pos][(int)t[i]-'a'];
			if(pos==-1)
			{
				ans++;
				pos=1;
				pos=nxt[pos][(int)t[i]-'a'];
				if(pos==-1)
				{
					ans=-1;
					break;
				}
			}
		}
		printf("%d\n",ans);
	}
}