2015年百度之星初赛(hdu5246-5251)

超级赛亚ACMer

 

 Accepts: 868

 

 Submissions: 5329

 Time Limit: 2000/1000 MS (Java/Others)

 

 Memory Limit: 32768/32768 K (Java/Others)

Problem Description

百小度是一个ACMer，也是一个超级赛亚人，每个ACMer都有一个战斗力，包括百小度。
所谓超级赛亚人的定义，是说如果在对抗中刚好接近极限状态，那就会激发斗志，实力提升。


具体来说，就是百小度现在要接受一些ACMer的挑战了，这些ACMer有n个人，第i个人的战斗力是a[i]。


百小度接下来可以自主安排与这n个ACMer的PK顺序，他要想在PK赛中赢过另外一个ACMer，就必须使得自己的战斗力不小于对方（平局情况他会按照百小度字典上的规则把自己排在第一）。


如果百小度的战斗力大于对方，那么百小度就会轻易获胜，得不到锻炼并且骄傲起来，他以后的战斗力将保持在这个值，再也不会发生改变。
如果百小度的战斗力等于对方，那么百小度在获胜的同时也会感到很吃力，但是这会激发百小度的斗志，使得他刻苦刷题，在下场PK赛之前，战斗力最多提升k点（即可以提升0~k点任意值）。



k是百小度的潜力提升上限，会被给定一个初始值，这个潜力提升上限k在后面的比赛中会下降。


每战胜一个ACMer，这个潜力上限k将减少1（因为超级赛亚人百小度也会感到累），但k最低只会减少到0，即不会出现战斗力下降的情况
。也就是第一次比赛如果激发了百小度的斗志，他能把战斗力提升0~k的任一值，如果第二次比赛继续被激发斗志，他能在第一次提升后的基础上，把战斗力再提升0 max(0,k−1),依次类推……


m是百小度的初始战斗力上限，也就是百小度第一次进行PK赛的时候，可以选择0~m的任意一个值作为他的战斗力。



现在希望你编写程序，判断一下百小度是否战胜所有的ACMer。

Input

输入包含多组数据（数据不超过500组）

第一行一个整数T，表示T组数据


对于每组数据，第一行包括三个整数n,m,k(1≤n≤104,1≤m,k≤108)


第二行包括n个正整数，表示彪形大汉的战斗力（战斗力为不超过1012的正整数）

Output

对于每组数据，先输出一行Case #i: (1≤i≤T)


如果百小度能打败所有的ACMer，再输出"why am I so diao?"


否则再输出"madan!"

Sample Input

25 11 315 13 10 9 85 11 38 9 10 13 16

Sample Output

Case #1:why am I so diao?Case #2:madan!
Hint
第一组样例解释5个ACMer，初始战斗力选择范围是[0,11],接下来每场战斗力提升上限是3,2,1,0,0,...,0百小度首先使得自己的初始战斗力为10，打败战斗力为10的第一个ACMer，然后选择战斗力提升3，变成13，打败战斗力为13的第二个ACMer，然后选择战斗力提升2，变成15，打败战斗力为15的第三个ACMer，之后再以任意顺序打败剩下的ACMer

思路：贪心，排序，先找到小于M离M最近的数，然后贪心，尽量加K的最大值

#include<iostream>#include<cstdio>#include<string>#include<cstring>#include<vector>#include<cmath>#include<queue>#include<stack>#include<map>#include<set>#include<algorithm>using namespace std;typedef long long LL;const int maxn=100010;int N,K,M;LL a[maxn];int main(){    int T;    scanf("%d",&T);    LL cas=0;    while(T--)    {        scanf("%d%d%d",&N,&M,&K);        for(LL i=1; i<=N; i++) scanf("%I64d",&a[i]);        sort(a+1,a+N+1);        int i=0;        while(i<N&&a[i+1]<=M) i++;        printf("Case #%I64d:\n",++cas);        if(i==0)        {            printf("madan!\n");            continue;        }        LL cur=K;        LL last=a[i];        bool flag=1;        i++;        while(i<=N)        {            if(a[i]-last>cur)            {                flag=0;                break;            }            if(i<N&&a[i+1]-last<=cur)i++;            else            {                cur--;                cur=max(cur,0LL);                last=a[i];                i++;            }        }        if(flag) printf("why am I so diao?\n");        else printf("madan!\n");    }    return 0;}

找连续数

 

 Accepts: 401

 

 Submissions: 1911

 Time Limit: 2000/1000 MS (Java/Others)

 

 Memory Limit: 32768/32768 K (Java/Others)

Problem Description

小度熊拿到了一个无序的数组，对于这个数组，小度熊想知道是否能找到一个k 的区间，里面的 k 个数字排完序后是连续的。

现在小度熊增加题目难度，他不想知道是否有这样的 k 的区间，而是想知道有几个这样的 k 的区间。

Input

输入包含一组测试数据。

