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

2
5 11 3
15 13 10 9 8
5 11 3
8 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 2
3 2 1 4 3 5
3
4

Sample Output

Case #1:
2
2

比赛的时候没搞出来

可以首先与处理出所有的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

2
2
1 10
3
2 5 4

Sample Output

Case #1:
0
Case #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

6
in 874
query
out
in 24622
in 12194
query

Sample Output

Case #1:
874
24622

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

#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;
}