Codeforces Round #670 (Div. 2)A-D题解
//写于rating值1987/2184
//补档
比赛链接:https://codeforces.ml/contest/1406
A题
贪心，施行
题意为给你一堆自然数，让你把他们分成两个部分。两个部分当中的各自没出现的最小的自然数相加，要求这个结果最大，询问这个最大结果是多少。
直接贪心依次取两个部分的数就可以了。
从0开始连续+1最多可以取到x，那么这个部分没出现的最小自然数就是x+1了，也是我们使用当前剩下的数字能得到的最大值。
#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
int num[107];//记录每个数字出现了几次
int32_t main()
{
IOS;
int t;
cin>>t;
while(t--)
{
memset(num,0,sizeof(num));
int n;
cin>>n;
for(int i=0;i<n;i++)
{
int x;
cin>>x;
num[x]++;
}
int ans=0;
for(int j=0;j<2;j++)//执行两次，分为两个部分
{
for(int i=0;1;i++)
{
if(i==101) {
ans+=101;break;}//循环到101就可以结束了，输入数据最大也只有100
if(num[i]==0) {
ans+=i;break;}//当前数字不存在，则就为当前部分的最小未出现自然数，累加到答案并结束循环
else num[i]--;//代表使用一个数字到当前部分里
}
}
cout<<ans<<endl;
}
}
B题
贪心，分类讨论，简单整体思维
题意为给定一个数列，你可以从中任意挑选5个数字乘起来（题意理解成这样就很简单了），希望你求出最大的结果。
这里任意挑选5个数字么，根据最后结果是正还是负（0可以包含在任意一种情况里），我们对最后结果的绝对值倾向是不同的。
如果结果为正，那么我们希望绝对值尽可能大。
如果结果为负，那么我们希望绝对值尽可能小。
而挑选5个数字，我们可以按照其中负数出现的次数，来决定最后结果的正负性。
由此我们可以把负数出现0，2，4次，和出现1，3，5次分为两种情况分别讨论，取各自情况的最大值即可。
#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
vector<ll>zhengshu,fushu;
int32_t main()
{
IOS;
int t;
cin>>t;
while(t--)
{
int n;
cin>>n;
for(int i=0;i<n;i++)
{
ll x;
cin>>x;
if(x<0) fushu.push_back(x);
else zhengshu.push_back(x);
}
sort(fushu.begin(),fushu.end());
sort(zhengshu.begin(),zhengshu.end());
ll ans=-llINF;
for(ll i=1;i<=5;i+=2)//正数或者0的出现次数为奇数，负数的出现次数为偶数
{
ll j=5-i;//i为正数出现次数，j为负数出现次数
if(zhengshu.size()>=i&&fushu.size()>=j)//此时结果为正数，我们要使得绝对值尽可能大，这样值更大
{
ll temp=1;
for(ll k=1;k<=i;k++) temp*=zhengshu[zhengshu.size()-k];//正数绝对值大的在末尾
for(ll k=0;k<j;k++) temp*=fushu[k];//负数绝对值大的在开头
ans=max(ans,temp);
}
}
for(ll i=0;i<5;i+=2)//正数或者0的出现次数为偶数，负数的出现次数为奇数
{
ll j=5-i;
if(zhengshu.size()>=i&&fushu.size()>=j)//此时结果为负数，我们要使得绝对值尽可能小，这样值更大
{
ll temp=1;
for(ll k=0;k<i;k++) temp*=zhengshu[k];//正数绝对值小的在开头
for(ll k=1;k<=j;k++) temp*=fushu[fushu.size()-k];//负数绝对值小的在末尾
ans=max(ans,temp);
}
}
zhengshu.clear();
fushu.clear();
cout<<ans<<endl;
}
}
C题
树，构造，图结论
题意为，给你一棵n个节点的树，现在从这棵树中取走一个节点，要使得剩下的图中，拥有最大节点数量的树的节点数要尽可能小。
现在不希望这个取走的节点有多种取法，你可以去除掉原树中的一条边，再重连一条边，够成一课新树，使得那个取走的节点取法变为唯一。
这里要先推出来，什么情况下会使得这个取走的节点有多种取法。
这里的结论是，如果有一条边的左右两侧节点数都恰好是n/2（此时n必然是偶数），那么我们分别取走这条边左右两侧的节点，剩下的部分最大节点数均为n/2。
推导这个结论可以用反证法，剩下的部分最大结点数大于n/2的反例就不说明了。
如果剩下的部分最大节点数小于n/2，那么代表取走那个点后，剩下的部分至少有三个，其中一个部分是当前的最大部分有x个结点，另外两个部分分别有y个和z个结点，y<=x,z<=x且x+y+z=n。
取走的这个点是三个部分的连接节点。
那么我们如果不取这个点的话，这三个部分的至少两个部分会连接起来构成一个更大的部分，
由于x+y>x,x+z>x,y+z>x
也就是说我们取其他的点都是会得到比x更大的部分，由此推翻。
寻找这样一条左右两侧节点数均为n/2的“中间边”我们可以通过dfs来得到，那么得到后我们要如何删边加边构造没有这种“中间边”的树呢。
我们注意到这个“中间边”的存在，其实也就是这个子树可以分成两个恰好拥有n/2节点的部分，且两个部分只有一条连边。
我们只需要让它们之间有多条连边即可。
我们用dfs找到这条“中间边”，这条边两侧的点中，u为更接近根节点的点，d为更远离根节点的点。那么我们可以从u的这一侧切出一个点出来（用树根这个点就可以了），把它和d接起来。
这样的话u这一侧就只有n/2-1个点了，再加上d这个点才凑满n/2个点，而d这个点和原本自己一侧至少有一个连边，切下来的原根节点与其又有一条连边，就不再有上述结论的情况了。
#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
const ll maxn=1e5+7;
struct Edge
{
ll to,next;
}edge[maxn*2];
ll head[maxn],ru[maxn],tot,n;//ru[i]数组代表i结点有几条边，用于寻找只有一条边的点作为树根起点
ll u,d;
void init()
{
for(ll i=1;i<=n;i++) head[i]=-1,ru[i]=0;
tot=0;
}
void add(ll u,ll v)
{
edge[tot].to=v;
edge[tot].next=head[u];
ru[v]++;
head[u]=tot++;
}
ll dfs(ll now,ll pre)//dfs返回值为now以及它的子树总共有几个结点，pre为之前的一个节点，用于dfs防止走回头路
{
ll ret=1;
for(ll i=head[now];i!=-1;i=edge[i].next)
{
ll to=edge[i].to;
if(to!=pre) ret+=dfs(to,now);
}
if(ret==n/2)//如果当前结点的个数恰好等于总结点数的一半，则记录这条“中间边”两侧的两个点位置，u是更接近根节点那一侧的点
{
u=pre;
d=now;
}
return ret;
}
int32_t main()
{
IOS;
int t;
cin>>t;
while(t--)
{
cin>>n;
init();
for(ll i=1;i<n;i++)
{
ll u,v;
cin>>u>>v;
add(u,v);add(v,u);
}
if(n&1)//如果总结点数是奇数个则无需进行操作，任意切掉一条边再重新把这条边构造还原即可
{
ll now=1;
ll to=edge[head[now]].to;
cout<<now<<' '<<to<<endl;
cout<<now<<' '<<to<<endl;
}
else//如果结点数是偶数个，那么去找是否有哪边边的两侧恰好结点数都是总数的一半，就会出现去除该条边两侧的两个点后，得到的剩余部分的最大结点数相等的情况
{
//此时最大结点数都是n/2，我们需要构造使得这种情况不再出现
ll start=-1;//start为树根节点，挑选只有一条边的叶子作为树根（如果选择树内部而不是叶子作为起点去dfs检测子树节点数量是否等于n/2是不正确的，因为还可能通过树根和其他子树的部分加起来构成n/2的一个子树，以另一个点为树根的情况下）
for(ll i=1;i<=n;i++) if(ru[i]==1) start=i;
u=d=0;//u为那条“中间边”两侧的点中离根节点较近的点，d为较远的
dfs(start,0);//dfs检测是否存在这样一条“中间边”，左右两侧的节点数都是n/2
ll to=edge[head[start]].to;//to为与根节点相连的唯一一个点的位置，用于后面构造操作
if(u==0)//如果不存在这样的“中间边”则无需操作，任意切掉一条边再重新把这条边构造还原即可
{
cout<<start<<' '<<to<<endl;
cout<<start<<' '<<to<<endl;
}
else//如果存在这样的“中间边”，从这条边的u那一侧切割下一个点，这里切割下树根节点，然后拼接到另一侧的d点上即可
{
cout<<start<<' '<<to<<endl;
cout<<start<<' '<<d<<endl;
}
}
}
}
D题
贪心，结论，差分
题意为给定一个长度为n的数列A，你需要构造一个长度为n的值不下降的数列B和一个长度为n的值不上升的数列C，满足B[i]+C[i]=A[i]。现在问你数列B和数列C中的最大数值的最小值是多少。
注意到我们只需要关注数列B和C中的最大值，数列B中的最大值是最后一个数字，数列C中的最大值是第一个数字。
我们可以假设固定了数列C中的第一个数字为x，那么数列B中的第一个数字就是A[1]-x。
之后我们依次向后看Ai的值，
如果A[i]<=A[i-1]，如果我们仍然按照i-1的位置构造B和C的话，加起来会大于A[i]，我们需要减小数字，我们可以直接减少数列C的数字即可，并且不会影响到B和C中的最大值是度搜好。
如果A[i]>A[i-1]，如果我们仍然按照i-1的位置构造B和C的话，加起来会小于A[i]，我们需要增大数字，我们不能增加数列C的数字值，只能增加数列B的，而这个增加值会影响B中最后一个数字的大小，也就是会影响到最后的最大值。
我们累加A[i]-A[i-1]中大于0的部分，值为temp，那么这样贪心构造后的数列B中的最大值就位A[1]-x+temp，而数列C中的最大值为x，我们希望他们中的最大值尽可能小。也就是两者相加平均分成两部分后较大的那部分了，而两者相加值为A[1]-x+temp+x=A[1]+temp。
因此我们实际上只需要关注第一个位置的数，和后面的数字的差分数组中大于0的部分即可。
我们可以通过差分数组O(1)进行修改操作并得到结果。
另外注意下A[1]+temp是负数的时候，除以2是向上取整的。
#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
vector<ll>num;
int32_t main()
{
IOS;
int n;
cin>>n;
num.resize(n+1);
for(ll i=1;i<=n;i++) cin>>num[i];
ll ans=num[1];
for(ll i=n;i>1;i--)//差分操作
{
num[i]-=num[i-1];
if(num[i]>0) ans+=num[i];
}
cout<<(max(ans/2,ans-ans/2))<<endl;//注意负数除以2是向上取整而不是向下，所以这里这么写是最稳妥的
ll q;
cin>>q;
for(ll i=0;i<q;i++)
{
ll l,r,x;
cin>>l>>r>>x;
if(l>1)
{
if(num[l]>0) ans-=num[l];
if(num[l]+x>0) ans+=num[l]+x;
}
if(l==1) ans+=x;//ans是num[1]加上后序差分数组大于0的部分，如果改变区间左侧就是1的话，直接要把x加到ans上
if(r<n)
{
if(num[r+1]>0) ans-=num[r+1];
if(num[r+1]-x>0) ans+=num[r+1]-x;
}
num[l]+=x;
if(r<n) num[r+1]-=x;
cout<<max(ans/2,ans-ans/2)<<endl;
}
}