前言

无敌！！第一次打Div3，因为之前打Div4赛时也就三四题，所以在打之前根本没想到自己能做到赛时三题！！虽然第三题是离结束十几秒的时候交的，没想到判完题比赛结束了还不算赛时通过……TvT

A. Square Year

#include <bits/stdc++.h>
using namespace std;typedef long long ll;
typedef pair<int,int> pii;void solve()
{string s;cin>>s;int num=0;for(int i=0;i<4;i++){num=num*10+s[i]-'0';}int sq=sqrt(num);if(sq*sq==num){cout<<0<<" "<<sq<<endl;}else{cout<<-1<<endl;}
}int main()
{ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--){solve();    }return 0;
}

这个题说实话有点恶心，感觉一开始题意不是很明确，没写随便输出一个即可，所以还对着用例想了半天。

随便输出一个那就简单了，那就是如果能开方就直接输出0和开平方后的数，不能就直接-1即可。

B. Not Quite a Palindromic String

#include <bits/stdc++.h>
using namespace std;typedef long long ll;
typedef pair<int,int> pii;//赛时暴力解
void solve1()
{int n,k;cin>>n>>k;string s;cin>>s;int m=s.length();if(k>m/2){cout<<"NO"<<endl;return ;}int cnt=0,cntA=0,cntO=0,cntX1=0,cntX2=0;for(int i=0,j=m-1;i<=j;i++,j--){if(s[i]!=s[j]){if(s[i]=='1'){cntX1++;}else{cntX2++;}}else if(s[i]==s[j]){if(s[i]=='1'){cnt++;cntA++;            }else{cnt++;cntO++;}}}if(cnt==k){cout<<"YES"<<endl;return ;}if((k%2==0&&cnt%2==0)||(k%2==1&&cnt%2==1)){if(k<cnt){if(min(cntA,cntO)>=(cnt-k)/2){cout<<"YES"<<endl;return ;}else{cout<<"NO"<<endl;return ;}}else{if(max(cntX1,cntX2)>=(k-cnt)/2){cout<<"YES"<<endl;return ;}else{cout<<"NO"<<endl;return ;}}}else{cout<<"NO"<<endl;return ;}}//优化解
void solve2()
{int n,k;cin>>n>>k;string s;cin>>s;int m=s.length();//因为要求k对“00”或“11”，所以剩下的n/2-k对都是“01”//所以保证0和1的数量减去n/2-k是偶数即可//统计出现次数vector<int>cnts(2);for(int i=0;i<m;i++){cnts[s[i]-'0']++;}int zeros=cnts[0]-(n/2-k);int ones=cnts[1]-(n/2-k);if(zeros>=0&&zeros%2==0&&ones>=0&&ones%2==0){cout<<"YES"<<endl;}else{cout<<"NO"<<endl;}
}int main()
{ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--){solve2();    }return 0;
}

这个题真的太草了，赛时完全想复杂了，虽然调了半天调出来了，但浪费了不少时间……

赛时想到的麻烦思路是，从要求的k和实际的cnt入手，分析两者奇偶性对结果的影响。因为交换后必然是两对两对地增加，两对两对地减少，所以只有当k和cnt奇偶性一致时才有可能凑出来。（很妙，但没用）

之后就去讨论k和cnt的大小关系。当k小于cnt时，需要通过交换减少个数，那就只能让“00”和“11”交换，一次消去两对，所以就要分别统计“00”和“11”的个数。只有当这俩个数的最小值比k和cnt差值的两倍大时才有可能凑出来。

当k大于cnt时，就需要通过交换增加个数，此时就需要让“01”和“10”的组合交换。注意，在上一个情况里，必须是在同一侧的两数交换，才能减少个数，所以是两者最小值。而这里，除了上述情况，还可以让两对“01”中其中一组的“0”和另一组的“1”交换，仍然可以消去一对。所以在这里就是取两者的最大值，要注意的是，这里需要在一开始进行剪枝，先把k大于m/2的情况剪了才行。

优化解就简单很多了，因为匹配的情况就是“00”和“11”两种，不匹配就是“01”和“10”两种，所以当要求有k对匹配时，不匹配的数量就是n/2-k。所以考虑先统计一遍0和1的词频，之后减去不匹配的数量就是需要的数量。当两者都大于0且是偶数时，就可以被交换出来。

