超级赛亚ACMer
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1536 Accepted Submission(s):
437
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
Source 2015年百度之星程序设计大赛 - 初赛(1) 题意： 就好比上台阶，每次自己跳跃的高度有限，怎么样跳到顶点是一个思路。 思路： 对于给定的那些战斗力的进行升序排序，然后采取贪心策略，每次尽可能的往上走。 代码：
1 #include <stdio.h>
2 #include<algorithm>
3 #define maxn 10005
4 long long aa[maxn];
5 int main()
6 {
7 int cnt=1,cas,i;
8 long long nn,mm,kk,res;
9 scanf("%d",&cas);
10 while(cas--){
11 scanf("%lld %lld %lld ",&nn,&mm,&kk);
12 for(i=0 ; i<nn ; i++)
13 scanf("%lld",aa+i);
14 std::sort(aa,aa+nn);
15 printf("Case #%d:\n",cnt++);
16 for(res=mm,i=0 ; i<nn ; i++ )
17 if(aa[i]<=mm) res=aa[i];
18 else break;
19
20 while(i!=0&&i<nn){
21 int j=i;
22 while(j<nn&&res+kk>=aa[j]) j++;
23 if(j==i)break;
24 else res=aa[j-1];
25 if(kk>0) kk--;
26 i=j;
27 }
28 if(res>=aa[nn-1])
29 puts("why am I so diao?");
30 else
31 puts("madan!");
32 }
33 return 0;
34 }找连续数
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 801 Accepted Submission(s):
294
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
Source 2015年百度之星程序设计大赛 - 初赛(1) 思路： 对于一个集合{a1,a2,a3,a4, .... an }map，我们如何知道里面的数是连续，其实只需要满足这样的特征： 集合中最大值 和集合中最小值的差+1 = 集合中元素的个数 。 我们就可以去说，这个集合是连续的。
1 #include<iostream>
2 #include<map>
3 #include<stdio.h>
4 #include<string.h>
5
6 const int maxn= 10005;
7 int n,m,k;
8 int aa[maxn];
9 int res[1005];
10 int main()
11 {
12 int T,cas=1;
13 int max_a ,min_a ;
14 std::map<int ,bool>tmp ;
15 while(~scanf("%d%d",&n,&m)){
16
17 for(int i=0;i<n;i++)
18 scanf("%d",aa+i);
19 //采用离线的方法
20 memset(res, 0,sizeof(res));
21 for(int i=0;i<n ;i++){
22 max_a = aa[i];
23 min_a = aa[i];
24 tmp.clear();
25 for(int j=i ; j<n&&j<1000+i;j++){
26 if(max_a < aa[j] ) max_a = aa[j];
27 if(min_a > aa[j] ) min_a = aa[j];
28 tmp[aa[j]]=true;
29 if(max_a -min_a==j-i&&max_a -min_a+1==tmp.size())
30 res[max_a -min_a+1]++;
31 }
32 }
33 printf("Case #%d:\n",cas++);
34 for(int i=0; i<m;i++)
35 {
36 scanf("%d",&k);
37 printf("%d\n",res[k]);
38 }
39 }
40 return 0;
41 }很危险的滑了过去...920ms
序列变换
Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 581 Accepted Submission(s):
287
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
Source 2015年百度之星程序设计大赛 - 初赛(1)
题意： 其实求的最小代价res，就是对于任意集合A{},使得里面的元素+—res，成为一个单调数列.... 刚开始搞不懂题目究竟是什么意思！ ╮(╯▽╰)╭ 简单的二分 代码：
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<math.h>
4 #define maxn 100005
5 int aa[maxn];
6
7 bool solve(int var ,int n){
8 //对于a[i]+|- var 变成单调数列
9 int tmp = var +aa[n-1];
10 for(int i=n-2; i>=0 ;i-- ){
11 if (abs(tmp - 1 - aa[i]) <= var)
12 tmp = tmp - 1;
13 else if (tmp - 1 >= aa[i])
14 tmp = aa[i] + var;
15 else
16 return 0;
17 }
18 return 1;
19 }
20 int main()
21 {
22 int t,n;
23 scanf("%d",&t);
24 for(int cas=1;cas<=t;cas++){
25 scanf("%d",&n);
26 for(int i=0; i<n ;i++)
27 scanf("%d",aa+i);
28
29 printf("Case #%d:\n",cas);
30 int mid ,ri=1000005,le=0;
31 while(le<ri){
32 mid = le +((ri-le)>>1L);
33 //判断是否为单调数列
34 if(solve(mid,n))
35 ri=mid ;
36 else
37 le = mid+1;
38 }
39 printf("%d\n",le);
40 }
41 return 0;
42 }KPI
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 639 Accepted Submission(s):
267
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
Source 2015年百度之星程序设计大赛 - 初赛(1) 这道题刚开始用堆来处理，发现总是出错！ 后来在看了下别人的解题报告，发现了一种新的思路，运用两个set集合，利用红黑树的特性。分段来进行排序 但是要总是保持这两颗树的元素个数之差保持在小于2的状态。而且要满足上层集合的个数始终大于或者等于下层集合个数。
1 #include<stdio.h>
2 #include<string.h>
3 #include<set>
4 #include<queue>
5 #include<stdlib.h>
6 #include<iostream>
7
8 int tt ,x,tmp,cnt=1;
9 char cmd[8];
10 int main( void )
11 {
12 std::set<int> low,hig;
13
14 while(scanf("%d",&tt)!=EOF){
15 std::queue<int>aa;
16 printf("Case #%d:\n",cnt++);
17 low.clear();
18 hig.clear();
19
20 while(tt--){
21 scanf("%s",cmd);
22 if(cmd[0]=='i'){
23
24 scanf("%d",&x);
25 aa.push(x);
26 if(hig.empty()|| x > *hig.begin())
27 hig.insert(x);
28 else
29 low.insert(x);
30
31 }
32 else if(cmd[0]=='o'){
33
34 tmp=aa.front();
35 aa.pop();
36 if(low.count(tmp))
37 low.erase(tmp);
38 else
39 hig.erase(tmp);
40
41 }else if(cmd[0]=='q')
42 printf("%d\n",*hig.begin());
43
44 if(low.size()+1<hig.size()){
45 low.insert(*hig.begin());
46 hig.erase(*hig.begin());
47 }
48 else if(low.size()>hig.size()){
49 hig.insert(*low.rbegin());
50 low.erase(*low.rbegin());
51 }
52 }
53 }
54 return 0;
55 }方法二 利用线段树处理，类似于一个单点更新和离散化处理...
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #include<queue>
5 #include<iostream>
6 #include<algorithm>
7
8
9 using namespace std;
10 const int maxn=10005;
11
12 int Hash[maxn],sum[maxn<<2];
13 int cnt;
14
15 typedef struct node{
16
17 int var ;
18 char cmd[6];
19
20 }Node;
21
22 void Push(int pos ){
23 sum[pos]=sum[pos<<1]+sum[pos<<1|1];
24 }
25
26 void Build(int st ,int en ,int pos){
27 if(st==en){
28 sum[st]=0;
29 return ;
30 }
31 int mid=st+((en-st)>>1L);
32 Build(st,mid,pos<<1);
33 Build(mid+1,en,pos<<1|1);
34 Push(pos);
35 }
36
37 void Update(int st ,int en ,int value ,int pos ,int find_p){
38
39 if(st==en) { //单点更新，说明增加或者减少一个点
40 sum[pos]=value;
41 return ;
42 }
43 int mid =st+((en-st)>>1L);
44 if(find_p<=mid)
45 Update(st , mid , value , pos<<1 , find_p);
46 else
47 Update(mid+1 , en , value , pos<<1|1 ,find_p);
48 Push(pos);
49 }
50
51 int query(int st ,int en ,int pos ,int num){
52 if(st==en)
53 return st;
54 int mid = st + ((en -st)>>1L);
55 if(sum[pos<<1]>=num)
56 return query(st,mid,pos<<1 , num);
57 else
58 return query(mid+1,en,pos<<1|1,num-sum[pos<<1]); //相对起点为0
59 }
60
61 //学习了某位大牛的STL用法
62 int HASH(int x ){
63
64 return lower_bound(Hash ,Hash+cnt,x)-Hash;
65 }
66
67 Node tem[maxn];
68 int main()
69 {
70 int nn,cas=1,pos;
71 while(~scanf("%d",&nn)){
72 queue<int>aa;
73 cnt=0;
74 memset(sum,0,sizeof(sum));
75 printf("Case #%d:\n",cas++);
76
77 for(int i=0;i<nn;i++){
78 scanf("%s",tem[i].cmd);
79 if(tem[i].cmd[0]=='i'){
80 scanf("%d",&tem[i].var);
81 Hash[cnt++]=tem[i].var;
82 }
83 }
84 sort(Hash,Hash+cnt);
85
86 for(int i=0;i<nn;i++){
87 if(tem[i].cmd[0]=='i')
88 {
89 pos = HASH(tem[i].var);
90 Update(1,cnt+1,1,1,pos+1);
91 aa.push(pos);
92
93 }
94 else if(tem[i].cmd[0]=='o')
95 {
96 pos =aa.front();
97 aa.pop();
98 Update(1,cnt+1,0,1,pos+1);
99
100 }
101 else{
102
103 pos = sum[1]/2 +1;
104 pos=query(1,cnt+1,1,pos);
105 printf("%d\n",Hash[pos-1]);
106
107 }
108 }
109 }
110 return 0;
111 }速度499ms飘然而过！
编程是一种快乐，享受代码带给我的乐趣！！！
