A. Absolute Maximization
题目链接：Problem - A - Codeforces
样例输入：
4
3
1 0 1
4
5 5 5 5
5
1 2 3 4 5
7
20 85 100 41 76 49 36
样例输入：
1
0
7
125
题意：给定一个长度为n的数组a[]，我们可以对这个数组中的数进行操作，每次操作选择两个数i和j，然后我们可以交换a[i]和a[j]中的任意二进制位，对整个数组操作完后，问数组中最大的数减去最小的数的值最大是多少？
分析：直接贪心，我们将数组中的1尽可能集中到最大值上，将数组中的0尽可能集中到最小值上，最后直接作差即可。集中1的操作正好相当于或运算，集中0的操作相当于与运算，所以答案就是数组的或值减去与值。
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<map>
#include<queue>
#include<vector>
#include<cmath>
using namespace std;
const int N=1e5+10;
int a[N];
int main()
{
int T;
cin>>T;
while(T--)
{
int n;
scanf("%d",&n);
int ans1=0,ans2=1023;
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
ans1|=a[i];
ans2&=a[i];
}
printf("%d\n",ans1-ans2);
}
return 0;
}B. Incinerate
题目链接：Problem - B - Codeforces
样例输入：
3
6 7
18 5 13 9 10 1
2 7 2 1 2 6
3 4
5 5 5
4 4 4
3 2
2 1 3
1 1 1
样例输出：
YES
NO
YES
题意：一开始有n个怪兽，每个怪兽有一个血量和攻击力，现在有一个人来攻击这些怪兽，这个人的初始攻击力是k。每轮战斗后怪兽的血量都会降低人的现有攻击力，但是人的攻击力也会降低，降低值就是存活的怪兽中的最低攻击力。现在问人能不能杀死全部的怪兽。
分析：容易看出，只要怪兽还没死，那么人对每个怪兽造成的伤害就是相同的，所以为了方便统计每轮战斗后剩余存活的怪兽的最低攻击力，我们可以按照攻击力对怪兽进行从小到大排序，并用一个sum来记录当前人对每个怪兽造成的伤害，对于每个怪兽，如果该怪兽的血量小于等于人造成的伤害，那么说明怪兽已经被打死，继续下一个怪兽即可，否则人就要与这个怪兽进行战斗，只要这个怪兽还没死，人每轮战斗结束后减少的攻击力就是该怪兽的攻击力，这个过程直接模拟即可，因为人的攻击力不是特别大，所以模拟的轮次不会特别多，当人的战斗力减少至0时就直接退出即可。需要注意的一点是，我们在模拟人与怪兽战斗的过程中，如果最后一次战斗把该怪兽打死了，那么人所减少的战斗力就是下一个存活的怪兽的攻击力，而不是当前已经被打死的怪兽的攻击力。
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<map>
#include<queue>
#include<vector>
#include<cmath>
using namespace std;
const int N=1e5+10;
struct node{
int hp,at;
}p[N];
bool cmp(node a,node b)
{
return a.at<b.at;
}
int main()
{
int T;
cin>>T;
while(T--)
{
int n,k;
scanf("%d%d",&n,&k);
for(int i=1;i<=n;i++)
scanf("%d",&p[i].hp);
for(int i=1;i<=n;i++)
scanf("%d",&p[i].at);
sort(p+1,p+n+1,cmp);
long long sum=0;//记录当前造成的总伤害
bool flag=true;
for(int i=1;i<=n;i++)
{
if(sum>=p[i].hp) continue;
else
{
p[i].hp-=sum;
if(i!=1) k-=p[i].at;
}
while(p[i].hp>0&&k>0)
{
sum+=k;
p[i].hp-=k;
if(p[i].hp>0)
k-=p[i].at;
}
if(p[i].hp>0&&k<=0)
{
flag=false;
break;
}
}
if(flag) puts("YES");
else puts("NO");
}
return 0;
}C. Another Array Problem
题目链接：Problem - C - Codeforces
样例输入：
3
3
1 1 1
2
9 1
3
4 9 5
样例输出：
3
16
18
题意：给定一个长度为n的数组a[]，我们可以对这个数组进行操作，每次操作选择两个下标i，j,满足1<=i<j<=n,操作后就会使得所有的满足i<=k<=j的k都有a[k]=|a[j]-a[i]|,问操作后的数组的元素和最大是多少。
分析：我们首先可以发现a数组中的数都是非负数，那么一定有|a[j]-a[i]|<=max(a[j],a[i])，也就是说即使是操作后的数也不可能存在大于max(a[1~n])的数。
对于n>=4的情况，我们可以把所有的数均变为原数组中的最大值，那么显然这种情况是最优的。
以n=4举个例子，假如四个数是3 9 2 1，我们先对后两个数连续进行两次操作变为3 9 0 0，接下来我们选择第2个数和第4个数进行一次操作得到3 9 9 9，然后对前两个数进行两次操作得到0 0 9 9，最后选择第一个数和第四个数进行一次操作得到9 9 9 9.可以发现这个策略是万能的，所以当n>=4时我们一定有方法把数组均变为最大值。
当n=2时无非就是不操作和操作1次，那么我们取一个最大值即可
n=3时暴力讨论一下就行。
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<map>
#include<queue>
#include<vector>
#include<cmath>
using namespace std;
const int N=2e5+10;
int a[N];
int main()
{
int T;
cin>>T;
while(T--)
{
int n;
scanf("%d",&n);
long long ans=0;
for(int i=1;i<=n;i++)
scanf("%d",&a[i]),ans+=a[i];
if(n<=3)
{
if(n==1) ans=a[1];
else if(n==2) ans=max(ans,2ll*abs(a[1]-a[2]));
else
{
ans=max(ans,3ll*max(a[1],a[3]));
ans=max(ans,3ll*abs(a[3]-a[1]));
ans=max(ans,3ll*abs(a[2]-a[1]));
ans=max(ans,3ll*abs(a[3]-a[2]));
}
}
else
{
for(int i=1;i<=n;i++)
ans=max(ans,1ll*a[i]*n);
}
printf("%lld\n",ans);
}
return 0;
}D. Valid Bitonic Permutations
题目链接：Problem - D - Codeforces
样例输入：
7
3 1 3 2 3
3 2 3 3 2
4 3 4 3 1
5 2 5 2 4
5 3 4 5 4
9 3 7 8 6
20 6 15 8 17
样例输出：
0
1
1
1
3
0
4788
题意：给定五个数n，i，j，x，y,问我们满足p[i]=x以及p[j]=y的长度为n的单峰排列个数。
单峰排列是指存在一个k满足1<k<n，且p[1~k]单调递增，p[k~n]单调递减。
分析：如果要是没有p[i]=x以及p[j]=y这两个限制，那么我们可以直接从n~1开始填数，也就是区间DP，设f[i][j]表示从第i个位置填到第j个位置的合法方案数，由于我们是从大到小开始填数，往两端开始添数，所以f[i][j]代表已经填了j-i+1个数，最后一个要填的数就是n-(j-i),所以我们只需要判断一个这个数能不能填在第i个位置或者第j个位置即可，所以动态规划的方程就很容易得到了，就是对于每一个当前要填的数就判断一下这个数能不能填在两端即可。加上这两个限制其实影响也不大，无非就是如果位置等于i了我们就判断一下要填的数是不是x，等于j了我们就判断一下要填的数是不是y就行了，其余的也是正常的区间DP。
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<map>
#include<queue>
#include<vector>
#include<cmath>
using namespace std;
const int N=103,mod=1e9+7;
int f[N][N];//f[i][j]表示从第i个位置填到第j个位置的合法方案数
int n,l,r,x,y;
bool check(int id,int val)
{
if(id==l) return val==x;
else if(id==r) return val==y;
return true;
}
int main()
{
int T;
cin>>T;
while(T--)
{
scanf("%d%d%d%d%d",&n,&l,&r,&x,&y);
memset(f,0,sizeof f);
for(int i=2;i<n;i++)//先填入峰值,注意峰值不能出现在1和n这两个位置
if(check(i,n)) f[i][i]=1;
for(int len=2;len<=n;len++)
for(int l=1;l+len-1<=n;l++)
{
int r=l+len-1;
//区间长度为len，那么该区间内最后一个要填入的数就是n-len+1
if(check(l,n-len+1)) f[l][r]=(f[l][r]+f[l+1][r])%mod;//尝试填到第l个位置
if(check(r,n-len+1)) f[l][r]=(f[l][r]+f[l][r-1])%mod;//尝试填到第r个位置
}
printf("%d\n",f[1][n]);
}
return 0;
}E. Node Pairs
题目链接：Problem - E - Codeforces
样例输入：
4样例输出：
5 6题意：给出一个p，让我们输出有p对点可以相互连通的有向图中的点的最小数目，在此基础上输出最多有多少单向连通的点对。
分析：为了使得点数最小，我们尽量的是构造完全图，一个点数为n的完全图中的可相互连通的点对数目是n*(n-1)/2，如果要是p不是一个完全图的点对数，我们就把他拆成多个完全图，每个完全图都尽可能点数多一些，最后点对数目凑成p即可，那么我们就可以发现这就是一个完全背包问题，直接背包求解即可。现在我们已经得到若干个完全图了，要问在此基础上最多有多少单项连通的点对，那么显然让整张有向图上除了双向连通的点对之外其余的所有的点对都单向连通时最优，而且这是显然可以做到的，随便画一个图就可以得到这个结论。不妨假设第一问的答案是m，那么第二问的答案就是m*(m-1)/2-p.因为m个点形成了m*(m-1)/2个点对，其中p个点对是双向的，其余的就都是单向的。
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<map>
#include<queue>
#include<vector>
#include<cmath>
using namespace std;
const int N=1e3+10;
long long v[N],f[300003];
int main()
{
int n;
cin>>n;
for(int i=1;i<N;i++)
v[i]=i*(i-1)/2;
memset(f,0x3f,sizeof f);
f[0]=0;
for(int i=1;v[i]<=n;i++)
for(int j=v[i];j<=n;j++)
f[j]=min(f[j],f[j-v[i]]+i);
printf("%lld %lld",f[n],f[n]*(f[n]-1)/2-n);
return 0;
}