怎么说呢，感觉这个优化解的思路太需要观察了……我赛时还想着怎么个调换法，这个直接从一般规律入手了，差距好大……

C. Need More Arrays

#include <bits/stdc++.h>
using namespace std;typedef long long ll;
typedef pair<int,int> pii;void solve()
{int n;cin>>n;vector<int>a(n);for(int i=0;i<n;i++){cin>>a[i];}vector<int>b;b.push_back(a[0]);for(int i=1,j=0;i<n;i++){if(a[j]+1<a[i]){b.push_back(a[i]);j=i;}}cout<<b.size()<<endl;;
}int main()
{ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--){solve();    }return 0;
}

这个题纯纯贪心，本来以为没戏了，没想到最后二十分钟真给我贪出来了，还是一发过。（骄傲）

根据原题意，其实就是要让这个数组不连续。那么贪心的思路就是，从前往后遍历这个数组，一旦发现有连续的部分就直接删除靠后的元素，因为这样只会导致后续可能对答案有增益，不会导致答案减少。（说实话，我都不知道我咋能想到这个贪心）

所以就是遍历数组，设置指针j记录上一个没删除的下标。然后如果连续就删除，否则就加到新数组里，然后j来到当前位置，最后返回新数组的大小即可。

D. Come a Little Closer

#include <bits/stdc++.h>
using namespace std;typedef long long ll;
typedef pair<int,int> pii;void solve()
{int n;cin>>n;vector<vector<ll>>mon(n,vector<ll>(2));for(int i=0;i<n;i++){cin>>mon[i][0]>>mon[i][1];}//特判if(n==1){cout<<1<<endl;return ;}ll ans=1e18+100;multiset<ll>xs,ys;for(int i=0;i<n;i++){xs.insert(mon[i][0]);ys.insert(mon[i][1]);}//计算所有的面积ans=min(ans,(*xs.rbegin()-*xs.begin()+1)*(*ys.rbegin()-*ys.begin()+1));//枚举每个移动的怪兽for(int i=0;i<n;i++){xs.erase(xs.find(mon[i][0]));ys.erase(ys.find(mon[i][1]));//统计可以缩小的答案ll tmp=(*xs.rbegin()-*xs.begin()+1)*(*ys.rbegin()-*ys.begin()+1);//剩余构成的长方形是满的if(tmp==n-1){//加上长宽的最小值 -> 移动到周围tmp+=min(*xs.rbegin()-*xs.begin()+1,*ys.rbegin()-*ys.begin()+1);}ans=min(ans,tmp);//放回去xs.insert(mon[i][0]);ys.insert(mon[i][1]);}cout<<ans<<endl;
}int main()
{ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--){solve();    }return 0;
}

这个题因为不知道multiset所以还卡了一会……

multiset就是允许存在重复元素的set，因为最多可以移动怪兽一次，所以肯定考虑枚举每个怪兽，看看移动之后能否使答案减小。所以有了multiset就可以把所有点放到set里，然后每次根据set中的最小值和最大值把要删除的整个格子抓出来。之后枚举每个怪兽，每次先在set中删除，接着统计答案，最后插回去即可。注意，若格子满了，即面积等于怪兽的数量，那就让当前怪兽去到长宽更小的那边，需要增加的就是长宽的最小值。

E. Kirei Attacks the Estate

#include <bits/stdc++.h>
using namespace std;typedef long long ll;
typedef pair<int,int> pii;const int MAXN=200005;//链式前向星建树
// int head[MAXN];
// int nxt[MAXN<<1];
// int to[MAXN<<1];
// int cnt=1;// void build(int n)
// {
//     fill(head,head+MAXN,0);
//     fill(nxt,nxt+(MAXN<<1),0);
//     fill(to,to+(MAXN<<1),0);
// }// void addEdge(int u,int v)
// {
//     nxt[cnt]=head[u];
//     to[cnt]=v;
//     head[u]=cnt++;
// }//dfs
void dfs(int u,int father,vector<vector<ll>>&ans,vector<ll>&weight,vector<vector<int>>&graph)
{ans[u][0]=max(weight[u],weight[u]-ans[father][1]);ans[u][1]=min(weight[u],weight[u]-ans[father][0]);// for(int ei=head[u],v;ei>0;ei=nxt[ei])// {//     v=to[ei];//     if(v!=father)//     {//         dfs(v,u,n,weight);//     }// }for(int cur:graph[u]){if(cur!=father){dfs(cur,u,ans,weight,graph);}}
}void solve()
{int n;cin>>n;vector<ll>weight(n+1);for(int i=1;i<=n;i++){cin>>weight[i];}//build(n);vector<vector<int>>graph(n+1);for(int i=1,u,v;i<=n-1;i++){cin>>u>>v;// addEdge(u,v);// addEdge(v,u);graph[u].push_back(v);graph[v].push_back(u);}//0:max  1:minvector<vector<ll>>ans(n+1,vector<ll>(2,0));dfs(1,0,ans,weight,graph);for(int i=1;i<=n;i++){cout<<ans[i][0]<<" ";}cout<<endl;
}int main()
{ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--){solve();    }return 0;
}

