Good Bye 2021: 2022 is NEAR（A~D，E已补）

最新推荐文章于 2024-09-14 22:25:23 发布

ATM与nudun的爱恨情仇

最新推荐文章于 2024-09-14 22:25:23 发布

阅读量439

点赞数 4

分类专栏： acm 文章标签：算法 c++ 数据结构

本文链接：https://blog.csdn.net/ATM1459007298/article/details/122248667

版权

acm 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

这场题目一言难尽，难度不大但挺搞心态的，D题打的太犹豫了，在两种思路面前反复横跳，结果浪费了接近1个小时，然后E题感觉比D简单好多。

（PS：由于最近进入考试周了，不能按时更新，只能等有空再更新了）

A. Integer Diversity（思维）

对abs（a[i]）进行数字统计，0最多算1个，其他最多算2个

#include <bits/stdc++.h>
#define ll long long
#define ls p<<1
#define rs p<<1|1
#define Ma 1000005
#define mod 1000000007
using namespace std;
ll a[Ma];

map <ll,ll> mp;


int main()
{
	ll tt;
	scanf("%lld",&tt);
	while (tt--)
	{
		mp.clear();
		ll n;
		scanf("%lld",&n);
		for (ll i=1;i<=n;i++)
		{
			scanf("%lld",&a[i]);
			mp[abs(a[i])]++;
		}
		ll ans=0;
		for (ll i=0;i<=100;i++)
			if (i==0)
				ans+=min(1ll,mp[i]);
			else
				ans+=min(2ll,mp[i]);
		printf("%lld\n",ans);
	}
	return 0;
}

B. Mirror in the String（思维）

首先对于字符串s，我们把镜子放在从0开始

假设镜子已经在位置i（i<n-1），若s[i]>s[i+1]我们无条件将镜子右移

若s[i]==s[i+1]，如果i==0,我们保留位置，否则右移

（例如：aaa->aa, baa->baaaab）

若s[i]<s[i+1]我们保留位置

#include <bits/stdc++.h>
#define ll long long
#define ls p<<1
#define rs p<<1|1
#define Ma 1000005
#define mod 1000000007
using namespace std;
ll a[Ma];



int main()
{
	ll tt;
	scanf("%lld",&tt);
	while (tt--)
	{
		ll n;
		scanf("%lld",&n);
		string s;
		cin>>s;
		ll k=s.size()-1;
		for (ll i=0;i<n-1;i++)
			if (s[i]<s[i+1]||s[i]==s[i+1]&&i==0)
			{
				k=i;
				break;
			}
			
		for (ll i=0;i<=k;i++)
			printf("%c",s[i]);
		for (ll i=k;i>=0;i--)
			printf("%c",s[i]);
		printf("\n");
	}
	return 0;
}

C. Representative Edges（暴力+贪心）

我们发现他给出的式子就是让我们搞一个等查数列

由于n<=70，我们只需确定任意两点即可

复杂度o( $n^3$ )

#include <bits/stdc++.h>
#define ll long long
#define ls p<<1
#define rs p<<1|1
#define Ma 1000005
#define mod 1000000007
using namespace std;
ll a[Ma];
ll n;

ll sol(ll x,ll y)
{
	ll ans=0;
	for (ll i=1;i<=n;i++)
		if ((a[i]-a[x])*(y-x)==(a[y]-a[x])*(i-x))
			ans++;
	return ans;
}

int main()
{
	ll tt;
	scanf("%lld",&tt);
	while (tt--)
	{
		
		scanf("%lld",&n);
		for (ll i=1;i<=n;i++)
			scanf("%lld",&a[i]);
		ll ma=0;
		for (ll i=1;i<=n;i++)
			for (ll j=i+1;j<=n;j++)
				ma=max(ma,sol(i,j));
		if (n==1)
			ma=1;
		printf("%lld\n",n-ma);
	}
	return 0;
}

D. Keep the Average High(dp+思维)

(开始想着用dp，结果感觉用dp不好写，然后又去往双指针与队列方面想，贡献一发wa后感觉也不好写，然后就开始反复横跳，最后定下来用dp发现出奇简单，写了15min就过了，心态炸裂)

首先我们容易发现要我们求的区间[le,re]中满足任意l,r

al+al+1+…+ar≥x⋅(r−l+1).

其实可以变成a[i]+a[i+1]>=2*x，但我们会发现这样并不能完全满足条件

对于这点我们定义>=x的数称之为大数,<x的数称之为小数，对于选入的[le,re]，可能会有

（小，大，小）的情况，而最劣情况为（...,小，大，小，大，小，大，......）

因此只需确定a[i]+a[i+1]+a[i+2]>=3*x和a[i]+a[i+1]>=2*x即可

这样我们就可以得出dp[i][j]（设i为第i位数，j为i的前面选了多少选入且连续的数（包括i））

由于上述条件我们发现j最大只需取到3即可

复杂度:o(3*n)

