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];elseans=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<=ng.resize(unique(g.begin(),g.end())-g.begin());O(m),m<=nfor(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);//出了空还多一个1for(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是必然的事情，只要还没结束，那么就不要认输放弃，说不定下一秒就写出来了。