文章介绍了四个Codeforces问题的解题思路，涉及模板字符串匹配、二进制分析、动态规划在形成三角形和子序列问题中的应用，以及处理城市间的最短路径问题。
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是必然的事情，只要还没结束，那么就不要认输放弃，说不定下一秒就写出来了。
239
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