#include <bits/stdc++.h>
#define ll long long
#define ls p<<1
#define rs p<<1|1
#define Ma 1000005
#define mod 1000000007
using namespace std;
ll a[Ma];
ll l[Ma];
ll dp[Ma][4];

int main()
{
	ll tt;
	scanf("%lld",&tt);
	while (tt--)
	{
		ll n,k;
		scanf("%lld",&n);
		for (ll i=1;i<=n;i++)
			scanf("%lld",&a[i]);
		scanf("%lld",&k);
		memset(dp,0,sizeof(dp));
		for (ll i=1;i<=n;i++)
		{
			dp[i][0]=max(max(dp[i-1][3],dp[i-1][0]),max(dp[i-1][1],dp[i-1][2]));
			dp[i][1]=dp[i-1][0]+1;
			if (i>1&&a[i]+a[i-1]>=2*k)
				dp[i][2]=max(dp[i-2][0]+2,dp[i-1][1]+1);
			if (i>2&&a[i]+a[i-1]+a[i-2]>=3*k&&a[i]+a[i-1]>=2*k&&a[i-1]+a[i-2]>=2*k)
				dp[i][3]=max(max(dp[i-3][0]+3,dp[i-2][1]+2),max(dp[i-1][2]+1,dp[i-1][3]+1));
		}
		printf("%lld\n",max(max(dp[n][0],dp[n][1]),max(dp[n][2],dp[n][3])));
	}
	return 0;
}

E. Lexicographically Small Enough（数据结构+贪心）

这题想到思路很简单，只是写起来费点时间，可惜栽在D上，没时间写了。

首先我们可以发现这题就硬贪+摸你就能得出答案，但时间复杂度为o( $n^2$ )显然不能通过

假设我们把j换到i的位置，这就等价于[i,j-1]+1，j->i，这就可以用线段树实现，复杂度为o（nlogn）

#include <bits/stdc++.h>
#define ll long long
#define ls p<<1
#define rs p<<1|1
#define Ma 1000005
#define mod 1000000007
#define inf 1e18
using namespace std;

string s,st;
ll n;
ll pre[Ma];

struct node
{
	ll l,r,w,add;
}t[Ma];

void build(ll p,ll l,ll r)
{
	t[p].l=l,t[p].r=r,t[p].add=0;
	if (l==r)
	{
		t[p].w=l;
		return;
	}
	ll mid=(l+r)>>1;
	build(ls,l,mid);
	build(rs,mid+1,r);
	t[p].w=t[ls].w+t[rs].w;
	return;
}

void spread(ll p)
{
	if (t[p].add)
	{
		t[ls].add+=t[p].add,t[rs].add+=t[p].add;
		t[ls].w+=t[p].add*(t[ls].r-t[ls].l+1);
		t[rs].w+=t[p].add*(t[rs].r-t[rs].l+1);
		t[p].add=0;
	}
	return;
}

void change(ll p,ll l,ll r)
{
	if (l>r)
		return;
	if (l<=t[p].l&&t[p].r<=r)
	{
		t[p].add++;
		t[p].w+=(t[p].r-t[p].l+1);
		return;
	}
	spread(p);
	ll mid=(t[p].l+t[p].r)>>1;
	if (l<=mid)
		change(ls,l,r);
	if (r>mid)
		change(rs,l,r);
	t[p].w=t[ls].w+t[rs].w;
	return;
}

ll ask(ll p,ll l,ll r)
{
	if (l<=t[p].l&&t[p].r<=r)
		return t[p].w;
	spread(p);
	ll mid=(t[p].l+t[p].r)>>1;
	ll val=0;
	if (l<=mid)
		val+=ask(ls,l,r);
	if (r>mid)
		val+=ask(rs,l,r);
	return val;
}

vector <ll> a[26];

void sol()
{
	build(1,0,n-1);
	for (ll i=0;i<26;i++)
		a[i].clear(),pre[i]=0;
	for (ll i=0;i<s.size();i++)
		a[s[i]-'a'].push_back(i);
	ll mi=inf,ans=0;
	for (ll i=0;i<st.size();i++)
	{
		for (ll j=0;j<st[i]-'a';j++)
			if (pre[j]<a[j].size())
			{
				ll p=ask(1,a[j][pre[j]],a[j][pre[j]]);
				mi=min(mi,ans+p-i);
			}
		if (pre[st[i]-'a']>=a[st[i]-'a'].size())
			break;
		ll p=ask(1,a[st[i]-'a'][pre[st[i]-'a']],a[st[i]-'a'][pre[st[i]-'a']]);
		ans+=p-i;
		change(1,0,a[st[i]-'a'][pre[st[i]-'a']]);
		pre[st[i]-'a']++;
	}
	if (mi==inf)
		printf("-1\n");
	else
		printf("%lld\n",mi);
	return;
}


int main()
{
	ll tt;
	scanf("%lld",&tt);
	while (tt--)
	{
		
		scanf("%lld",&n);
		cin>>s>>st;
		sol();
	}
	return 0;
}