NO.1
题目描述：
给定一个长度为N的序列a，对于每一个数都可选或不选，把选出的数有序组成一个新的序列b，使b序列的“和谐数”最大。
一个序列的和谐数如下定义：对于位置i，如果第奇数次选的则加上bi，偶数次选的则减去bi
注意：新的序列b必须是从左到右依次在a序列选择的，即不能打乱顺序。
思路：DP
设f[i,0/1]表示第i个位置选(为0)或不选(为1)的“和谐数”最大
状态转移方程为：
f[i,0]=max(f[i-1,0],f[i-1,1]+a[i])
f[i,1]=max(f[i-1,1],f[i-1,0]-a[i])
用了DP，妈妈再也不用担心我不会AC了
代码：
uses math;
var n,i,x:longint;
f:array[0..10000001,0..1]of int64;
begin
assign(input,'a.in');
assign(output,'a.out');
reset(input);
rewrite(output);
readln(n);
for i:=1 to n do
begin
read(x);
f[i,1]:=max(f[i-1,1],f[i-1,0]-x);
f[i,0]:=max(f[i-1,0],f[i-1,1]+x);
end;
write(max(f[n,1],f[n,0]));
close(input);
close(output);
end.
NO.2
题目描述：
ProKing来到了家里，忽然发现桌台上有n1个玩偶，每个玩偶上有一个对应的值，而在桌台下也有n2个玩偶，每个玩偶上也有一个对应的值，现在，proking想知道台上的玩偶的默契值除以台下玩偶的默契值得到的既约分数（既约分数就是分子分母最大公约数为1的分数）
默契值定义为所有玩偶的权值的乘积.
20%思路：暴力
直接将两个序列乘起来，再用辗转相除法求最大公因数
60%思路：高精度
可以使用高精度，把两个序列两两去除公因数，时间复杂度O(n^2)
100%思路：高精度+筛素数+压位
先用zs[i]来存i的最小质因数
然后我们对每个序列开一个数组s[i,j]为第j序列拥有i质因数的个数，那么循环枚举a[i,j]的最小质因数(zs[a[i,j])，求出除完最小质数后的数(a[i,j]-a[i,j] div zs[a[i,j]])，再求除后的数的最小质因数……
到这里，我们求出了每个序列分解质因数后的每个质因数所拥有的质数，那么就去重！！！
去重分三种情况：
①s[i,1]>s[i,2](也就是第一个序列拥有i的数量比第二个序列多）,那么s[i,1]-=s[i,2] s[i,2]=0
②s[i,2]>s[i,1](第一个序列拥有i的数量比第二个序列少），那么s[i,2]-=s[i,1] s[i,1]=0
③s[i,1]=s[i,2](第一个序列拥有i的数量等于第二个序列拥有i的数量），那么s[i,1]=s[i,2]=0
这样做完，两个序列就必须是互质的
然后,就用高精度乘法
因为只用高精度乘法，是会超时的，所以就要用压位
所谓压位，就是将原本存一位的a[i]，改成存多位
那么压位很简单实现
还有一个细节，就是在压位输出时，一般会将首位的0省略不输，那么就要加一个处理，将0位补齐（Tips:第一位不用补0）
代码：
const max=2300;
mo=100000000;
var n:array[1..2]of int64;
a,s,l:array[0..100101,1..2]of int64;
x,z,y:int64;
i,j,k:longint;
zs:array[0..12624]of int64;
procedure zxs;
var i,x:longint;
begin
for i:=2 to 10000 do
begin
x:=0;
for j:=2 to trunc(sqrt(i)) do
if (i mod j=0) then
begin
zs[i]:=j; x:=j;
break;
end;
if x=0 then zs[i]:=i;
end;
end;
begin
assign(input,'count.in');
assign(output,'count.out');
reset(input);
rewrite(output);
read(n[1]);
for i:=1 to n[1] do read(a[i,1]);
readln;
read(n[2]);
for i:=1 to n[2] do read(a[i,2]);
zxs;
for i:=1 to 2 do
for j:=1 to n[i] do
begin
x:=a[j,i];
while x>1 do
begin
inc(s[zs[x],i]);
x:=x div zs[x];
end;
end;
for i:=2 to 10000 do
if (s[i,1]>0)and(s[i,2]>0) then
if (s[i,1]>s[i,2]) then begin s[i,1]:=s[i,1]-s[i,2]; s[i,2]:=0; end
else begin s[i,2]:=s[i,2]-s[i,1]; s[i,1]:=0; end;
l[max,1]:=1; l[max,2]:=1;
for i:=1 to 2 do
for j:=2 to 10000 do
begin
z:=s[j,i];
while z>0 do
begin
dec(z);
for k:=2 to max do l[k,i]:=l[k,i]*j;
for k:=max downto 2 do
if l[k,i]>9 then
begin
l[k-1,i]:=l[k-1,i]+l[k,i] div mo;
l[k,i]:=l[k,i] mod mo;
end;
end;
end;
x:=0;
for i:=1 to 2 do
begin
for j:=0 to max do
if l[j,i]>0 then
begin
x:=j;
break;
end;
write(l[x,i]);
for j:=x+1 to max do
begin
y:=l[j,i]; z:=0;
if y=0 then y:=1;
while y<mo do
begin
y:=y*10;
z:=z+1;
end;
for k:=2 to z do write('0');
write(l[j,i]);
end;
write(' ');
end;
close(input);
close(output);
end.NO.3
题目描述：
给定一个长度为n的序列a，试求出对于序列a的每一个前缀的终极数x，使得
最小，试求出终极数t（如若有多个终极数t，只需输出最小的那个）
思路：堆维护+快排
这题的主要思路就是就中位数
堆有两个堆一个是大根堆，一个是小根堆，其实小根堆的堆顶就是中位数
这个问题就转移为维护一个堆
维护一个堆有三种情况：
①将大根堆从大到小排序
②将小根堆从小到大排序
③如果，大根堆顶大于小根堆顶，就将大根堆顶和小根堆顶交换，交换后的大根堆和小根堆都要进行重新排序
那么每一次的小根堆顶就是x终极数
最后再快排终极数，求出中位数即可AC
代码：
#include<cstdio>
#include<iostream>
#include<cstdlib>
using namespace std;
int x1,x2,a[1000001]={0},big[1000001]={0},small[1000001],x[1000001],i,t,n;
void temp1(int x)
{
while ((x>1)&&(small[x]<small[x/2]))
{
t=small[x];small[x]=small[x/2];small[x/2]=t;
x=x/2;
}
}
void temp2(int x)
{
while ((x>1)&&(big[x]>big[x/2]))
{
t=big[x];big[x]=big[x/2];big[x/2]=t;
x=x/2;
}
}
void doit1(int x)
{
int y;
while (((x*2<=x1)&&(small[x*2]<small[x]))||(((x*2+1)<=x1)&&(small[x*2+1]<small[x])))
{
y=x*2;
if ((x*2+1<=x1)&&small[x*2+1]<small[x*2]) y=x*2+1;
t=small[y];small[y]=small[x];small[x]=t;
x=y;
}
}
void doit2(int x)
{
int y;
while (((x*2<=x2)&&(big[x*2]>big[x]))||(((x*2+1)<=x2)&&(big[x*2+1]>big[x])))
{
y=x*2;
if (x*2+1<=x2&&big[x*2+1]>big[x*2]) y=x*2+1;
t=big[y];big[y]=big[x];big[x]=t;
x=y;
}
}
void qsort(int l,int r)
{
int i=l,j=r,mid=x[(l+r)/2];
if (l>=r) return;
do
{
while(x[i]<mid) i++;
while(x[j]>mid) j--;
if (i<=j)
{
t=x[i];x[i]=x[j];x[j]=t;
i++;j--;
}
}
while (i<=j);
qsort(l,j);
qsort(i,r);
}
int main()
{
freopen("c.in","r",stdin);
freopen("c.out","w",stdout);
scanf("%d",&n);
x1=0;
x2=0;
for (int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
if (i%2==1)
{
x1++;
small[x1]=a[i];
temp1(x1);
if (small[1]<big[1])
{
t=small[1];small[1]=big[1];big[1]=t;
doit1(1);
doit2(1);
}
}
else
{
x2++;
big[x2]=a[i];
temp2(x2);
if (small[1]<big[1])
{
t=small[1];small[1]=big[1];big[1]=t;
doit1(1);
doit2(1);
}
}
x[i]=small[1];
}
qsort(1,n);
printf("%d",x[n/2]);
fclose(stdin);
fclose(stdout);
return 0;
}NO.4
题目描述：给定一个0-1串，请找到一个尽可能长的子串，其中包含的0与1的个数相等。
思路：前缀和+贪心
如果设遇’0’+1，遇’1’-1
那么如果在前后找到有相等的数值时，这两个中间的序列必定是符合的!（长度就是x[i]-x[j])
那么为了减少时间复杂度，就可以用贪心思想，记录出现这个数的最前和最后
循环一遍求出最长的长度
代码：
var s:ansistring;
i,ans,j,min,max,x:longint;
min1,max1:array[-1000001..1000001]of longint;
begin
assign(input,'string.in');
reset(input);
assign(output,'string.out');
rewrite(output);
fillchar(min,sizeof(min1),127);
min1[0]:=0;
readln(s);
min:=maxlongint;
x:=0;
max:=0;
for i:=1 to length(s) do
if s[i]='1' then
begin
inc(x);
if x>max then max:=x;
if x<min then min:=x;
if i<min1[x] then min1[x]:=i;
if i>max1[x] then max1[x]:=i;
end
else
begin
dec(x);
if x>max then max:=x;
if x<min then min:=x;
if i<min1[x] then min1[x]:=i;
if i>max1[x] then max1[x]:=i;
end;
for i:=min to max do
if ans<max1[i]-min1[i] then ans:=max1[i]-min1[i];
write(ans);
close(input);
close(output);
end.