2020超级码力初赛一题解

树木规划

这个没啥好说的，暴力就完事儿了。
好叭还是简单说说。
要删除最少的元素，反过来，我们就要保留尽可能多的元素。对于一个元素x，保证合法的情况下，他的下一个元素就应该在x＋d及其以后，这样，对于一个位置x，我们可以得到最长的包含x的合法序列长度。

例如d＝2 树的位置{1，2，3，5，6}。那么包含1的最长合法序列就是1 3 5，并且后续不用再次遍历1 3 5这三个元素了，所以将它标记掉。

总复杂度o（nlogn）

class Solution {public:int n,vis[100010]={0},ans=0;int treePlanning(vector<int> &trees, int d) {n=trees.size();for(int i=0;i<n;i++){if(vis[i]==1)continue;int num=0;int si=i;while(si<n)//从i开始，每次找最小的合法位置{si=lower_bound(trees.begin(),trees.end(),trees[si]+d)-trees.begin();//二分查找最小的合法位置vis[si]=1;//标记掉这个位置num++;//序列长度加一}ans=max(num,ans);//更新答案}return n-ans;}
};

正三角形拼接

简单来说，需要使得某个数字的出现次数>=3。
如果存在数字x出现次数>=3，答案为0 。
如果存在数字x出现两次，并且存在一个比x大的数字，那直接把大的数字分割出一个x即可。答案为1 。
如果存在数字x出现一次，并且存在数字x*2，那把大的分割一次就可以分割出两个x。答案为1 。
剩下的情况下，最多两次就可以分割出3个相同的数字。

按照上述顺序，map标记判断即可。
总复杂度o（nlogn）

class Solution {public:
#define all(x) (x).begin(),(x).end()int makeEquilateralTriangle(vector<int> &lengths) {sort(all(lengths));map<int,int> vis;for(int i:lengths)vis[i]++;//标记每个长度的出现次数lengths.resize(unique(all(lengths))-lengths.begin());//去重，更新sizeint n=lengths.size();for(int i=0;i<n;i++)if(vis[lengths[i]]>=3)return 0;for(int i=0;i<n;i++)if((vis[lengths[i]]>=2&&i!=n-1)||(vis[lengths[i]]>=1&&vis[lengths[i]*2]>=1))return 1;return 2;}
};

大楼间穿梭

这题的“高”竟然是>=的意思，卡的我一度怀疑人生。
容易发现“右边第一个比自己大的数字”是单调栈的经典模型，并且每个点p的花费都是左边能到p的点q的花费+q到p转移过程的花费，由此可以推出dp转移式。

设dp[i]为到i为止的跳跃最小花费。
dp[i]=min(dp[i-1],dp[i-2])+y
dp[i]=min(dp[右边第一个比自己大的点是i的点])+x

例如{3 2 1 5}，5可以通过y的花费由1和2转移过来。同时5也可以通过花费x由3 2 1转移过来。
所以通过单调栈处理出每个位置的右边，第一个比自己大的元素位置，然后dp转移一下即可。

总复杂度o(n)
(忽略我直接全部开的longlong

class Solution {public:long long b[200010],dp[200010];vector<long long> v[200010];long long shuttleInBuildings(vector<int> &heights, int k, int x, int y) {long long n=heights.size();for(long long i=0; i<=n; i++)b[i]=n+1,dp[i]=1e18;//初始化stack<long long> Q;for(long long i=0; i<n; i++){while(!Q.empty()&&heights[Q.top()]<=heights[i])//维护一个单调递减的序列。q.top第一次遇见了一个比自己大的元素。{b[Q.top()]=i;//q.top的右边第一个比自己大的元素的下标为iQ.pop();}Q.push(i);}for(long long i=0; i<n; i++)if(b[i]-i<=k)v[b[i]].push_back(i);//存下能到达b[i]的位置有哪些。dp[0]=0;//到达起点的花费为0for(long long i=1;i<n;i++){for(long long j:v[i])dp[i]=min(dp[i],dp[j]+x);//遍历所有右边第一个比自己大的元素是i的位置，更新答案dp[i]=min(dp[i],dp[i-1]+y);//前一个位置通过花费y转移if(i-2>=0)//判越界dp[i]=min(dp[i],dp[i-2]+y);}return dp[n-1];}
};

对称前后缀

3e3的范围,明显是n^2的做法。
暴力方法的话，枚举起点和终点，然后遍历中间的子串，就可以得到答案。但是这种n^3的方法显然没法通过这道题。

可以枚举中间点，往两边扩展，并且标记这个中间点到目前为止有没有失去匹配过，如果没有失去匹配过，那这个串的贡献就是整个串的长度（回文串前缀后缀完全匹配），否则就为整个串匹配长度的一半。

比如对于串“1 2 3 4 3 5 1” ，以从4开始往两边扩展举例。
假如两个位置对应相同，则前缀和后缀匹配个数就会＋1。
（1）4的时候，没有失配过，串为回文串，所以匹配长度为整个子串长度1。
（2）3 4 3的时候，没有失配过，串为回文串，所以匹配长度为整个子串的长度3
（3）2 3 4 3 5时，2!=5，失配，重置匹配长度为0。
（4）1 2 3 4 3 5 1时，1＝1，匹配长度＋1，并且因为失配过，所以这个串不是回文串，匹配长度为1。

总复杂度o（n^2）

class Solution {public:long long suffixQuery(string &s) {long long ans=0;for(int i=0;i<s.size();i++){int l=i,r=i+1,f=0;long long num=0;while(l>=0&&r<s.size())//以i和i+1的中间空位为中心{num++;if(s[l]==s[r]){if(f==0)ans+=num*2;elseans+=num;}else{f=1;num=0;}l--;r++;}l=i,r=i,f=0;num=0;while(l>=0&&r<s.size())以i为中心{num++;if(s[l]==s[r]){if(f==0)ans+=num*2-1;elseans+=num;}else{f=1;num=0;}l--;r++;}} return ans;}
};