2016"百度之星" - 初赛（Astar Round2B）解题报告
Preface
hdu5696~5701
1001 区间的价值
主要利用数据随机的特性。之前没接触过这类题，主要利用随机数据分布的特点，将一些 O(n2) 的时间复杂度用调和级数转化为 O(nlogn) 的时间复杂度。除此之外，还有一些特性，例如长度为 n 的最长上升序列的长度大约为 logn ， n 个随机点的凸包点集大小大约为 logn 等等。。之后会收集下此类的题。回到这个题上，先说做法，递归处理区间 [l,r] 找出区间中的最小值和最大值，更新后，再去递归区间 [l,k−1] 和区间 [k+1,r] 。其中 k 是区间 [l,r] 中最小值的下标。再利用 ans[i]=max(ans[i],ans[i+1]) 更新得到答案。显然这个做法是正确的，又由于数据是随机的，所以这个时间复杂度我们可以进行看成 O(nlogn) 的。
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#include<bitset>
using namespace std;
typedef long long LL;
LL ans[110000];
LL a[110000];
void work(int l,int r)
{
if (l>r) return ;
if (l==r)
{
ans[1]=max(ans[1],a[l]*a[l]);
return ;
}
int minn=l,maxx=l;
for (int i=l;i<=r;i++)
{
if (a[i]<a[minn]) minn=i;
if (a[i]>a[maxx]) maxx=i;
}
ans[r-l+1]=max(ans[r-l+1],a[minn]*a[maxx]);
work(l,minn-1);
work(minn+1,r);
}
int n;
int main()
{
while (scanf("%d",&n)==1)
{
memset(ans,0,sizeof(ans));
for (int i=1;i<=n;i++)
{
scanf("%I64d",&a[i]);
}
work(1,n);
for (int i=n-1;i>=1;i--)
ans[i]=max(ans[i],ans[i+1]);
for (int i=1;i<=n;i++)
printf("%I64d\n",ans[i]);
}
return 0;
}1002 刷题计划
这里主要用到求解最大/最小乘积生成树的思想，具体做法之后会专门写一篇算法学习，先放上神犇的链接：
http://www.cnblogs.com/autsky-jadek/p/3959446.html
然后题目中要求要第一关键字之和至少要到 m ，我们只需要用背包搞一下就行了。
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#include<bitset>
using namespace std;
typedef long long LL;
const LL INF=1e18;
int n,m;
LL pa[500],pb[500],pc[500];
LL a[500],b[500],c[500];
LL w[500];
LL A[1100],B[1100];
struct point
{
LL x,y;
}ans;
LL cross(point a,point b)
{
return a.x*b.y-a.y*b.x;
}
int d[500];
LL sum;
LL f[1100];
int cmp(int a,int b)
{
return pa[a]<pa[b];
}
point find(LL k1,LL k2)
{
point num={0,0};
for (int i=1;i<=n;i++)
w[i]=-b[i]*k2+c[i]*k1;
memset(A,0,sizeof(A));
memset(B,0,sizeof(B));
for (int i=0;i<=sum;i++)
f[i]=-INF;
f[0]=0;
int pre=0;
for (int i=1;i<=n;i++)
{
pre+=a[i];
for (int j=pre,k1=j-a[i];j>=a[i];j--,k1--)
if (f[k1]>-1e16&&f[k1]+w[i]>f[j])
{
f[j]=f[k1]+w[i];
A[j]=A[k1]+b[i];
B[j]=B[k1]+c[i];
}
}
LL now=-INF;
for (int i=m;i<=sum;i++)
if (f[i]>now)
{
now=f[i];
num=(point){A[i],B[i]};
}
if (num.x*num.y<ans.x*ans.y) ans=num;
return num;
}
void work(point k1,point k2)
{
if (k1.x==k2.x&&k1.y==k2.y)
{
k2.x++,k2.y++;
}
int ka=k1.x-k2.x,kb=k1.y-k2.y;
point now=find(ka,kb);
point aa={k1.x-k2.x,k1.y-k2.y};
point bb={now.x-k2.x,now.y-k2.y};
if (cross(aa,bb)>0)
{
work(k1,now);
work(now,k2);
}
}
int main()
{
while (scanf("%d%d",&n,&m)==2)
{
for (int i=1;i<=n;i++)
{
scanf("%I64d %I64d %I64d",&pa[i],&pb[i],&pc[i]);
d[i]=i;
}
sort(d+1,d+1+n,cmp);
for (int i=1;i<=n;i++)
a[i]=pa[d[i]],b[i]=pb[d[i]],c[i]=pc[d[i]];
ans.x=ans.y=2100000;
sum=0;
for (int i=1;i<=n;i++)
sum+=a[i];
work(find(1,0),find(0,-1));
printf("%I64d\n",ans.x*ans.y);
}
return 0;
}1003 瞬间移动
组合数学题。我们能够发现，当n固定时，整个答案为n-2阶等差数列，之后能推出公式
ans=Cn−2n+m−4
然后利用预处理出的逆元的前缀积，和阶乘的值 O(1) 搞一下就行了。
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#include<bitset>
using namespace std;
typedef long long LL;
const LL mod=1e9+7;
LL f[1100000],inv[1100000],ff[1100000];
LL C(int n,int m)
{
if (n==0||m==0) return 1;
LL res=(f[n]*inv[m])%mod;
res=(res*inv[n-m])%mod;
return res;
}
int n,m;
int main()
{
f[0]=1;
for (int i=1;i<=1000010;i++)
f[i]=(f[i-1]*i)%mod;
ff[1]=ff[0]=inv[1]=inv[0]=1;
for (int i=2;i<=1000010;i++)
{
inv[i]=(LL)(mod-mod/i)*inv[mod%i]%mod;
ff[i]=inv[i];
}
for (int i=2;i<=1000010;i++)
inv[i]=(inv[i-1]*inv[i])%mod;
while (scanf("%d %d",&n,&m)==2)
{
printf("%I64d\n",C(n+m-4,n-2));
}
return 0;
}1004 货物运输
首先我们能想到二分答案，然后问题在于如何判断一个答案是否存在方案。假设我们需要判断时间最多为 x 的方案是否存在。对于一个运输 l[i] 和 r[i] ，如果之间的距离小于 x ，我们就不用考虑了。如果大于 x ，我们要找出新建的站点两端 l 和 r 所在的最大的区间即可，这里我们只用讨论四种方案就行。最后看区间是否为空就可以判断是否存在方案了。
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#include<bitset>
using namespace std;
typedef long long LL;
int n,m;
int l[1100000],r[1100000];
int lx,rx,ly,ry;
void change(int x,int y)
{
int l=x-y,r=x+y;
lx=min(lx,l),ly=min(ly,r);
rx=max(rx,l),ry=max(ry,r);
}
int check(int x)
{
int x1=-1e9,x2=1e9,y1=-1e9,y2=1e9;
for (int i=1;i<=m;i++)
{
if (r[i]-l[i]>x)
{
lx=ly=1e9,rx=ry=-1e9;
change(l[i],r[i]-x);
change(l[i],r[i]+x);
change(l[i]-x,r[i]);
change(l[i]+x,r[i]);
x1=max(x1,lx),y1=max(y1,ly);
x2=min(x2,rx),y2=min(y2,ry);
if (x1>x2||y1>y2) return 0;
}
}
return 1;
}
int solve()
{
int l=0,r=n-1;
while (l<r)
{
int mid=(l+r)>>1;
if (check(mid)) r=mid;
else l=mid+1;
}
return l;
}
int main()
{
while (scanf("%d %d",&n,&m)==2)
{
for (int i=1;i<=m;i++)
{
scanf("%d %d",&l[i],&r[i]);
if (l[i]>r[i]) swap(l[i],r[i]);
}
int ans=solve();
printf("%d\n",ans);
}
return 0;
}1005 区间交
将线段的所有端点排序，对于同一位置的点，我们先考虑线段左端点的插入，再更新答案，最后考虑线段右端点的删除。那么如何更新答案呢。我们考虑以 i 为区间交的左端点的情况，由于所有数值为正，所以此时区间的右端点越大越好。如果此时插入的线段个数不少于 k ，那么后面一定有至少 k 个右端点，我们只要求出所有右端点中的第 k 大即可，那么这个是以 i 为左端点，线段右端点中第 k 大的位置为右端点的区间，更新下 ans 即可。插入和删除可以用线段树维护，不过我选择了模板功能强大的splay。插入时，将对应线段的右端点放进splay中，删除时，将对应线段右端点从splay中删除即可。
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#include<bitset>
using namespace std;
typedef long long LL;
int l[110000],r[110000];
vector<int> p;
struct point
{
int id,x,type;
}a[310000];
LL v[110000];
int num;
int cmp(point a,point b)
{
if (a.x!=b.x) return a.x<b.x;
return a.type<b.type;
}
const int maxn=110000;
struct node
{
int num,size,c[2],fa;
LL data;
}tree[maxn];
int root=0,sum=0;
void update(int x)
{
tree[x].size=tree[tree[x].c[0]].size+tree[tree[x].c[1]].size+tree[x].num;
}
void rotate(int x,int p)
{
int y=tree[x].fa;
if (tree[x].c[p]) tree[tree[x].c[p]].fa=y;
tree[y].c[p^1]=tree[x].c[p];
tree[x].c[p]=y;
tree[x].fa=tree[y].fa;
tree[y].fa=x;
if (tree[x].fa) if (y==tree[tree[x].fa].c[0]) tree[tree[x].fa].c[0]=x;
else tree[tree[x].fa].c[1]=x;
update(y);
update(x);
}
void splay(int x)
{
while (tree[x].fa!=0)
{
int y=tree[x].fa;
int z=tree[y].fa;
if (z==0)
{
if (tree[y].c[0]==x) rotate(x,1);
else rotate(x,0);
break;
}
int a=y==tree[z].c[0]?1:0;
int b=x==tree[y].c[0]?1:0;
if (a^b) rotate(x,b),rotate(x,a);
else rotate(y,a),rotate(x,b);
}
root=x;
}
void maintain(int x)
{
while (x!=0)
update(x),x=tree[x].fa;
}
void init(LL x,int sum)
{
tree[sum].data=x;
tree[sum].fa=0;
tree[sum].c[0]=0;
tree[sum].c[1]=0;
tree[sum].num=1;
tree[sum].size=1;
}
void insert(LL x,int sum)
{
int y=root;
int pos=0;
init(x,sum);
if (y==0)
{
root=sum;
return;
}
while (true)
{
tree[y].size++;
if (x==tree[y].data)
{
pos=y;
tree[y].num++;
maintain(y);
break;
}
int p=1;
if (x<tree[y].data) p=0;
if (tree[y].c[p]==0)
{
tree[y].c[p]=sum;
tree[sum].fa=y;
break;
}
else y=tree[y].c[p];
}
if (pos==0) pos=sum;
splay(pos);
}
int findpos(LL x,int z)
{
int p,y=root,d=0;
while (x!=tree[y].data)
{
p=0;
if (x>tree[y].data) p=1;
if (p&&z) d+=tree[tree[y].c[0]].size+tree[y].num;
y=tree[y].c[p];
}
if (z) return d+tree[tree[y].c[0]].size+1;
else return y;
}
int find(int x,int p)
{
x=findpos(x,0);
splay(x);
int y=root;
y=tree[y].c[p];
while (tree[y].c[p^1])
y=tree[y].c[p^1];
return y;
}
void del(LL x)
{
int pos=findpos(x,0);
splay(pos);
if (tree[pos].num>1)
{
tree[pos].num--;
tree[pos].size--;
}
else
{
if (tree[pos].c[0]!=0)
{
tree[tree[pos].c[0]].fa=0;
int f=find(tree[pos].data,0);
tree[tree[pos].c[1]].fa=f;
tree[f].c[1]=tree[pos].c[1];
maintain(tree[pos].c[1]);
root=tree[pos].c[0];
tree[pos].c[0]=0;
tree[pos].c[1]=0;
}
else
{
tree[tree[pos].c[1]].fa=0;
root=tree[pos].c[1];
}
}
}
LL finddata(int x)
{
int y=root;
while (x<=tree[tree[y].c[0]].size||x>tree[tree[y].c[0]].size+tree[y].num)
{
if (x<=tree[tree[y].c[0]].size) y=tree[y].c[0];
else
{
x-=tree[tree[y].c[0]].size+tree[y].num;
y=tree[y].c[1];
}
}
return tree[y].data;
}
LL ssum[110000];
int n,k,m;
int main()
{
while (scanf("%d %d %d",&n,&k,&m)==3)
{
root=sum=num=0;
for (int i=1;i<=n;i++)
scanf("%I64d",&v[i]);
for (int i=1;i<=n;i++)
ssum[i]=ssum[i-1]+v[i];
for (int i=1;i<=m;i++)
{
scanf("%d %d",&l[i],&r[i]);
num++;
a[num].id=i;a[num].x=l[i];a[num].type=1;
num++;
a[num].id=i;a[num].x=r[i];a[num].type=3;
}
for (int i=1;i<=n;i++)
{
num++;
a[num].id=i;
a[num].x=i;
a[num].type=2;
}
sort(a+1,a+1+num,cmp);
int now=0;
LL ans=0;
for (int i=1;i<=num;i++)
{
if (a[i].type==1)
{
now++;
insert(ssum[r[a[i].id]],++sum);
}
if (a[i].type==2)
{
if (now<k) continue;
ans=max(ans,finddata(now+1-k)-ssum[a[i].id-1]);
}
if (a[i].type==3)
{
now--;
del(ssum[r[a[i].id]]);
}
}
printf("%I64d\n",ans);
}
return 0;
}1006 中位数计数
首先我们能判断出，我们不需要特殊考虑两个数的平均值为 x 的这种情况。之后我们就可以将其转化为经典的问题了。枚举中位数，然后以之为起点，向两边扫，遇到大于 x 的数置为1，遇到小于 x 的数置为-1，遇到等于 x 的数置为0即可。然后判断有多少区间和为0即可。
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#include<bitset>
using namespace std;
typedef long long LL;
int n;
int a[9000],b[9100];
int d[18100];
const int bb=9040;
int main()
{
while (scanf("%d",&n)==1)
{
for (int i=1;i<=n;i++)
scanf("%d",&a[i]);
for (int i=1;i<=n;i++)
{
int ans=0;
memset(d,0,sizeof(d));
for (int j=1;j<=n;j++)
{
if (a[j]==a[i]) b[j]=0;
else if (a[j]>a[i]) b[j]=1;
else b[j]=-1;
}
int now=0;
for (int j=i;j>=1;j--)
{
now+=b[j];
d[now+bb]++;
}
now=0;
for (int j=i;j<=n;j++)
{
now+=b[j];
ans+=d[-now+bb];
}
printf("%d",ans);
if (i!=n) printf(" ");
else printf("\n");
}
}
return 0;
}