Tricky Template(Problem - A - Codeforces)
题目大意:现有三个模板字串a,b,c,都由小写字母组成,问能否找到一个字串s,使s与a,b匹配,与c不匹配,匹配的条件如下:
如果s的某位为小写字母,那么需要与匹配串的对应位完全相同
如果某位为大写字母,那么需要与匹配串的对应位不同
思路:这题的考点就在于什么时候出现题目要求的情况,只要有一位满足,哪怕剩下的不满足也无所谓,那么就要看a[i],b[i],c[i]的关系,如果a[i]=b[i]=c[i],那么这一位能与a,b匹配就一定能与c匹配,如果a[i]=b[i]!=c[i],那么填上a[i]即可,如果如果a[i]!=b[i],这一位可以填一个大写字母,这个大写字母与c[i]相同但不与a[i],b[i]相同即可,也就是说,只要有一个位置a[i]!=c[i]&&b[i]!=c[i]就成立。
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
int n;
string a,b,c;
cin>>n>>a>>b>>c;
int flag=0;
for(int i=0;i<n;i++)
{
if(a[i]!=c[i]&&b[i]!=c[i])
{
flag=1;
break;
}
}
if(flag) printf("YES\n");
else printf("NO\n");
}
}
Forming Triangles(Problem - B - Codeforces)
题目大意:现给出若干条边,每条边的长度为2^a[i],要找出三边组成一个三角形(非退化三角形就是一个有面积的三角形),问最多有多少种组合(数相同,但所处位置不同视为不同的选择)
思路:这里提到了2^a[i],那么就要从二进制的角度来看看有什么规律:
2^i=2^(i-1)+2^(i-1)
然后又由三角形两边之和大于第三边,所以我们必须选两个相同的,然后再选一个小于等于它们的。那么情况实际就出来了,先统计出每种长度边的个数,用map统计,刚好还能顺便排个序。然后从小到大访问,对于每种长度,如果大于等于2才有讨论的价值,选出两条当前长度的边,假设当前长度的有k条边,那么这两条边的选择的情况就有(k-1)*k/2,然后第三条边的选择为前c条边的总个数+(k-2),那么遍历map就能统计出来。
#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main()
{
int t;
scanf("%lld",&t);
while(t--)
{
int n;
scanf("%lld",&n);
map<int,int>mp;
for(int i=1;i<=n;i++)
{
int x;
scanf("%lld",&x);
mp[x]++;
}
int c=0;
int ans=0;
for(auto it:mp)
{
int d=it.second;
if(d>=2)
{
ans += (d-1)*d/2*c;//前面的
ans += (d-2)*(d-1)*d/6;//本身
}
c+=d;
}
printf("%lld\n",ans);
}
}
Closest Cities(Problem - C - Codeforces)
题目大意:现有一排城市,它们的坐标单增,然后每个城市有一个最近城市(距离绝对值是这个城市到所有城市中最小的),对于城市x,如果要到城市y,那么有两种情况:
y是x的最近城市:花费1;
y不是x的最近城市:花费abs(ax-ay)
现有q个查询,a,b,求a到b的最小花费。
思路:我们来看从a到b,如果直接走,由于坐标单增,实际上相当于一个点一个点走,两点之间花费为坐标差,或者1,因为单增,所以不会重复计算某一段。然后有q个询问,那么我们只要预处理出来从前到后和从后到前的前缀和不就好了。
#include<bits/stdc++.h>
using namespace std;
int a[200010],ne[200010],s1[200010],s2[200010];
signed main()
{
int t;
scanf("%d",&t);
while(t--)
{
int n;
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
ne[1]=2,ne[n]=n-1;
for(int i=2;i<=n-1;i++)
{
int l=a[i]-a[i-1],r=a[i+1]-a[i];
if(l<r) ne[i]=i-1;
else ne[i]=i+1;
}
s1[1]=0;
int c=1;
for(int i=2;i<=n;i++)
{
if(ne[c]==i) s1[i] = s1[c]+1;
else s1[i] = s1[c]+a[i]-a[c];
c=i;
}
s2[n]=0;
c=n;
for(int i=n-1;i>=1;i--)
{
if(ne[c]==i) s2[i]=s2[c]+1;
else s2[i]=s2[c]+a[c]-a[i];
c=i;
}
int q;
scanf("%d",&q);
while(q--)
{
int l,r,ans=0;
scanf("%d%d",&l,&r);
if(l<r)
ans = s1[r]-s1[l];
else
ans=s2[r]-s2[l];
printf("%d\n",ans);
}
}
}
ps:这里我最初还想的是给每个点和它可以到的点打上标记,然后判断标记是否相同(来自Salyg1n and the MEX Game(Problem - C - Codeforces),包括画的有向图的想法也来自这里),然后后来又想到遍历每个点,以每个点作为中转(来自最长上升子序列状态转移的思路),再后来又想到找离它们最近的标记相同的点(来自2D Traveling(Problem - B - Codeforces)),再往后发现找起来太麻烦,然后发现性质,打算遍历,然后超时了,想到前缀和优化,然后ac。所以,思路未必是一次就想到的,就是这样不断猜测不断尝试不断推翻最后实现的过程。而且这每一步其实都是联想到之前题目的解法类比出来的,所以呀,哪有什么捷径,都是不断学习新的知识点,不断补题学习新思路,不断内化,然后转为输出的过程。
Berserk Monsters(Problem - D - Codeforces)
题目大意:现在有n个怪兽排成一排,每个怪兽有一个攻击值a和一个防御值d,对它们发动魔法攻击,它们可以同时对相邻位置的怪兽产生a的伤害,如果一个怪兽受到的伤害值大于d,那么这个怪兽就死亡,游戏进行n轮,要求每轮死亡怪兽的数目。
思路:乍一看很简单,就是一个双向链表的题,可以定义l[],r[]两个数组来表示指针,单独定义一个数组储存它们受到的伤害,最后链表遍历结束时,遍历怪兽,将受到伤害的怪兽移出链表。看起来很对,也确实可以实现,但是这里的时间复杂度就是O(n^2),因为回合是n轮,每次遍历怪兽判断是否死亡的时间复杂度也是O(n),那么合起来就是O(n^2),有没有什么办法可以进行优化呢?显然是有的,我们可以发现怪兽左边相邻的怪兽的下标一定比它小,右边相邻的怪兽的下标一定比它大。然后我们与删除位置相邻的怪兽的左右会变,别的怪兽的左右不会变,所以它原来如果没被删除,那么将可以删除的部分删除后,它们仍然不会被删除,那么就没有遍历的必要。所以我们将删除位置左右没被删除的元素记录下来即可。再次遍历时,就只访问这些元素。然后再来看,我们如何去删除元素呢,显然用:
r[l[i]]=r[i]
l[r[i]]=l[i]
那么我们如果有三个元素a,b,c,相邻的两个元素b,c都被删除,岂不是a被被放进新数组两次,这也产生了冗余,那就需要用到vector容器的两个函数unique(),resize(),unique()将所有元素调整一下,对于重复元素,取一个放到前面来,剩下的都放在后面,结束时,返回不重复部分尾元素的迭代器,resize()重新分配空间大小,所以就是g.resize(unique(g.begin(),g.end())-g.begin())即可实现,那么这道题的优化就完成了,我们只记录删除位置左右未被删除的元素,所以最坏情况是隔一个删一个那么每次砍半,但是并不会真的出现这种情况,所以时间复杂度是小于O(nlogn)的,可以AC。
#include<bits/stdc++.h>
using namespace std;
int a[300010],d[300010],l[300010],r[300010],st[300010];
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
int n;
scanf("%d",&n);
vector<int>g,v;
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
g.push_back(i);
l[i]=i-1;
r[i]=i+1;
st[i]=1;
}
a[n+1]=0;
r[n]=0;
for(int i=1;i<=n;i++) scanf("%d",&d[i]);
for(int k=0;k<n;k++)
{
sort(g.begin(),g.end());//O(mlogm),m<=n
g.resize(unique(g.begin(),g.end())-g.begin());O(m),m<=n
for(auto it:g)O(m),m<=n
{
if(d[it]<a[l[it]]+a[r[it]])
{
v.push_back(it);
st[it]=0;
}
}
g.clear();
for(auto i:v)//O(m),m<=n
{
/*这里实际上只考虑原来位置删除后,新产生的相邻关系会不会造成删除,原来不能删的,如果相邻元素没变,
一样不能删,没有考虑的必要,原来能删的已经删除,自然不会被放入,所以g一下被缩小到很小,
最坏隔一位删一个,那么就变成一半,剩余的都比一半小,所以最坏是logn,而且肯定不到logn*/
l[r[i]]=l[i],r[l[i]]=r[i];
if(st[l[i]]) g.push_back(l[i]);
if(st[r[i]]) g.push_back(r[i]);
}
cout<<v.size()<<" ";
v.clear();
}
cout<<endl;
}
}
Increasing Subsequences(Problem - E - Codeforces)
题目大意:现在要创建一个数组,使数组中的严格上升子序列的个数恰好为x个。输出数组长度和具体的数,如果不成立则输出-1.另外数组长度不能超过200。
思路:这个题按照题目意思来看,这个数组可以是任意的,所以正着想不大好想,似乎没什么规律,那么我们倒着来看,如何统计一个序列中单增序列的个数,这里显然需要用到动态规划:
dp[i]表示以i作为结尾的单增序列的个数,那么就如下更新:
dp[i]=1(前面一个序列都不加)
dp[i]+=dp[x](1<=x<v,如果a[i]>a[x])
我们就此找出每个位置可以产生的上限,进而算出总的最大值,因为要考虑是否可以产生这样的数组
max:
dp[1]=1;
dp[2]=1+dp[1]=2;
dp[3]=1+dp[1]+dp[2]=4;
dp[4]=1+dp[1]+dp[2]+dp[3]=8;
...
是不是有点特点,某个位置前面如果有多少个小于它的数,那么就可以产生2多少次方个贡献。
所以我们考虑将n转化成二进制的角度来看,我最开始的思路是通过将高位转化到低位,然后按照
v,v+1,...,v+k,v,v+1,v+2,...
的顺序来放,每一组内部包含一个所有位。
但是很显然长度会超,那么我们在找找别的规律来看:
以37为例:
100101
空也为一种情况,所以凑出36即可
100100
如果将最高位拆下来:011212
再举一个偶数来看:
36
则需凑出35:
100011
如果将最高位拆下来:011123;
我们会发现拆的时候除了最后一位和原本是1的地方外,其他都是1,为1则表示前面有多少个小于它的数,那么我们可以设定一个单增的序列:
1 2 3 4 5 5
那么得到的单增序列长度为:1 2 4 8 16 16
这样可以看出,1和2都能对应凑出来,如果为3的话,也是最后一位为3,前面有0个小于它的数,那么直接开头填一个最大值即可。
那么思路就有了,我们直接拆太麻烦,就看原数的每位数的前一位(从右往左访问),如果为1,那么在添完本位数后,后面多填一个最大的数,这样就可以保证下一位有两个。这样看实际0位,如果原数是偶数,那么0位就是0,最后应该有两个数前面有0个元素小于它,一个是我们填进去的第一个元素,一个代表空集合。如果原数是奇数,那么这一位实际应该有3个数前面有0个元素小于它,除了刚提到的两个,我们再多加一个最大数即可。
#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main()
{
int t;
scanf("%lld",&t);
while(t--)
{
int n;
scanf("%lld",&n);
int k=__lg(n);//二进制下最高位1在哪里
vector<int>g;
if(n%2) g.push_back(k);//出了空还多一个1
for(int i=0;i<k;i++)
{
g.push_back(i);
if(n>>i+1&1 && i+1!=k) g.push_back(k);
}
cout<<g.size()<<endl;
for(auto i:g) cout<<i<<" ";
cout<<endl;
}
}
ps:哈哈哈,这次终于轮到我卡着最后一分钟ac了。所以哪有什么应不应该,没思路就去想思路,有思路了就去实现思路,那么ac是必然的事情,只要还没结束,那么就不要认输放弃,说不定下一秒就写出来了。