第一行包含两个整数n，m，n代表数组中有多少个数字，m 代表针对于此数组的询问次数，n不会超过10的4次方，m 不会超过1000。第二行包含n个正整数，第 I 个数字代表无序数组的第 I 位上的数字，数字大小不会超过2的31次方。接下来 m 行，每行一个正整数 k，含义详见题目描述，k 的大小不会超过1000。

Output

第一行输"Case #i:"。(由于只有一组样例，只输出”Case #1:”即可)

然后对于每个询问的 k，输出一行包含一个整数，代表数组中满足条件的 k 的大小的区间的数量。

Sample Input

6 23 2 1 4 3 534

Sample Output

Case #1:22

比赛的时候没搞出来

可以首先与处理出所有的1~1000的K区间，然后直接查询，或者RMQ在线查询，判断的时候，要考虑是不是有重复，是不是有断点

首先是预处理写法：

#include<iostream>#include<cstdio>#include<string>#include<cstring>#include<vector>#include<cmath>#include<queue>#include<stack>#include<map>#include<set>#include<algorithm>using namespace std;const int maxn=10010;int N,M;int a[maxn];int ans[maxn],pre[maxn];int minv[maxn],maxv[maxn];bool vis[maxn];map<int,int> mp;void solve(){    mp.clear();    for(int i=1;i<=N;i++)    {        maxv[i]=minv[i]=a[i];        vis[i]=1;        if(mp.find(a[i])==mp.end())pre[i]=-1;        else pre[i]=mp[a[i]];        mp[a[i]]=i;    }    for(int i=1;i<=1000;i++)    {        ans[i]=0;        if(i>N)break;        for(int j=1;j+i<=N+1;j++)        {            if(!vis[j])continue;            if(maxv[j]-minv[j]+1!=i)continue;            ans[i]++;        }        for(int j=1;j+i<=N;j++)        {            maxv[j]=max(maxv[j],a[i+j]);            minv[j]=min(minv[j],a[i+j]);            if(pre[i+j]>=j)vis[j]=false;        }    }}int main(){    int cas=1;    while(scanf("%d%d",&N,&M)!=EOF)    {        for(int i=1;i<=N;i++)scanf("%d",&a[i]);        solve();        printf("Case #%d:\n",cas++);        while(M--)        {            int x;            scanf("%d",&x);            printf("%d\n",ans[x]);        }    }    return 0;}

然后是RMQ写法，参考了BC上大神的

#include<iostream>#include<cstdio>#include<string>#include<cstring>#include<vector>#include<cmath>#include<queue>#include<stack>#include<map>#include<set>#include<algorithm>using namespace std;typedef long long LL;const double eps=1e-6;const int maxn=10100;LL A[maxn][20],B[maxn][20],C[maxn][20];int logn[maxn];map<LL,int> mp;int N,M;LL a[maxn];int can(int l,int r){//    int k=logn[r-l+1];    int k=0;    while((1<<(k+1))<=(r-l+1))k++;    LL a=max(A[l][k],A[r-(1<<k)+1][k]);    LL b=min(C[l][k],C[r-(1<<k)+1][k]);    LL c=max(B[l][k],B[r-(1<<k)+1][k]);    return (c-b==r-l)&&a<l;}int main(){    int cas=1;    scanf("%d%d",&N,&M);//    for(int i=1;i<=N;i++)//        logn[i]=int(floor(log(double(i))/log(2.0)+eps));    for(int i=1;i<=N;i++)scanf("%I64d",&a[i]);    for(int i=1;i<=N;i++)        B[i][0]=C[i][0]=a[i];    for(int i=1;i<=N;i++)        A[i][0]=mp[a[i]],mp[a[i]]=i;    for(int j=1;(1<<j)<=N;j++)        for(int i=1;i+(1<<j)<=N+1;i++)            A[i][j]=max(A[i][j-1],A[i+(1<<(j-1))][j-1]),            C[i][j]=min(C[i][j-1],C[i+(1<<(j-1))][j-1]),            B[i][j]=max(B[i][j-1],B[i+(1<<(j-1))][j-1]);    printf("Case #%d:\n",cas++);    while(M--)    {        int x,ans=0;        scanf("%d",&x);        for(int i=1;i+x-1<=N;i++)            if(can(i,i+x-1))ans++;        printf("%d\n",ans);    }    return 0;}

序列变换

 

 Accepts: 816

 

 Submissions: 3578

 Time Limit: 4000/2000 MS (Java/Others)

 

 Memory Limit: 32768/32768 K (Java/Others)

Problem Description

给定序列A={A1,A2,...,An}, 要求改变序列A中的某些元素，形成一个严格单调的序列B（严格单调的定义为：Bi<Bi+1,1≤i<N）。

我们定义从序列A到序列B变换的代价为cost(A,B)=max(|Ai−Bi|)(1≤i≤N)。

请求出满足条件的最小代价。

注意，每个元素在变换前后都是整数。

Input

第一行为测试的组数T(1≤T≤10).

对于每一组： 第一行为序列A的长度N(1≤N≤105)，第二行包含N个数，A1,A2,...,An. 序列A中的每个元素的值是正整数且不超过106。

Output

对于每一个测试样例，输出两行：

第一行输出："Case #i:"。i代表第 i 组测试数据。

第二行输出一个正整数，代表满足条件的最小代价。

Sample Input

221 1032 5 4

Sample Output

Case #1:0Case #2:1

思路：二分

#include<iostream>#include<cstdio>#include<string>#include<cstring>#include<vector>#include<cmath>#include<queue>#include<stack>#include<map>#include<set>#include<algorithm>using namespace std;const int maxn=100010;int N;int a[maxn];bool can(int x){    int last=a[1]-x;    for(int i=2;i<=N;i++)    {        if(a[i]+x<=last)return false;        last=max(a[i]-x,last+1);    }    return true;}int main(){    int T,cas=1;    scanf("%d",&T);    while(T--)    {        scanf("%d",&N);        int sum=0;        for(int i=1;i<=N;i++)scanf("%d",&a[i]);        int l=0,r=1e6;        while(l<r)        {            int mid=(l+r)>>1;            if(can(mid))r=mid;            else l=mid+1;        }        printf("Case #%d:\n%d\n",cas++,l);    }    return 0;}

KPI

 

 Accepts: 517

 

 Submissions: 2185

 Time Limit: 2000/1000 MS (Java/Others)

 

 Memory Limit: 32768/32768 K (Java/Others)

Problem Description

你工作以后, KPI 就是你的全部了. 我开发了一个服务，取得了很大的知名度。数十亿的请求被推到一个大管道后同时服务从管头拉取请求。让我们来定义每个请求都有一个重要值。我的KPI是由当前管道内请求的重要值的中间值来计算。现在给你服务记录，有时我想知道当前管道内请求的重要值得中间值。

Input

有大约100组数据。

每组数据第一行有一个n(1≤n≤10000)，代表服务记录数。

接下来有n行，每一行有3种形式 "in x": 代表重要值为x(0≤x≤109)的请求被推进管道。 "out": 代表服务拉取了管道头部的请求。 "query: 代表我想知道当前管道内请求重要值的中间值. 那就是说，如果当前管道内有m条请求, 我想知道，升序排序后第floor(m/2)+1th 条请求的重要值.

为了让题目简单，所有的x都不同，并且如果管道内没有值，就不会有"out"和"query"操作。

Output

对于每组数据，先输出一行

Case #i: 然后每一次"query"，输出当前管道内重要值的中间值。

Sample Input

6in 874queryoutin 24622in 12194query

Sample Output

Case #1:87424622

思路：线段树维护离散化之后的区间中在队列中的数个数

#include<iostream>#include<cstdio>#include<string>#include<cstring>#include<vector>#include<cmath>#include<queue>#include<stack>#include<map>#include<set>#include<algorithm>using namespace std;const int maxn=20100;int N;int root,tot;queue<int> qu;int X[maxn];struct node{    char op[10];    int x;}q[maxn];struct IntervalTree{    int sum[maxn<<2];    void build()    {        memset(sum,0,sizeof(sum));    }    void update(int o,int l,int r,int pos,int val)    {        if(l==r)        {            sum[o]+=val;            return ;        }        int mid=(l+r)>>1;        if(pos<=mid)update(o<<1,l,mid,pos,val);        else update(o<<1|1,mid+1,r,pos,val);        pushup(o);    }    void pushup(int o)    {        sum[o]=sum[o<<1]+sum[o<<1|1];    }    int query(int o,int l,int r,int val)    {        if(l==r)return l;        int mid=(l+r)>>1;        if(sum[o<<1]>=val)return query(o<<1,l,mid,val);        else return query(o<<1|1,mid+1,r,val-sum[o<<1]);    }}tree;int main(){    int x;    int cas=1;    while(scanf("%d",&N)!=EOF)    {        int cnt=0;        for(int i=1;i<=N;i++)        {            scanf("%s",q[i].op);            if(q[i].op[0]=='i')            {                scanf("%d",&q[i].x);                X[++cnt]=q[i].x;            }        }        printf("Case #%d:\n",cas++);        while(!qu.empty())qu.pop();        sort(X+1,X+cnt+1);        int num=0;        tree.build();        for(int i=1;i<=N;i++)        {            if(q[i].op[0]=='i')            {                int pos=lower_bound(X+1,X+cnt+1,q[i].x)-X;                tree.update(1,1,cnt,pos,1);                qu.push(q[i].x);                num++;            }            else if(q[i].op[0]=='o')            {                int pos=lower_bound(X+1,X+cnt+1,qu.front())-X;                tree.update(1,1,cnt,pos,-1);                qu.pop();                num--;            }            else            {                int pos=tree.query(1,1,cnt,num/2+1);                printf("%d\n",X[pos]);            }        }    }    return 0;}