NOIP2011解题报告
马鞍山第二中学 郑逸宁
DAY1.
1.1carpet
题目简述:
求最后一次覆盖某一点的矩形的序号.
分析:
对于点(x,y)和矩形(a,b,g,k),若满足a<=x<=a+g && b<=y<=b+k,则称该矩形覆盖该点.
实现1:
从前向后查找,一边读一边更新.T=O(n),S=O(1);
实现2:
先存储下来,从后往前查找,查找到即输出.T=O(n),S=O(n);
总结:
一般来说,实现2在数据已经储存好的情况下比1要快,但就本题来说比1花费了更多的空间,这体现了时间和空间的辩证关系.
代码
#include<cstdio>
#include<cstring>
#include<iostream>
long const maxn=10001;
long a[maxn],b[maxn],x[maxn],y[maxn];
long n;
long ansx,ansy;
bool flag=false;
int main(){
freopen("carpet.in","r",stdin);
freopen("carpet.out","w",stdout);
scanf("%ld",&n);
for(int i=1;i<=n;i++)
scanf("%ld %ld %ld %ld",&a[i],&b[i],&x[i],&y[i]);
scanf("%ld %ld",&ansx,&ansy);
for(int i=n;i>=1;i--)
if((ansx>=a[i])&&(ansx<=a[i]+x[i])&&(ansy>=b[i])&&(ansy<=b[i]+y[i])){
flag=true;
printf("%d\n",i);
break;
}
if(!flag)
printf("-1\n");
fclose(stdin);
fclose(stdout);
return 0;
}
1.2hotel
题目简述:
求一段有A,B两种属性的序列中,满足Ai=Aj,并且存在Bk(i<=k<=j)<=W的无序二元组的组数.
分析1:
这是一个静态统计问题.先不妨设i<j,防止统计时重复,也能很快的想到按属性A分开处理,我们可以利用动态规划的思想来解决.
实现1:
T[i]表示第i个元素前最近的满足Bk<=W元素的位置;
G[i][j]表示在前j 元素中属性A为i的元素的个数.
首先计算出G[i][j]:
若Aj=i,则G[i][j]=G[i][j-1]+1;
否则G[i][j]=G[i][j-1];
然后一边计算T[i],一边统计总数ans:
若i本身满足Bi<=W则T[i]=i,ans+=G[Ai][T[i]]-1(自己不能和自己成组);
否T[i]=T[i-1], ans+=G[Ai][T[i]].
最后时间复杂度T=O(kn),空间复杂度S=O(kn) .
分析2:
本题还有不同的思路.如:使用ST算法的O(nlog2n)的算法,和同样是DP预处理但构造得比较精妙的O(n)的算法。具体实现,以后再写.
总结:
O(kn)的算法很容易想到,但更快的算法比较困难,毕竟我在考场上还想错了.如果题目可以用O(kn)的方法解决,那么在考试时最好不要想O(n)或O(nlog2n)的算法.
O(kn)
#include<cstdio>
#include<cstring>
#include<iostream>
const long maxn=200001;
const long maxm=51;
int c[maxn];
bool t[maxn];
int G[maxm][maxn];
int T[maxn];
long long ans=0;
int main(){
freopen("hotel.in","r",stdin);
freopen("hotel.out","w",stdout);
memset(t,false,sizeof(t));
memset(G,0,sizeof(G));
long n,m,p;//n:hotels m:colours
int q;
scanf("%ld %ld %ld",&n,&m,&p);
for(int i=1;i<=n;i++){
scanf("%d %d",&c[i],&q);
if(q<=p)
t[i]=true;
}
for(int j=0;j<=m-1;j++)
for(int i=1;i<=n;i++)
{
if(j==c[i])
G[j][i]=G[j][i-1]+1;
else
G[j][i]=G[j][i-1];
}
for(int i=1;i<=n;i++){
if(t[i]){
T[i]=i;
ans+=(long long)G[c[i]][T[i]]-1;
}
else{
T[i]=T[i-1];
ans+=(long long)G[c[i]][T[i]];
}
}
printf("%lld",ans);
fclose(stdin);
fclose(stdout);
return 0;
}
1.3mayan
题目简述:
有一个游戏,通过交换左右两个方块,使三个或三个以上的同色方块连成一线而消除掉,当下方方块消除后,上面的方块会掉落.求在规定步数时,方块刚好全部消除的字典序最小方案.
分析:
搜索.
实现:
这道题很复杂,编写的内容非常的多,由于我水平不高,只是写了在一层中平移互换的部分.
总结:
要多练习搜索题.
30%
#include<cstdio>
#include<cstring>
#include<iostream>
int flag=true;
int tot;
int ansx[5],ansy[5],ansc[5];
void work(int i,int p[5]);
int main(){
freopen("mayan.in","r",stdin);
freopen("mayan.out","w",stdout);
int p[5];
memset(p,0,sizeof(p));
int t;
scanf("%d",&tot);
for(int i=0;i<=4;i++)
for(int j=1;;j++)
{
if(j>2){
flag=false;
break;
}
scanf("%d ",&t);
if(t)
p[i]=t;
else
break;
}
if(flag)
work(0,p);
else
printf("-1");
if(flag)
printf("-1");
fclose(stdin);
fclose(stdout);
return 0;
}
void work(int i,int p[5]){
int q[5];
if(!flag)
return ;
if(i==tot){
if((!p[1])&&(!p[2])&&(!p[3])&&(!p[4])&&(!p[0]))
{
for(int j=0;j<=tot-1;j++)
printf("%d %d %d\n",ansx[j],ansy[j],ansc[j]);
flag=false;
return;
}
return;
}
for(int x=0;x<=4;x++)if(p[x]){
for(int a=0;a<=4;a++)
q[a]=p[a];
if(x<4&&q[x]){
q[x]^=q[x+1];q[x+1]^=q[x];q[x]^=q[x+1];
for(int a=0;a<=2;a++){
int t=q[a],b;
for(b=a+1;b<=4;b++)
if(q[b]-t)
break;
if(b-a>=3)
for(b=a;b<=4;b++)
if(q[b]==t)
q[b]=0;
}
ansx[i]=x;
ansy[i]=0;
ansc[i]=1;
work(i+1,q);
}
for(int a=0;a<=4;a++)
q[a]=p[a];
if(x>0&&q[x]){
q[x]^=q[x-1];q[x-1]^=q[x];q[x]^=q[x-1];
for(int a=0;a<=2;a++){
int t=q[a],b;
for(b=a+1;b<=4;b++)
if(q[b]-t)
break;
if(b-a>=3)
for(b=a;b<=4;b++)
if(q[b]==t)
q[b]=0;
}
ansx[i]=x;
ansy[i]=0;
ansc[i]=-1;
work(i+1,q);
}
}
}
Day2:
2.1factor
题目简述:
求(ax+by)n中xnym项的次数.
分析:
利用二项式展开定理,系数为C(n,n+m) anbm
实现:
递推求出组合数C[i][j]=C[i-1][j-1]+C[i-1][j],一边加一边取模.再一边乘一边取模,乘上anbm即可.
T=O((n+m)2),S=O((n+m)2).
总结:
取模的运算遵循乘法和加法的结合律,但不支持除法.如果要用公式法算组合数,需要先分解质因数,
约分后再乘才行.相比之下使用递推法算组合数就更好一些
代码
#include<cstdio>
#include<cstring>
#include<iostream>
long c[1001][1001];
int main(){
freopen("factor.in","r",stdin);
freopen("factor.out","w",stdout);
long a,b,n,m,k;
long const mod=10007;
long ans=1;
memset(c,0,sizeof(c));
scanf("%ld %ld %ld %ld %ld",&a,&b,&k,&n,&m);
a%=mod;
b%=mod;
for(int i=1;i<=k;i++)
c[i][0]=c[i][i]=1;
for(int i=2;i<=k;i++)
for(int j=1;j<=i-1;j++){
c[i][j]=c[i-1][j]+c[i-1][j-1];
if(c[i][j]>mod)
c[i][j]-=mod;
}
ans*=c[k][n];
if(ans>mod)
ans-=mod;
for(int i=1;i<=n;i++){
ans*=a;
ans%=mod;
}
for(int i=1;i<=m;i++){
ans*=b;
ans%=mod;
}
printf("%ld",ans);
fclose(stdin);
fclose(stdout);
return 0;
}
2.2
题目简述:
给定n个含有w, v两种属性的元素和m个区间,选一个W,使公式:
Yi=∑1*∑vj,j∈[Li,Ri]且wj≥W
计算出的∑Yi与给定的值Y之间的差的绝对值最小。
分析:
这是一道动态统计的问题,但仔细分析,∑Yi随W增大而单调不增,所以我们可以先二分答案,让后把它改为静态的统计问题.对于多区间的统计,有不同的解决方法,所以同样使用二分答案,本题的得分也在50~100之间.
实现1:
单独处理每个区间,按照公式计算即可.
T=O(n2log2maxw),S=O(n).
实现2:
使用线段树.这是一个错误的想法,是在错误预估 O(nlog2nlog2maxw)的时间可以通过的前提下做出的选择,其实一开使想到O(n)的扫描线算法(其实这已经是一个错误的想法了,因为扫描线是用于对于多区间覆盖,无关联的点的简单统计用的,而对于有重叠的区间统计和较复杂的公式就无能为了力了),也联想到树状数组,觉得功能不足以完成较复杂的公式计算.其实没有想到正确的统计方法,要不然不仅是树状数组,连什么数据结构都不用也可以解决.
具体实现方式就是每次插入m条线段,并递归同时计算出∑1和∑vj,最后求和计算.
T=O(nlog2nlog2maxw),S=O(n).
实现3:
其实类似的统计题是做过的,但看到复杂的公式就没有想到改进.我们可以用动态规划的思想来解决这个问题:用t[i]表示前i个元素中符合条件的元素的个数,用sum[i]表示前i个元素中符合条件元素的v的值的和,那么对于区间[l,r],最后的值就是(sum[r]-sum[l-1])*(t[r]-t[l-1]).我们预处理出t[i]和sum[i]的值,然后对每个区间操作一次即可。
T=O((n+m)log2maxw),S=O(n).
总结:
好多人没有得满分的原因是二分查找没有注意边界,但也有像我一样脑残的人想到了高级的线段树,而忽视了简单的预处理,还浪费了不少的时间。
线段树悲剧
#include<cstdio>
#include<cstring>
#include<iostream>
long n,m;
long long S;
long long T;
long w[200001],v[200001];
long r[200001],l[200001];
long A[800001],B[800001];
long X[800001],P[800001];
long xx,pp;
long Hash[200001];//=Hash(x);
long Hass[200001];//=Hash-1(x);
long tHash=0;
long root;
long W;
long maxw=0;
long long work(long q);
void build(long i,long a,long b);
void count(long i,long a,long b);
void recount(long i,long a,long b);
inline long long abs(long long a,long long b){return (a-b>0)?(a-b):(b-a);}
int main(){
freopen("qc.in","r",stdin);
freopen("qc.out","w",stdout);
memset(Hash,0,sizeof(Hash));
long low,high,t;
long long g,k;
scanf("%ld %ld %lld",&n,&m,&S);
for(long i=1;i<=n;i++){
scanf("%ld %ld",&w[i],&v[i]);
if(w[i]>maxw)
maxw=w[i];
}
for(long i=1;i<=m;i++){
scanf("%ld %ld",&l[i],&r[i]);
Hash[l[i]]=Hash[r[i]]=1;
}
for(long i=1;i<=n;i++)
if(Hash[i]){
tHash++;
Hass[tHash]=i;
Hash[i]=tHash;
}
build(1,1,tHash);
low=0;high=maxw;
//g=work(4);printf("%lld",g);return 0;
g=work(high);
if(g>S){
printf("%lld",g-S);
fclose(stdin);
fclose(stdout);
return 0;
}
g=work(low);
if(g<S){
printf("%lld",S-g);
fclose(stdin);
fclose(stdout);
return 0;
}
while(low<=high){
t=(low+high)/2;
if(low+1==high)
break;
g=work(t);
if(g-S>0)
low=t;
else
high=t;
}
g=work(low);
g=abs(g,S);
k=work(high);
k=abs(k,S);
if(g<k)
printf("%lld",g);
else
printf("%lld",k);
fclose(stdin);
fclose(stdout);
return 0;
}
void build(long i,long a,long b){
A[i]=a;B[i]=b;
if(a+1!=b){
build(i*2,a,(a+b)/2);
build(i*2+1,(a+b)/2,b);
}
}
void count(long i,long a,long b){//
X[i]=P[i]=0;
if(a+1==b){
for(int k=Hass[a];k<=Hass[b];k++)
if(w[k]>=W){
X[i]++;
P[i]+=v[k];
}
}
else{
count(i*2,a,(a+b)/2);
count(i*2+1,(a+b)/2,b);
X[i]=X[i*2]+X[i*2+1];
P[i]=P[i*2]+P[i*2+1];
if(w[Hass[(a+b)/2]]>=W){
X[i]--;
P[i]-=v[Hass[(a+b)/2]];
}
}
return ;
}
void recount(long i,long a,long b){
if(A[i]==a&&B[i]==b){
xx+=X[i];
pp+=P[i];
return;
}
else if(b<=(A[i]+B[i])/2)
recount(i*2,a,b);
else if((a>=(A[i]+B[i])/2))
recount(i*2+1,a,b);
else {
recount(i*2,a,(A[i]+B[i])/2);
recount(i*2+1,(A[i]+B[i])/2,b);
if(w[Hass[(A[i]+B[i])/2]]>=W){
xx--;
pp-=v[Hass[(A[i]+B[i])/2]];
}
}
}
long long work(long q){
W=q;
T=0;
count(1,1,tHash);
for(long i=1;i<=m;i++){
xx=pp=0;
if(l[i]!=r[i])
recount(1,Hash[l[i]],Hash[r[i]]);
else if(w[l[i]]>W)
T+=(long long)w[l[i]]*v[l[i]];
T+=(long long)xx*pp;
}
return T;
}
AC代码
#include<cstdio>
#include<cstring>
#include<iostream>
long n,m;
long long S;
long w[200001],v[200001];
long r[200001],l[200001];
long long sum[200001];
long t[200001];
long xx,pp;
long root;
long maxw=0;
long long work(long q);
inline long long abs(long long a,long long b){return (a-b>0)?(a-b):(b-a);}
int main(){
freopen("qc.in","r",stdin);
freopen("qc.out","w",stdout);
long low,high,t;
long long g,k;
scanf("%ld %ld %lld",&n,&m,&S);
for(long i=1;i<=n;i++){
scanf("%ld %ld",&w[i],&v[i]);
if(w[i]>maxw)
maxw=w[i];
}
for(long i=1;i<=m;i++){
scanf("%ld %ld",&l[i],&r[i]);
}
low=0;high=maxw;
g=work(high);
if(g>S){
printf("%lld",g-S);
fclose(stdin);
fclose(stdout);
return 0;
}
g=work(low);
if(g<S){
printf("%lld",S-g);
fclose(stdin);
fclose(stdout);
return 0;
}
while(low<=high){
t=(low+high)/2;
if(low+1==high)
break;
g=work(t);
if(g-S>0)
low=t;
else
high=t;
}
g=work(low);
g=abs(g,S);
k=work(high);
k=abs(k,S);
if(g<k)
printf("%lld",g);
else
printf("%lld",k);
fclose(stdin);
fclose(stdout);
return 0;
}
long long work(long q){
long W=q;
long long T=0;
for(int i=1;i<=n;i++){
sum[i]=sum[i-1];
t[i]=t[i-1];
if(w[i]>W){
t[i]++;
sum[i]+=v[i];
}
}
for(int i=1;i<=m;i++)
T+=(sum[r[i]]-sum[l[i]-1])*(t[r[i]]-t[l[i]-1]);
return T;
} 2.3bus
题目简述:
有序的n个点组成一个序列,有m个单位在时间Ti出现在其中的一点Ai要移动到比Ai大的一点Bi,只有所有要到Ai点以后的单位都到了Ai点,才可以出发到下一个点,每两个相邻的点之间有一定权值的距离.可以通过k次调整,每次使相邻点之间的距离-1,可以重复调整.求所有点移动的最小时间和.
分析1:
题目不是很好懂,大略读懂题目后,观察数据中有k<=1的30%的数据,于是枚举即可.
实现1:
d[i]表示第i个点到第i+1个点的权值,a[i],b[i],t[i]如题目简述所示.latest[i]表示到第i个点的元素最晚的到达值,arrive[i]表示集体到第i个点的时间.当k=0时:
arrive[i]=max(arrive[i-1],latest[i-1])+d[i-1],
ans=∑(arrive[b[i]]-t[i])
当k=1时,枚举出一个d[i],减去1,计算出最优的ans即可.T=O(n2),S=O(n).
分析2:
我们考虑怎样使用调整.显然对于latest[i]>=arrive[i],对于i点以后的单位所需的时间没有任何影响,感觉这里的许多操作应该是独立的,大概可以用贪心的方法来解题,然而需要一个衡量标准,这正是在考场上没想到的.
实现2:
用next[i]表示在第i个点后离i最近的满足latest[i]>=arrive[i]的点,sum[i]表示前i个点的单位数.
我们可以用sum[next[i]]-sum[i]来衡量在第i-1到第i个点之间调整的效果,每次选择该值最大的边,把d的值-1,然后重新计算arrive[i]的值,再做相同操作.此时时间复杂度O(kn),还不足以通过全部的数据.其实很简单的想一想,如果把d[i]的值-1后仍然有所有满足latest[i]>=arrive[i]的点的状态不会改变并且d[i]仍然可以-1,那么下次调整的还是i-1到i的这条边.我们不妨一次性把它做到位,让d[i]减去一个恰好的数(我是拿KM算法的松弛量类比的)最终T=O(n2),S=O(n).
总结:
本来想在后面70%中随便贪心做做的,但时间不够了,当时想的贪心法已经很接近这个解法了,如果第二题能节约更多的时间的话,就可以给这题留出更大的希望.
果断30%
#include<cstdio>
#include<cstring>
#include<iostream>
long n,m,k;
long d[10001];
long t[10001],a[10001],b[10001];
long latest[10001];
long arrive[10001];
long ans=0;
long qqq;
int main(){
freopen("bus.in","r",stdin);
freopen("bus.out","w",stdout);
memset(latest,0,sizeof(latest));
scanf("%ld %ld %ld",&n,&m,&k);
for(int i=1;i<=n-1;i++)
scanf("%ld",&d[i]);
for(int i=1;i<=m;i++){
scanf("%ld %ld %ld",&t[i],&a[i],&b[i]);
if(t[i]>latest[a[i]])
latest[a[i]]=t[i];
}
if(k==0){
int tt=latest[1];
for(int i=2;i<=n;i++){
arrive[i]=tt+d[i-1];
tt=arrive[i];
if(latest[i]>tt)
tt=latest[i];
}
for(int i=1;i<=m;i++)
ans+=arrive[b[i]]-t[i];
printf("%ld",ans);
fclose(stdin);
fclose(stdout);
return 0;
}
if(k==1){
qqq=100000000;
for(int j=1;j<=n-1;j++){
ans=0;
d[j]--;
memset(arrive,0,sizeof(arrive));
int tt=latest[1];
for(int i=2;i<=n;i++){
arrive[i]=tt+d[i-1];
tt=arrive[i];
if(latest[i]>tt)
tt=latest[i];
}
for(int i=1;i<=m;i++)
ans+=arrive[b[i]]-t[i];
if(ans<qqq)
qqq=ans;
d[j]++;
}
printf("%ld",qqq);
fclose(stdin);
fclose(stdout);
return 0;
}
fclose(stdin);
fclose(stdout);
return 0;
}
其实AC也不难
#include<cstdio>
#include<cstring>
#include<iostream>
long n,m,k;
long d[10001];
long t[10001],a[10001],b[10001];
long latest[10001];
long arrive[10001];
long sum[10001];
long next[10001];
long ans=0;
long qqq;
long dd;
long maxl;
long maxint=1000000000;
long inline max(long a,long b){return a>b?a:b;}
long inline min(long a,long b){return a<b?a:b;}
int main(){
freopen("bus.in","r",stdin);
freopen("bus.out","w",stdout);
memset(latest,0,sizeof(latest));
memset(sum,0,sizeof(sum));
scanf("%ld %ld %ld",&n,&m,&k);
for(int i=1;i<=n-1;i++)
scanf("%ld",&d[i]);
for(int i=1;i<=m;i++){
scanf("%ld %ld %ld",&t[i],&a[i],&b[i]);
if(t[i]>latest[a[i]])
latest[a[i]]=t[i];
sum[b[i]]++;
}
for(int i=1;i<=n;i++)
sum[i]+=sum[i-1];
while(1){
maxl=1;
//计算arrive[i]
arrive[1]=0;
for(int i=2;i<=n;i++)
arrive[i]=max(arrive[i-1],latest[i-1])+d[i-1];
//计算next[i]
next[n]=n;
for(int i=n-1;i;i--){
next[i]=next[i+1];
if(arrive[i+1]<=latest[i+1])
next[i]=i+1;
}
//贪心选择最优的一条边操作,一次操作可以直接使d[i]变为0
while(!d[maxl]&&maxl<=n-1)
maxl++;
if(maxl==n||k==0)
break;
for(int i=maxl+1;i<=n-1;i++)
if(d[i]&&sum[next[maxl]]-sum[maxl]<sum[next[i]]-sum[i])
maxl=i;
if(sum[next[maxl]]-sum[maxl]==0)
break;
dd=maxint;
for(int i=maxl+1;i<=next[maxl]-1;i++)
dd=min(dd,arrive[i]-latest[i]);
dd=min(dd,k);
dd=min(dd,d[maxl]);
k-=dd;
d[maxl]-=dd;
}
for(int i=1;i<=m;i++)
ans+=arrive[b[i]]-t[i];
printf("%ld",ans);
fclose(stdin);
fclose(stdout);
return 0;
}
注:本文用T 表示时间复杂度,S表示空间复杂度.复杂度只表示数量级,不考虑常数.
还需思考的问题:
1.2的O(nlogn)和O(n)的解法
2.1的数学方法优化?
1.3怎样爆搜?