真的抽象，没想到链式前向星性能会比邻接表差好多，同样思路链式前向星直接TLE了……不过很好的一点是思路自己在补题的时候想到了！！

这个题其实就是个树型dp，观察给出的式子就能发现，当前节点的威胁值其实就是两种情况，自己单独和自己节点减去父节点的威胁值。而又因为要求当前节点的威胁值最大，所以就要求减去的父节点的威胁值最小。那么就考虑用dfs往下扎，同时收集当前节点威胁值的最大值和最小值即可。

F. Small Operations

#include <bits/stdc++.h>
using namespace std;typedef long long ll;
typedef pair<int,int> pii;//最大公约数
int gcd(int a,int b)
{if(b>a){int tmp=b;b=a;a=tmp;}return b==0?a:gcd(b,a%b);
}//质因子
vector<int>factors(int n)
{vector<int>ans;for(int i=2;i*i<=n;i++){while(n%i==0){if(ans.empty()||ans.back()!=i){ans.push_back(i);}n/=i;}}if(n!=1){ans.push_back(n);}return ans;
}//约数
vector<int>divisors(int n)
{vector<int>ans;for(int i=n;i>=1;i--){if(n%i==0){ans.push_back(n/i);}}return ans;
}//把1乘到n的最小次数 -> 贪心是不对的，正解是按乘积bfs展开路径
int check(int n,int k)
{if(n==1){return 0;}//往上乘的过程中，每一步的结果必然是n的约数vector<int>div=divisors(n);set<int>cur;//当前层结果cur.insert(1);for(int i=1;;i++){set<int>next;//下一层for(int x:cur){for(int y:div){if(y>k){break;}next.insert(x*y);}}if(next.find(n)!=next.end())//乘出n{return i;}cur=next;}return 0;
}void solve()
{int x,y,k;cin>>x>>y>>k;//先让两者同除一个最大公约数//之后先让x变为1，然后再乘到yint t=gcd(x,y);x/=t;y/=t;//若两者任意一个存在一个质因子大于k//那么不可能把x除到1或把1乘到y，所以必不可能完成for(int t:factors(y)){if(t>k){cout<<-1<<endl;return ;}}for(int t:factors(x)){if(t>k){cout<<-1<<endl;return ;}}int ans=check(x,k)+check(y,k);cout<<ans<<endl;
}int main()
{ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);int t=1;cin>>t;while(t--){solve();    }return 0;
}

数学题拼尽全力无法战胜了……

首先可以发现，上来可以求x和y的最大公约数，然后让两者同除这个最大公约数，然后考虑除完的结果，这样不会对答案造成影响。之后的思路是先把x除到1，再从1乘到y。所以，对于无法完成的情况，那就是要分别取两者的质因数，若存在一个质因子大于k，那么就必然不可能完成。判断完之后，因为从一个数除到1和从1乘到这个数是对称的，所以就是用一个check方法求x和y从1乘到该数的最小步数，加起来即可。

对于check方法，这里按k从大到小乘的贪心思路是不对的，正解是bfs展开路径。观察可以发现，在从1乘到该数的过程中，每一步的结果都必然是该数的因数，那么就可以先把该数的所有因数抓出来，接着用两个set分别存当前步数里能乘出来的结果和下一步能乘出来的结果。然后每次遍历当前层，若该数的因数没有大于k，就让该数的因数乘以当前层里的结果，然后存到下一层里。最后去找当前层里是否存在该数，有的话直接返回当前的步数，否则就让cur来到下一层。

G. Build an Array

G题饭老师的讲解没听懂……

总结

努力总会有回报！！加油！！再接再厉！！

END