题目就不贴了，自己看吧。
这套题每道题如果会做的话写代码的过程真是轻松加愉快……湖南人出的题似乎都是这样……真有水平……
hnoi2012 day1:
bzoj2727 双十字 cross
要求我们统计双十字的个数
r*c<=10^6
所以我们可以扫一遍整个矩阵- -
因为竖线只有一条，所以以其为主线来考虑
首先我们可以线性处理出来每个点最多向左向右延伸多少
考虑一个点作为下端的情况有多少种，即是他以上有多少个“土”
那我们考虑以一个点为双十字下面那根横线，能形成多少个“土”
设这个为点最多向两边延伸长度为len，c[i]为它以上最多向两边延伸长度i的图形的个数
就是说这样的
(
*
***
*
*
***
)
那么我们这一行长度为2~len
形成“土”的个数显然为(len-1)*c[1]+((len-1)+(len-2))*c[2]..+((len-1)+..+1)*c[len-1]+((len-1)+..+1)*(c[len]+..+c[maxlen]) (长度大于等于他的等价于比他短1的)
这个怎么算呢……
显然等价于len*(1*c[1]+2*c[2]+..(len-1)*c[len-1])-(1*c[1]+(1+2)*c[2]+(1+2+3)*c[3]+..+(1+..+(len-1))*c[len-1])+(1+..+(len-1))*(c[len]+..c[maxlen])
…………
开三个树状数组好了
虽然推导有点麻烦，但是写还是很好写的，因为只用写个树状数组
bzoj2728 与非 nand
= =比较烦的一道题
首先玩下nand
发现这个东西好神啊，可以模拟出来not、and、or、xor，有了这些常用运算，
然后我们把n个数写成二进制数
比如
(7)2=111
(5)2=101
(3)2=011
然后我们竖着看……如果有两列完全相同，那么我们是没法让造出来的数这两位不同的
为什么呢……显而易见吧……位运算跟别的位没有关系两位等价就不能不相同
实际上没有两位必须等价的话，我们可以nand出任意数
也很好证明
既然有or运算，那么我们只要做出来各种只有一位为1，其他都为0的即可造出所有数
那么我们让某位为1，其他位为该如何操作……
可以对这n个数中这一位为0进行取反，然后把n个数and起来，如果其他位列跟着一列不同，其他位必然为0……因为这位全是1
知道了这个结论接下来就十分好做了，数位dp就行了
bzoj2729 排队 queue
组合数学题，比较简单吧
因为男生没有限制，所以先排男生，用n!种排列方式
这样就有n+1个缝隙可供我们放老师和女生
可以分情况讨论
两个老师在同一个缝隙中，这时候两个老师中间必须有一个女生，情况有A(n+1,1)*m*A(n+2,m-1)种
两个老师不在同一个缝隙中，情况有A(n+1,2)*A(n+3,m)种
所以答案为n!(A(n+1,1)*m*A(n+2,m-1)+A(n+1,2)*A(n+3,m))
显然答案会爆任意数据类型……需要高精度
bzoj2730 矿场搭建 mining
思考一下可以发现，只有割点崩塌才会出现问题，不然不影响图的连通性……
所以把割点全部删除以后，图会分成几个联通块
显然的，只跟一个割点相连的联通块内必须放一个出口，所以答案就是只跟一个割点相连的联通块大小之积
…………
实际上还有一种特殊情况……
图没割点……
放一个出口就够了？
显然不够，出口塌了怎么办……所以任意选两个点做为出口都行
bzoj2731 三角形覆盖问题 triangle
这题实际上有稳定算法……
不过感觉比较麻烦就写了个跑得比较快的爆搞……实际上应该比稳定算法还快，数据似乎是随机的
显然可以一行一行求面积
一行的面积=(上一行计算新出现的三角形的覆盖长度+这一行不算新出现的三角形的覆盖长度)/2
…………一行一行扫好了
怎么求被覆盖的长度呢……
数轴比较短啊……记录每一段被覆盖了多少次很容易求出来啊……
每一段覆盖了多少次怎么知道……？加三角形的时候爆搞啊……升高一行减掉当前的三角形小时的部分啊
这样据说可以过80分
但是说了这个比稳定算法还快，所以加个优化……
暴力判下新加入的三角形是不是在当前某个三角形内部，在的话不加
…………
ac了…………
bzoj2732 射箭 archery
因为抛物线过原点可得抛物线方程y=ax^2+bx
对于某个靶子x,y1,y2
可得y1<=ax^2+bx<=y2
把ab当成x、y就是两个半平面
可以求半平面交了
一条一条加入半平面如果半平面为空就结束
似乎又是随机数据……n^2做即可
还有个什么随机增量算法……期望O(n)……不懂
这个牵扯到大量实数运算，eps需要设到1e-16
bzoj2733 永无乡neverland
简化一下题意
有两种操作
1、求一个集合的第k大的数是哪个
2、将两个集合并起来
很容易想到平衡树……但是如何合并两颗平衡树
这用到了平衡树的启发式合并
启发式合并……听起来很高端……实际上就是合并两棵树的时候把小的树里的元素一个一个塞进大的树
…………
显然，复杂度最坏nlog^2n
bzoj2734 集合选数 set
首先考虑一下互相的约束
可以发现，只有2^i*3^j*x会互相制约
那么1~n的数就被划分成了几个互相独立的系统
方案数就是各系统方案数之积
问题转化成了求一个系统的方案数
观察一下x=1的情况
9 18 36
3 6 12
1 2 4
可以按2^i次方划分成一列一列
显然，一行不会超过11个元素(3^11>10^5)
一个数选择的话，相邻的四个数都不能选
显然可以状态压缩动态规划
复杂度不太好算……但是能很快通过
我最初的想法是把这个矩阵斜着看……发现状态很多，而且转移很慢
实际上这道题在matrix67的博客上有讲过
program bzoj2727;
const
maxn=1000000009;
var
z,ans,tot,now,x,y,r,c,n,i,j,k,o:longint;
s,tree:array [0..2,0..1200001] of longint;
dl,w:array [0..1200001] of longint;
map:array [0..1200001] of boolean;
function lowbit (x:longint):longint;inline;
begin
exit(x xor (x and (x-1)));
end;
procedure insert (p,o,x:longint);inline;
begin
if x=0 then exit;
p:=int64(p)*s[o,x] mod maxn;
while x<=c do
begin
tree[o][x]:=(tree[o][x]+p) mod maxn;
x:=x+lowbit(x);
end;
end;
function find (o,x:longint):longint;inline;
var
ans:longint;
begin
ans:=0;
while x>0 do
begin
ans:=(ans+tree[o][x]) mod maxn;
x:=x-lowbit(x);
end;
exit(ans);
end;
begin
read(r,c);
read(n);
for i:=1 to n do
begin
read(x,y);
map[x*c-c+y]:=true;
end;
for i:=1 to r do
begin
now:=1;
for j:=1 to c do
if map[i*c-c+j] then
now:=j+1
else
w[i*c-c+j]:=j-now;
now:=c;
for j:=c downto 1 do
if map[i*c-c+j] then
now:=j-1
else
if now-j<w[i*c-c+j] then
w[i*c-c+j]:=now-j;
end;
for i:=1 to c do
s[0,i]:=1;
for i:=1 to c do
s[1,i]:=i;
for i:=1 to c do
s[2,i]:=int64(i+1)*i div 2 mod maxn;
for j:=1 to c do
begin
for o:=2 to tot-1 do
for k:=0 to 2 do
insert(-o+1,k,w[dl[o]]);
tot:=0;
z:=0;
for i:=1 to r do
if map[i*c-c+j] then
begin
for o:=2 to tot-1 do
for k:=0 to 2 do
insert(-o+1,k,w[dl[o]]);
tot:=0;
z:=0;
end
else
begin
ans:=(ans+z) mod maxn;
inc(tot);
dl[tot]:=i*c-c+j;
if w[dl[tot]]>1 then
begin
k:=int64(w[dl[tot]])*find(1,w[dl[tot]]-1) mod maxn;
k:=(k-find(2,w[dl[tot]]-1)) mod maxn;
k:=(k+(find(0,c)-find(0,w[dl[tot]]-1))*(int64(w[dl[tot]]-1)*w[dl[tot]]) div 2 mod maxn) mod maxn;
z:=(z+k) mod maxn;
end;
if (tot>=3)and(w[dl[tot-1]]>0) then
for k:=0 to 2 do
insert(tot-2,k,w[dl[tot-1]]);
end;
end;
ans:=(ans+maxn) mod maxn;
writeln(ans);
end.program bzoj2728;
type
st=array [0..1001] of boolean;
const
one:int64=1;
var
n,i,j,k:longint;
l,r:int64;
a:array [0..1001] of int64;
eve:array [0..60] of st;
count,dl,fa:array [0..60] of longint;
procedure swap (var a,b:longint);inline;
begin
if a=b then exit;
a:=a xor b;
b:=a xor b;
a:=a xor b;
end;
function over (a,b:st):boolean;inline;
var
i:longint;
begin
for i:=1 to n do
if a[i]>b[i] then exit(true)
else
if a[i]<b[i] then exit(false);
exit(false);
end;
function calc (n:int64):int64;
var
i:longint;
ans:int64;
begin
if n<0 then exit(0);
ans:=0;
for i:=k-1 downto 0 do
begin
if n and (one shl i)<>0 then
if fa[i]=0 then
ans:=ans+(one shl (count[i]-1))
else
if n and (one shl fa[i])=0 then
ans:=ans+(one shl count[i]);
if fa[i]<>0 then
if (n and (one shl i)) shr i <> (n and (one shl fa[i])) shr fa[i] then
break;
end;
if (fa[i]=0)or((fa[i]<>0)and(n and (one shl i) shr i=n and (one shl fa[i]) shr fa[i])) then inc(ans);
exit(ans);
end;
begin
read(n,k,l,r);
if l>(one shl k)-1 then
begin
writeln(0);
halt;
end;
if r>=(one shl k) then
r:=(one shl k)-1;
for i:=1 to n do
read(a[i]);
for i:=0 to k - 1 do
for j:=1 to n do
eve[i][j]:=(a[j] and (one shl i))=0;
for i:=1 to k do
dl[i]:=i-1;
for i:=1 to k do
for j:=i+1 to k do
if (over(eve[dl[i]],eve[dl[j]]))or
((not over(eve[dl[i]],eve[dl[j]]))and(not over(eve[dl[j]],eve[dl[i]]))and(dl[i]<dl[j])) then
swap(dl[i],dl[j]);
for i:=2 to k do
if (not over(eve[dl[i]],eve[dl[i-1]]))and(not over(eve[dl[i-1]],eve[dl[i]])) then
fa[dl[i]]:=dl[i-1];
if fa[0]=0 then count[0]:=1
else count[0]:=0;
for i:=1 to k-1 do
begin
count[i]:=count[i-1];
if fa[i]=0 then inc(count[i]);
end;
writeln(calc(r)-calc(l-1));
end.program bzoj2729;
type
gj=array [0..100001] of longint;
var
n,m,i,j,k:longint;
ans,temp:gj;
procedure mul (var a:gj; b:longint);inline;
var
i:longint;
begin
for i:=a[0] downto 1 do
a[i]:=a[i]*b;
i:=1;
while (i<=a[0])or(a[i]>0) do
begin
a[i+1]:=a[i+1]+a[i] div 10;
a[i]:=a[i] mod 10;
inc(i);
end;
dec(i);
a[0]:=i;
end;
procedure plus (var a,b:gj);inline;
var
i,k:longint;
begin
if a[0]>b[0] then k:=a[0]
else k:=b[0];
for i:=1 to k do
begin
a[i]:=a[i]+b[i];
a[i+1]:=a[i+1]+a[i] div 10;
a[i]:=a[i] mod 10;
end;
if a[k+1]<>0 then inc(k);
a[0]:=k;
end;
begin
read(n,m);
if (n=0)and(m=0) then
begin
writeln(0);
exit;
end;
temp[0]:=1;
temp[1]:=1;
mul(temp,n+1);
mul(temp,2);
mul(temp,m);
for i:=n+2 downto n+2-m+2 do
mul(temp,i);
ans:=temp;
fillchar(temp,sizeof(temp),0);
temp[0]:=1;
temp[1]:=1;
mul(temp,n+1);
mul(temp,n);
for i:=n+3 downto n+3-m+1 do
mul(temp,i);
plus(ans,temp);
for i:=2 to n do
mul(ans,i);
for i:=ans[0] downto 1 do
write(ans[i]);
writeln;
end.program bzoj2730;
var
ans:int64;
all,w,tot,s,t,max,n,i,j,k:longint;
dd,count,belong,dfn,low,root,fa:array [0..201] of longint;
yes,divide:array [0..201] of boolean;
point,next:array [0..1001] of longint;
procedure connect (u,v:longint);inline;
begin
inc(tot);
point[tot]:=v;
next[tot]:=root[u];
root[u]:=tot;
end;
procedure dfs (now:longint);
var
i,k:longint;
begin
inc(tot);
dfn[now]:=tot;
low[now]:=tot;
i:=root[now];
k:=0;
while i<>0 do
begin
if point[i]<>fa[now] then
if dfn[point[i]]=0 then
begin
inc(k);
fa[point[i]]:=now;
dfs(point[i]);
if low[point[i]]<low[now] then low[now]:=low[point[i]];
if (now<>1)and(low[point[i]]>=dfn[now]) then divide[now]:=true;
if (now=1)and(k>1) then divide[now]:=true;
end
else
if dfn[point[i]]<low[now] then
low[now]:=dfn[point[i]];
i:=next[i];
end;
dec(tot);
end;
procedure search (now:longint);
var
i:longint;
begin
inc(count[tot]);
yes[now]:=true;
belong[now]:=tot;
i:=root[now];
while i<>0 do
begin
if (not yes[point[i]])and(not divide[point[i]]) then
search(point[i]);
i:=next[i];
end;
end;
begin
w:=0;
repeat
read(n);
if n=0 then break;
max:=0;
fillchar(root,sizeof(root),0);
for i:=1 to n do
begin
read(s,t);
if t>max then max:=t;
connect(s,t);
connect(t,s);
end;
tot:=0;
fillchar(divide,sizeof(divide),false);
fillchar(dfn,sizeof(dfn),0);
dfs(1);
fillchar(yes,sizeof(yes),false);
fillchar(count,sizeof(count),0);
tot:=0;
for i:=1 to max do
if (not yes[i])and(not divide[i]) then
begin
inc(tot);
search(i);
end;
inc(w);
write('Case ',w,': ');
if tot=1 then
begin
writeln(2,' ',max*(max-1) div 2);
continue;
end;
fillchar(dd,sizeof(dd),0);
for i:=1 to max do
if divide[i] then
begin
fillchar(yes,sizeof(yes),false);
k:=root[i];
while k<>0 do
begin
if (not divide[point[k]])and(not yes[belong[point[k]]]) then
begin
yes[belong[point[k]]]:=true;
inc(dd[belong[point[k]]]);
end;
k:=next[k];
end;
end;
all:=0;
ans:=1;
for i:=1 to tot do
if dd[i]=1 then
begin
inc(all);
ans:=ans*count[i];
end;
writeln(all,' ',ans);
until false;
end.program bzoj2731;
var
ans:double;
max,h,len,now,tot,n,i,j,k:longint;
dl,next,last,x,y,d:array [0..10001] of longint;
count:array [0..2000001] of longint;
ok:boolean;
procedure swap (var a,b:longint);inline;
begin
if a=b then exit;
a:=a xor b;
b:=a xor b;
a:=a xor b;
end;
procedure qsort (s,e:longint);
var
i,j,k:longint;
begin
if s>=e then exit;
i:=s;
j:=e;
k:=y[dl[(s+e) div 2]];
while i<=j do
begin
while y[dl[i]]<k do inc(i);
while y[dl[j]]>k do dec(j);
if i>j then break;
swap(dl[i],dl[j]);
inc(i);
dec(j);
end;
qsort(s,j);
qsort(i,e);
end;
begin
read(n);
for i:=1 to n do
begin
read(x[i],y[i],d[i]);
dl[i]:=i;
if y[i]+d[i]>max then max:=y[i]+d[i];
end;
qsort(1,n);
next[0]:=10001;
last[10001]:=0;
len:=0;
h:=y[dl[1]];
i:=1;
while h<=max do
begin
now:=len;
k:=next[0];
while k<>10001 do
begin
dec(count[x[k]+d[k]-(h-y[k])]);
if count[x[k]+d[k]-(h-y[k])]=0 then dec(now);
if h=y[k]+d[k] then
begin
next[last[k]]:=next[k];
last[next[k]]:=last[k];
end;
k:=next[k];
end;
ans:=ans+(now+len)/2;
len:=now;
while (i<=n)and(y[dl[i]]=h) do
begin
ok:=true;
k:=next[0];
while k<>10001 do
begin
if (x[k]<=x[dl[i]])and(x[dl[i]]+d[dl[i]]<=x[k]+d[k]-(h-y[k])) then
begin
ok:=false;
break;
end;
k:=next[k];
end;
if d[dl[i]]=0 then ok:=false;
if ok then
begin
last[next[0]]:=dl[i];
next[dl[i]]:=next[0];
last[dl[i]]:=0;
next[0]:=dl[i];
for j:=x[dl[i]] to x[dl[i]]+d[dl[i]]-1 do
begin
if count[j]=0 then inc(len);
inc(count[j]);
end;
end;
inc(i);
end;
inc(h);
end;
writeln(ans:0:1);
end.program bzoj2732;
const
eps:extended=1e-16;
inf:extended=9999999999;
type
point=
record
x,y:extended;
end;
var
ans,o,n,i,j,k:longint;
tot:array [0..1] of longint;
x,y1,y2:array [0..100001] of longint;
dl:array [0..1,0..100001] of point;
function get (x1,y1,x2,y2,k2,b2:extended):point;
var
k1,b1:extended;
ans:point;
begin
if abs(x1-x2)<=eps then
begin
ans.x:=x1;
ans.y:=x1*k2+b2;
exit(ans);
end;
k1:=(y1-y2)/(x1-x2);
b1:=y1-x1*k1;
ans.x:=(b1-b2)/(k2-k1);
ans.y:=ans.x*k1+b1;
exit(ans);
end;
procedure meet (k,b:extended;p:longint);
var
i,j:longint;
begin
o:=1-o;
tot[o]:=0;
for i:=1 to tot[1-o] do
begin
if dl[1-o,i].y*p>=(dl[1-o,i].x*k+b)*p then
begin
inc(tot[o]);
dl[o,tot[o]]:=dl[1-o,i];
end;
j:=i mod tot[1-o] + 1;
if (dl[1-o,i].y*p>(dl[1-o,i].x*k+b)*p)xor(dl[1-o,j].y*p>(dl[1-o,j].x*k+b)*p) then
begin
inc(tot[o]);
dl[o,tot[o]]:=get(dl[1-o,i].x,dl[1-o,i].y,dl[1-o,j].x,dl[1-o,j].y,k,b);
end;
end;
end;
begin
read(n);
for i:=1 to n do
read(x[i],y1[i],y2[i]);
tot[o]:=4;
dl[o,1].x:=-inf;
dl[o,1].y:=0;
dl[o,2].x:=-inf;
dl[o,2].y:=inf;
dl[o,3].x:=inf;
dl[o,3].y:=inf;
dl[o,4].x:=inf;
dl[o,4].y:=0;
for i:=1 to n do
begin
ans:=i;
meet(-x[i],y1[i]/x[i],1);
meet(-x[i],y2[i]/x[i],-1);
if tot[o]<=2 then
begin
ans:=i-1;
break;
end;
end;
writeln(ans);
end.program bzoj2733;
var
o,u,v,n,m,q,i,j,k:longint;
ch:char;
fa,tot,left,right,heap:array [0..200001] of longint;
a,father,sum:array [0..100001] of longint;
procedure swap (var a,b:longint);inline;
begin
if a=b then exit;
a:=a xor b;
b:=a xor b;
a:=a xor b;
end;
function root (now:longint):longint;
begin
if father[now]=0 then exit(now);
father[now]:=root(father[now]);
exit(father[now]);
end;
procedure rotate (son:longint);inline;
var
mot:longint;
begin
mot:=fa[son];
fa[son]:=fa[mot];
if fa[mot]<>0 then
if left[fa[mot]]=mot then
left[fa[mot]]:=son
else
right[fa[mot]]:=son;
fa[mot]:=son;
if left[mot]=son then
begin
tot[mot]:=tot[mot]-tot[son]-1;
left[mot]:=right[son];
if right[son]<>0 then fa[right[son]]:=mot;
right[son]:=mot;
end
else
begin
tot[son]:=tot[son]+tot[mot]+1;
right[mot]:=left[son];
if left[son]<>0 then fa[left[son]]:=mot;
left[son]:=mot;
end;
end;
procedure insert (now:longint);inline;
var
i:longint;
begin
heap[now]:=random(maxlongint);
i:=o;
repeat
if a[i]>a[now] then
if left[i]=0 then
begin
left[i]:=now;
break;
end
else
i:=left[i]
else
if right[i]=0 then
begin
right[i]:=now;
break;
end
else
i:=right[i]
until false;
tot[now]:=0;
fa[now]:=i;
left[now]:=0;
right[now]:=0;
i:=now;
repeat
if left[fa[i]]=i then inc(tot[fa[i]]);
i:=fa[i];
until fa[i]=0;
while heap[now]>heap[fa[now]] do rotate(now);
if fa[now]=0 then o:=now;
end;
procedure dfs (now:longint);
begin
if left[now]<>0 then
begin
fa[left[now]]:=0;
dfs(left[now]);
left[now]:=0;
end;
if right[now]<>0 then
begin
fa[right[now]]:=0;
dfs(right[now]);
right[now]:=0;
end;
insert(now);
end;
procedure link (u,v:longint);
var
i:longint;
begin
u:=root(u);
v:=root(v);
if u=v then exit;
if sum[u]>sum[v] then swap(u,v);
father[u]:=v;
sum[v]:=sum[u]+sum[v];
while fa[u]<>0 do u:=fa[u];
while fa[v]<>0 do v:=fa[v];
o:=v;
dfs(u);
end;
function find (now,k:longint):longint;inline;
begin
repeat
if tot[now]+1=k then exit(now)
else
if tot[now]+1<k then
begin
k:=k-tot[now]-1;
now:=right[now];
end
else
now:=left[now];
until false;
end;
begin
heap[0]:=maxlongint;
read(n,m);
for i:=1 to n do
read(a[i]);
for i:=1 to n do
sum[i]:=1;
for i:=1 to m do
begin
read(u,v);
link(u,v);
end;
readln(q);
for i:=1 to q do
begin
readln(ch,u,v);
if ch='Q' then
begin
u:=root(u);
if sum[u]<v then
begin
writeln(-1);
continue;
end;
while fa[u]<>0 do u:=fa[u];
writeln(find(u,v));
end
else
link(u,v);
end;
end.program bzoj2734;
const
modu=1000000001;
var
o,ans,n,i,j,k:longint;
thr,two:array [0..17] of longint;
tot:array [0..1] of longint;
dl,f:array [0..1,0..2048] of longint;
yes:array [0..100001] of boolean;
function calc (w:longint):longint;inline;
var
ans,i,j,k:longint;
procedure dfs (x,y,fob,stu,plus:longint);
var
i:longint;
begin
if w*two[x]*thr[y]>n then
begin
if f[o][stu]=0 then
begin
inc(tot[o]);
dl[o][tot[o]]:=stu;
end;
f[o][stu]:=(f[o][stu]+plus) mod modu;
exit;
end;
dfs(x,y+1,fob,stu,plus);
if fob and two[y] = 0 then
dfs(x,y+2,fob,stu or two[y],plus);
end;
begin
o:=0;
tot[o]:=1;
dl[o][1]:=0;
f[o][0]:=1;
i:=-1;
while tot[o]>0 do
begin
inc(i);
for j:=0 to 11 do
if int64(w)*two[i]*thr[j]>n then break
else
yes[int64(w)*two[i]*thr[j]]:=true;
o:=1-o;
fillchar(f[o],sizeof(f[o]),0);
tot[o]:=0;
for j:=1 to tot[1-o] do
if w*two[i]<=n then
dfs(i,0,dl[1-o,j],0,f[1-o,dl[1-o,j]]);
end;
o:=1-o;
ans:=0;
for i:=1 to tot[o] do
ans:=(ans+f[o][dl[o,i]]) mod modu;
exit(ans);
end;
begin
two[0]:=1;
for i:=1 to 18 do
two[i]:=two[i-1]*2;
thr[0]:=1;
for i:=1 to 12 do
thr[i]:=thr[i-1]*3;
ans:=1;
read(n);
for i:=1 to n do
if not yes[i] then
ans:=int64(ans)*calc(i) mod modu;
writeln(ans);
end.
1131
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
