A题：Tokitsukaze and Bracelet
思路：
签到题，可以直接模拟，也可以找到规律，简化代码。
代码：
#include <iostream>
using namespace std;
int main()
{
int t;
cin>>t;
while (t--)
{
int a,b,c;
cin>>a>>b>>c;
int count=0;
if(a>=150) count++;
if(a>=200) count++;
if(b>=34) count++;
if(b>=45) count++;
if(c>=34) count++;
if(c>=45) count++;
cout<<count<<endl;
}
return 0;
}#include <iostream>
using namespace std;
int a,b,c;
int calc(int x)
{
if(x<=32) return 0;
else if(x<=40) return 1;
return 2;
}
int solve(int a,int b,int c)
{
a/=50;
a-=2;
int ans=a+calc(b)+calc(c);
return ans;
}
int main()
{
int t;
cin>>t;
while (t--)
{
int a,b,c;
cin>>a>>b>>c;
int count=solve(a,b,c);
cout<<count<<endl;
}
return 0;
}B题：Tokitsukaze and Cats
思路：
每一只猫需要4个网，但如果猫的上下左右也就是距离为一的位置上有猫的话，就可以在相应的方向上共用同一张网，所以我们可以统计这种共用网的个数，然后用猫的数量减去共用网的数量即可。
代码：
时间复杂度o(k)也就是o(n*m)
#include<iostream>
using namespace std;
typedef pair<int,int> PII;
const int N=1e5+10,M=310;
int map[M][M];
PII e[N];
int main()
{
int n,m,k;
scanf("%d%d%d",&n,&m,&k);
int count=0;
for(int i=0;i<k;i++)
{
int a,b;
scanf("%d%d",&a,&b);
map[a][b]=-1;
e[i]={a,b};
}
int dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};
for(int i=0;i<k;i++)
{
int x=e[i].first,y=e[i].second;
for(int j=0;j<4;j++)
{
int a=x+dx[j],b=y+dy[j];
if(a>0 && a<=n && b>0 && b<=m && map[a][b]==-1)
count++;
}
}
count/=2;
int ans=k*4-count;
printf("%d\n",ans);
return 0;
}E题： Tokitsukaze and Eliminate (easy)
思路：
本题由于颜色种类小，所以可以使用两个栈来模拟，先让1，0宝石分别以下标方式入栈，然后清除，出栈，模拟即可，
代码：
时间复杂度o(2n)
#include<iostream>
using namespace std;
const int N=1e6+10;
int t1[N],tt;
int t2[N],yy;
int main()
{
int t;
scanf("%d",&t);
while (t--)
{
int n;
scanf("%d",&n);
for(int i=0;i<n;i++)
{
int a;
cin>>a;
if(a==1) t1[++tt]=i;
else t2[++yy]=i;
}
int count=0;
while (tt!=0 && yy!=0)
{
if(t1[tt]<t2[yy])
{
while (t2[yy]>t1[tt])yy--;
tt--;
}
else
{
while (t1[tt]>t2[yy])tt--;
yy--;
}
count++;
}
while (tt!=0) tt--,count++;
while (yy!=0) yy--,count++;
printf("%d\n",count);
}
return 0;
}F题：Tokitsukaze and Eliminate (hard)
思路：
本题由于宝石颜色种类最大为2*10的5次方，所以就不能采用模拟栈的方式，会超时的，所以本题需要考虑其他做法。
本题可以使用两个数组las, pre，las记录每种颜色当前最大的下标位置（用于第一次寻找当前最大下标的最小下标），pre 记录每次输入宝石颜色的前一个下标位置（用于标记被清除的下标中前一个下标的位置），之后用两个变量last,newlast分别表示，last当前最大下标中最小下标的位置（也就是当前最后一个宝石的下一个位置），newlast下一个最大下标中最小下标的位置，然后倒序开始遍历，寻找。
注：数组最好从1开始赋值，因为我们需要一个标志来表示最小下标，如果以0开始的话，那么第一个下标为0，如果出现有种颜色已经删完了，那么在之后遍历中newlast会为0，这样的话，就等于直接跳到了第一个元素，结果就会错误，所以下标最好以1开始，并且，当他的pre为0的时候，不进行计算最小值的操作。
代码：
时间复杂度o(n)
#include<iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int N=2e5+10;
int a[N];
int pre[N],las[N];
int main()
{
ios::sync_with_stdio(false);
cin.tie(0),cout.tie(0);
int t;
cin>>t;
while (t--)
{
int ans=0;
int n;
cin>>n;
for(int i=1;i<=n;i++)
{
las[i]=0;
pre[i]=0;
}
for(int i=1;i<=n;i++)
{
cin>>a[i];
pre[i]=las[a[i]];
las[a[i]]=i;
}
int last=N,newlast=N;
for(int i=1;i<=n;i++)
{
if(las[i]!=0) last=min(last,las[i]);
}
for(int i=n;i>=1;i--)
{
if(i>last)
{
if(pre[i]!=0) newlast=min(newlast,pre[i]);
//如果i >last 那么统计删除宝石中最小前下标
}
else
{
if(pre[i]!=0) newlast=min(newlast,pre[i]);
//当i==last 再判断下当前位置的前最小下标，之后完成删除操作，执行移位操作
last=newlast; //将last移动到从删除宝石中统计的最小前下标上。
ans++; //统计执行移位操作次数
}
}
cout<<ans<<endl;
}
return 0;
}I题：Tokitsukaze and Short Path (plus)
思路：
本题基本意思就是，计算每一个点到其他点的最小路径，然后累加起来输出。
本题n的最大值为2*10的5次方，所以代码的时间复杂度为o(n),o(nlogn),o(nsqrt(n))，才能过，
所以不能盲目的模拟，遍历。
本题将他的边权计算公式|au+av|+|au-av|抽象成一个柱状图的话，你就会惊奇的发现，这个公式还可以化简。
所以我们计算边的长度就可以简化为2*max（au，av），可怎么才能方便我们找到max（au，av）呢？
我们可以运用排序，将每一个点进行排序，然后从后向前找，
这时就需要考虑，如果au与av之间有其他的路径可以到达呢？哪种最短呢？
所以我们就得到了，计算最短路的方法了，
然后，我们就可以计算最短路之和了，通过遍历数组，对于每一个元素，向前计算他前面的所有最短路，也就是2ai*（i-1） 向后计算他的后缀和sum，2*sum，相加统计即可。
注意：ai最大为2*10的5次方，所以计算后缀和以及前面值2ai*(i-1)需要注意溢值的问题。
代码：
时间复杂度o(nlogn)
#include<iostream>
#include <algorithm>
using namespace std;
const int N=2e5+10;
int a[N];
void solve()
{
int n;
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
sort(a+1,a+n+1);
long long ans=0,sum=0;
for(int i=n;i>=1;i--)
{
ans+=2*sum;
ans+=2*a[i]*(long long )(i-1);//此处需要特别注意 两个整数相乘过程中还是整数，也会溢出，
// 所以还是需要转换一下
sum+=a[i];
}
cout<<ans<<endl;
}
int main()
{
int t;
cin>>t;
while (t--)
solve();
return 0;
}J题：Tokitsukaze and Short Path (minus)
思路：
同上一篇的I题一样，将边权公式抽象为矩形图之后：
我们通过排序之后，就可以保证他们的值的计算。
这时，我们需要考虑，边权最小值的几种可能。
然后我们在遍历计算的时候计算它每一个值的前缀和和后缀和，最后的总和就是答案。
注：前缀和和后缀和，以及里面涉及到乘法的计算，都需要注意溢出的情况，开long long 范围即可
代码：
时间复杂度o(n)
#include<iostream>
#include <algorithm>
using namespace std;
const int N=2e5+10;
int a[N];
int main()
{
int t;
cin>>t;
while (t--)
{
int n;
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
sort(a+1,a+n+1);
long long sum=2*a[1],ans=2*a[1]*(long long)(n-1);
for(int i=2;i<=n;i++)
{
ans+=min(2*a[i],4*a[1])*(long long )(n-i);
ans+=sum;
sum+=min(2*a[i],4*a[1]);
}
cout<<ans<<endl;
}
return 0;
}
1293
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
