2012百度之星資格賽試題與AC代碼合集

本文轉載自查看原文 2012-06-01 13:53 2384 百度之星資格賽 AC代碼

39d92648852458fb770b5616.html

2012百度之星資格賽試題與AC代碼

A:百度計算器的加法

時間限制: 1000ms 內存限制: 10000kB

描述
百度框計算中提供了計算器這個功能，模擬計算器中的復雜功能，我們最先需要解決的就是實現加法模塊。今天就給你個機會，和百度計算器一樣，計算一下十以內的加法吧。

輸入
僅有一組數據，包含兩個正整數，分別為a, b(0 <= a, b <= 10)

輸出
一個正整數，暨輸入a, b后對應的a+b的計算結果

樣例輸入
5 2

樣例輸出
7

 1 #include <stdio.h>
 2 
 3 #include <stdlib.h>
 4 
 5 /*
 6 
 7 author tilltheendwjx
 8 
 9 blog   http://blog.csdn.net/wjh200821或者http://www.cnblogs.com/tilltheendwjx/
10 
11 */
12 
13 int main()
14 
15 {
16 
17     int a,b;
18 
19     scanf("%d%d",&a,&b);
20 
21     printf("%d",a+b);
22 
23    //system("pause");
24 
25     return 0;  
26 
27 }

B:小諾愛USB設備

時間限制: 1000ms 內存限制: 65536kB

描述
在百度工作的小諾是一個USB設備迷，在他桌上有一堆的USB設備——USB鼠標、USB小音箱、USB按摩器……但是，公司配給小諾的ThinkPad X系列的電腦只有一個能用的USB接口。不過還好，小諾有一堆的USB Hub，可以把一個可用的USB接口變成多個USB接口。但是，小諾很難確定這些USB Hub能否滿足他他眾多的USB設備的需求。

輸入
輸入首行包括一個整數N（1 ≤ N ≤ 20），表示測試數據組數。接下去的N行，每行包括一組測試數據。每組測試數據行以一個整數K開頭（1 ≤ K ≤ 10），表示這組測試數據提供的USB Hub的數量；緊接着，在同一行，有K個整數（每兩個整數之間由一個空格分隔開），{M1，M2…Mi…MK}（2 ≤ Mi ≤ 10），每個整數表示了這個USB Hub能將一個USB接口數變成的多個USB接口的數量。

輸出
針對每組測試數據輸出一個結果，表示小諾用這組提供的USB Hub后，能最多使用的USB設備的數量。每個輸出占一行。

樣例輸入
3
2 2 2
3 3 2 4
6 2 2 2 3 4 5

樣例輸出
3
7
13

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 /*
 6 
 7 author tilltheendwjx
 8 
 9 blog   http://blog.csdn.net/wjh200821或者http://www.cnblogs.com/tilltheendwjx/
10 
11 */
12 
13 int main()
14 
15 {
16 
17     int n;
18 
19     cin>>n;
20 
21     int k;
22 
23     int *a;
24 
25     int *b=new int[n];
26 
27     for(int i=0;i<n;i++)
28 
29     {
30 
31        cin>>k;
32 
33        a=new int[k];
34 
35        int sum=0;
36 
37        for(int j=0;j<k;j++)
38 
39        {
40 
41                cin>>a[j];
42 
43                sum+=a[j];
44 
45        }
46 
47        b[i]=sum+1-k;
48 
49     }
50 
51     for(int i=0;i<n;i++)
52 
53     {
54 
55       
56 
57        cout<<b[i]<<endl;
58 
59     }
60 
61     delete a;
62 
63    //system("pause");
64 
65    return 0;   
66 
67 }

C:易手機的套餐

時間限制: 1000ms 內存限制: 10000kB

描述
裝載百度易平台的易手機已經上市，為了更好的為大家提供服務。百度與合作的運營商正在討論為易手機用戶推出一款特別的套餐，幫助大家更好的利用易手機。作為這個項目負責人的曉萌調研了大量用戶使用這個套餐后會出現的資費預估，讓我們來看看這個特別的套餐到底會帶來怎樣資費情況吧。

輸入
輸入數據包括十二行，每行包括一個數字（不含金錢符號$），表示曉萌調研的某一用戶使用特別套餐后，一月到十二月消費的資費情況。每行包括的這個數字精確到小數點后兩位。

輸出
輸出僅一行，表示用戶使用該套餐后，針對給出的12個月的資費的均值情況。在分位采用四舍五入進位。輸出以金錢符號$開頭，輸出中不含空格等其它特別字符。

樣例輸入
112.00
249.12
214.12
34.10
223.05
109.20
53.27
102.25
239.18
95.99
95.01
25.75

樣例輸出
$129.42

 1 #include <stdio.h>
 2 
 3 #include <stdlib.h>
 4 
 5 #include <math.h>
 6 
 7 /*
 8 
 9 author tilltheendwjx
10 
11 blog   http://blog.csdn.net/wjh200821或者http://www.cnblogs.com/tilltheendwjx/
12 
13 */
14 
15 int main()
16 
17 {
18 
19    float a[12];
20 
21    float avg=0;
22 
23    int i=0;
24 
25    for(i=0;i<2;i++)
26 
27    {
28 
29       a[i]=0.00;
30 
31    }
32 
33    for(i=0;i<12;i++)
34 
35    {
36 
37       scanf("%f",&a[i]);
38 
39       avg=avg+a[i];
40 
41    }
42 
43    printf("$%.2f",(float)(avg/12));
44 
45    //system("pause");
46 
47    return 0;  
48 
49 }

D:共同狂歡

時間限制: 1000ms 內存限制: 131072kB

描述
百度2005年8月5日上市時，在北京和納斯達克的同學們每一個小時整點時就會通一次電話，對一下表，確認一切相關活動都精確同步。但是要注意，在兩邊的同學位於不同的時區，在夏時制時，兩地時差12小時，因此，每次對表都需要做一下時區轉換。你來幫我們完成這個有點麻煩的工作吧。

輸入
輸入的第一行包括一個整數T（T ≤ 30），表示測試數據的組數；接下去的T行每行包括一個時間，表示兩地中的一個地方同學報出的整點的時間，表示成“H:M”的形式，其中H是小時（0 ≤ H ＜ 24，且當H小於10的時候可以表示成1位或者2位的形式）、M是分鍾（0 ≤ M ＜ 60，且當M小於10的時候可以表示成1位或者2位）。

輸出
每個測試數據輸出一行，當是整點對時時，輸出時區轉換后的小時結果；當不是整點對時時，輸出0。

樣例輸入
4
12:00
01:01
3:00
00:00

樣例輸出
24
0
15
12

 1 #include <stdio.h>
 2 
 3 #include <stdlib.h>
 4 
 5 /*
 6 
 7 author tilltheendwjx
 8 
 9 blog   http://blog.csdn.net/wjh200821或者http://www.cnblogs.com/tilltheendwjx/
10 
11 */
12 
13 int main()
14 
15 {
16 
17    int n;
18 
19    int *a;
20 
21    int *b;
22 
23    int *c;
24 
25    int i=0;
26 
27    scanf("%d",&n);
28 
29    a=(int *)malloc(sizeof(int)*n);
30 
31    b=(int *)malloc(sizeof(int)*n);
32 
33    c=(int *)malloc(sizeof(int)*n);
34 
35    for(i=0;i<n;i++)
36 
37    {
38 
39        scanf("%d:%d",&a[i],&b[i]);
40 
41        if(b[i]!=0)
42 
43        { c[i]=0;}
44 
45        else
46 
47        {
48 
49            if((a[i]+12)==24)
50 
51               c[i]=24;
52 
53            else
54 
55               c[i]=(a[i]+12)%24;
56 
57        }
58 
59        
60 
61    }
62 
63    for(i=0;i<n;i++)
64 
65    {
66 
67        printf("%d\n",c[i]);
68 
69        
70 
71    }
72 
73    free(a);
74 
75    free(b);
76 
77    free(c);
78 
79    //system("pause");
80 
81    return 0;  
82 
83 }

E:C++ 與Java

時間限制: 2000ms 內存限制: 65536kB

描述
在百度之星的貼吧里面，Java的愛好者和C++的愛好者總是能為這兩種語言哪個更好爭論上幾個小時。Java的愛好者會說他們的程序更加整潔且不易出錯。C++的愛好者則會嘲笑Java程序很慢而且代碼很長。
另一個Java和C++愛好者不能達成一致的爭論點就是命名問題。在Java中一個多個單詞構成的變量名應該按照如下格式命名：第一個單詞的開頭用小寫字母，其余單詞都以大寫字母開頭，單詞與單詞之間不加分隔符，除單詞的首字母之外的字母一律使用小寫。例如：javaIdentifier, longAndMnemonicIdentifier, name, bAIDU.
與Java不同C++的命名全都使用小寫字母，在單詞和單詞之間使用“_”來作為分隔符。例如：c_identifier, long_and_mnemonic_identifier, name (當名字中只有一個單詞的時候，Java與C++的命名是相同的), b_a_i_d_u.
你的任務就是寫一個程序能讓C++和Java程序相互轉化。當然轉換完成的程序中的變量名也要符合其語言的命名規則，否則的話是不會有人喜歡你的轉換器的。
首先你要做的就是寫一個變量名轉換器。給出一個變量名，你要先檢測是Java的還是C++的，然后把它轉化為另一種命名格式。如果兩種都不是，那么你的程序就要報錯。轉換過程必須保持原有的單詞順序，只能改變字母的大小寫和增加或刪除下划線。

輸入
輸入有且僅有一行，是一個變量名，其中包含字母和下划線，長度不超過100。

輸出
如果輸入的是Java變量名那么輸出它對應的C++形式。如果是C++的則輸出對應的Java的形式。如果兩種都不是就輸出“Error!”。

樣例輸入
輸入樣例1：
long_and_mnemonic_identifier
輸入樣例2：
anotherExample
輸入樣例3：
i
輸入樣例4：
bad_Style

樣例輸出
輸出樣例1：
longAndMnemonicIdentifier
輸出樣例2：
another_example
輸出樣例3：
i
輸出樣例4：
Error!

  1 #include <stdio.h>
  2 
  3 #include <stdlib.h>
  4 
  5 #include <math.h>
  6 
  7 #include <string.h>
  8 
  9 #include <ctype.h>
 10 
 11 /*
 12 
 13 author tilltheendwjx
 14 
 15 blog   http://blog.csdn.net/wjh200821或者http://www.cnblogs.com/tilltheendwjx/
 16 
 17 */
 18 
 19 int main()
 20 
 21 {
 22 
 23    char a[100];
 24 
 25    char b[100];
 26 
 27    int i=0;
 28 
 29    int j=0;
 30 
 31    int flag=0;
 32 
 33    int javature=0;
 34 
 35    int cture=0;
 36 
 37    scanf("%s",a);
 38 
 39    for(i=0;i<100;i++)
 40 
 41    {
 42 
 43        if(a[i]=='\0')
 44 
 45          break;
 46 
 47        if(a[i]=='_')
 48 
 49        {
 50 
 51           if((islower(a[i+1])==0)||i==0||a[i+1]=='\0')
 52 
 53              flag=1;
 54 
 55           else
 56 
 57              cture=1;
 58 
 59           i++;
 60 
 61           b[j]=(char)toupper(a[i]);
 62 
 63           j++;
 64 
 65        }
 66 
 67        else if((isupper(a[i])!=0))
 68 
 69        {
 70 
 71           if((a[i-1]=='_')||i==0)
 72 
 73             flag=1;
 74 
 75           else
 76 
 77             javature=1;
 78 
 79           b[j]='_';
 80 
 81           j++;
 82 
 83           b[j]=(char)tolower(a[i]);
 84 
 85           j++;
 86 
 87        }
 88 
 89        else
 90 
 91        {
 92 
 93            b[j]=a[i];
 94 
 95            j++;
 96 
 97        }
 98 
 99         
100 
101    }
102 
103    b[j]='\0';
104 
105    if(flag==0)
106 
107    {
108 
109       if(javature==1&&cture==1)
110 
111          printf("Error!");
112 
113       else
114 
115          printf("%s",b);
116 
117    }
118 
119    else
120 
121        printf("Error!");
122 
123    //system("pause");
124 
125    return 0;  
126 
127 }

F:百科蝌蚪團

時間限制: 1000ms 內存限制: 65536kB

描述
百度百科有一支神奇的隊伍，他們叫自己“百科蝌蚪團”。為了更好的讓蝌蚪團的成員們安排工作，百度百科的運營團隊定出了一個24小時制的時間表。例如：
1. 每個蝌蚪團成員工作時長相同；
2. 必須安排蝌蚪團成員在他們方便的時間段工作；
3. 蝌蚪團成員安排時間最小安排時間節點（開始工作或停止工作）為半小時，比如04：00或04：30，而不是04：15；
4. 蝌蚪團成員一天在百度百科工作的時間是有上限的，他們會根據自己的情況給出上限。
5. 在特定時間段內必須有一定數量的蝌蚪團成員工作，以保證百度百科不斷的進步
請幫運營團隊計算一下，能保持24小時穩定在崗的蝌蚪團最少成員的數量。如果有2個蝌蚪團成員工作結束，同時另2個蝌蚪團成員開始工作，這段時間都算有2各成員穩定在崗。

輸入
輸入有多組，每組測試數據以一個整數N開頭（1 ≤ N ≤ 50），表示蝌蚪團的成員數。緊接着，我們會有N個數據塊，每一個數據塊對應了一名蝌蚪團成員的日程情況。
每個數據塊以兩個整數開始，分別為K（1 ≤ K ≤ 50）和M（1 ≤ M ≤ 1440），用空格隔開。K表示這個數據塊對應蝌蚪團成員方便的時間段的數量，M表示這個成員願意每天在百度百科工作的最長分鍾數。接下去的K行中，每行包括兩個時間，分別表示成“HH：MM”的格式，以空格分隔，分別對應了該蝌蚪團成員一個方便的時間段的開始時間、結束時間；例如09：00 10：00表明他在早上九點到十點的時間段是方便的，可以在百度百科工作。如果兩個時間相同，則說明這個他全天都是方便的。
最后一組數據的N為0，表示輸入結束。

輸出
對於每組數據，輸出為一個整數，占一行。表示能保持24小時穩定在崗的蝌蚪團最少成員的數量。

樣例輸入
5
1 720
18:00 12:00
1 1080
00:00 23:00
1 1080
00:00 20:00
1 1050
06:00 00:00
1 360
18:00 00:00
3
1 540
00:00 00:00
3 480
08:00 10:00
09:00 12:00
13:00 19:00
1 420
17:00 00:00
3
1 1440
00:00 00:00
1 720
00:00 12:15
1 720
12:05 00:15
0

樣例輸出
2
1
1

  1  #include<stdio.h>
  2 
  3  #include<memory.h>
  4 
  5  #include<stdlib.h>
  6 
  7  #define maxn 102
  8 
  9   int d[maxn],g[maxn][maxn],f[maxn][maxn],pre[maxn],map[maxn][maxn],sum[maxn],current[maxn];
 10 
 11   int n,m,num,mm;
 12 
 13   struct node
 14 
 15  {
 16 
 17      int x,y;
 18 
 19  }seg[1000],time[1000];
 20 
 21   #define oo 0xfffffff
 22 
 23   int cmp(const void *a,const void *b)
 24 
 25  {
 26 
 27      struct node *va=(struct node*)a;
 28 
 29      struct node *vb=(struct node*)b;
 30 
 31      return va->x-vb->x;
 32 
 33  }
 34 
 35   void rev_bfs(int t)
 36 
 37  {
 38 
 39      int queue[maxn],flag[maxn];
 40 
 41      int head,tail,i;
 42 
 43      memset(sum,0,sizeof(sum));
 44 
 45      for (i=0;i<=n+49;i++)
 46 
 47      {
 48 
 49          d[i]=n+49;
 50 
 51          sum[n+49]++;
 52 
 53      }
 54 
 55      sum[n+49]--;
 56 
 57      sum[0]++;
 58 
 59      d[t]=0;
 60 
 61      queue[1]=t;
 62 
 63      flag[t]=1;
 64 
 65      head=1;tail=1;
 66 
 67      memset(flag,0,sizeof(flag));
 68 
 69      while (head<=tail)
 70 
 71      {
 72 
 73          for (i=0;i<=n+49;i++)
 74 
 75              if (flag[i]==0&&g[i][queue[head]]>0)
 76 
 77              {
 78 
 79                  queue[++tail]=i;
 80 
 81                  d[i]=d[queue[head]]+1;
 82 
 83                  sum[n+49]--;
 84 
 85                  sum[d[i]]++;
 86 
 87                  flag[i]=1;
 88 
 89              }
 90 
 91          head++;
 92 
 93      }
 94 
 95  }
 96 
 97   void augment(int s,int t)
 98 
 99  {
100 
101      int i,min;
102 
103      min=oo;
104 
105      for (i=t;i!=s;i=pre[i])
106 
107           if (g[pre[i]][i]<min)
108 
109              min=g[pre[i]][i];
110 
111      for (i=t;i!=s;i=pre[i])
112 
113      {
114 
115          g[pre[i]][i]-=min;;
116 
117          g[i][pre[i]]+=min;
118 
119          f[pre[i]][i]+=min;
120 
121          f[i][pre[i]]-=min;
122 
123      }
124 
125  }
126 
127   int retreat(int *u,int s)
128 
129  {
130 
131      int v,min;
132 
133      min=n+49;
134 
135      for (v=0;v<=n+49;v++)
136 
137          if (g[*u][v]>0&&d[v]<min)
138 
139              min=d[v];
140 
141      sum[d[*u]]--;
142 
143      if ((sum[d[*u]])==0&&d[*u]<=n+49) return 0;
144 
145      d[*u]=min+1;
146 
147      sum[d[*u]]++;
148 
149      current[*u]=0;
150 
151      if (*u!=s) *u=pre[*u];
152 
153      return 1;
154 
155  }
156 
157   void ISAP(int s,int t)
158 
159  {
160 
161      int u,v;
162 
163      rev_bfs(t);
164 
165      u=s;
166 
167      while (d[s]<n+50)
168 
169      {
170 
171          for (v=current[u];v<=n+49;v++)                                                                           
172 
173              if (g[u][v]>0&&d[u]==d[v]+1)
174 
175                  break;
176 
177          if (v<=n+49)
178 
179          {
180 
181              current[u]=v;
182 
183              pre[v]=u;
184 
185              u=v;
186 
187              if (u==t)
188 
189              {
190 
191                  augment(s,t);
192 
193                  u=s;
194 
195              }
196 
197          }
198 
199          else if (retreat(&u,s)==0) return;
200 
201      }
202 
203  }
204 
205  void init()
206 
207  {
208 
209      int i,j,a,b,c,d,min,t,k,ans,max,st,en,temp;
210 
211      while (scanf("%d",&n)!=EOF&&n)
212 
213      {
214 
215          memset(map,0,sizeof(map));;
216 
217          for (i=1;i<=n;i++)
218 
219          {
220 
221              scanf("%d%d",&m,&t);
222 
223              map[48][i+48]=t/30;
224 
225              num=0;
226 
227              mm=0;
228 
229              for (j=1;j<=m;j++)
230 
231              {
232 
233                  scanf("%d:%d %d:%d",&a,&b,&c,&d);
234 
235                  if (a==c&&b==d)
236 
237                  {
238 
239                      for (k=0;k<48;k++)
240 
241                          map[i+48][k]=1;
242 
243                      continue;
244 
245                  }
246 
247                  if (c==0&&d==0)
248 
249                  {
250 
251                      num++;
252 
253                      seg[num].x=a*60+b;
254 
255                      seg[num].y=1440;
256 
257                  }
258 
259                  else if (a*60+b>c*60+d)
260 
261                  {
262 
263                      num++;
264 
265                      seg[num].x=a*60+b;
266 
267                      seg[num].y=1440;
268 
269                      num++;
270 
271                      seg[num].x=0;
272 
273                      seg[num].y=c*60+d;
274 
275                  }
276 
277                  else
278 
279                  {
280 
281                      num++;
282 
283                      seg[num].x=a*60+b;
284 
285                      seg[num].y=c*60+d;
286 
287                  }
288 
289              }
290 
291              if (num==0) continue;
292 
293              qsort(seg+1,num,sizeof(seg[1]),cmp);
294 
295              st=seg[1].x;en=seg[1].y;
296 
297              seg[num+1].x=1500;seg[num+1].y=1600;
298 
299              for (j=2;j<=num+1;j++)
300 
301              {
302 
303                  a=seg[j].x;
304 
305                  b=seg[j].y;
306 
307                  if (st<=a&&a<=en&&en<b)
308 
309                      en=b;
310 
311                  else if (a>en)
312 
313                  {
314 
315                      mm++;
316 
317                      time[mm].x=st;
318 
319                      time[mm].y=en;
320 
321                      st=a;
322 
323                      en=b;
324 
325                  }
326 
327              }
328 
329              for (j=1;j<=mm;j++)
330 
331              {
332 
333                  a=time[j].x/60;
334 
335                  b=time[j].x-60*a;
336 
337                  c=time[j].y/60;
338 
339                  d=time[j].y-60*c;
340 
341                  if (a==c)
342 
343                  {
344 
345                      if (b==0&&d>=30)
346 
347                          map[i+48][a*2]=1;
348 
349                  }
350 
351                  else
352 
353                  {
354 
355                      if (b>0&&b<=30) b=30;
356 
357                      if (b>30)
358 
359                      {
360 
361                          a++;
362 
363                          b=0;
364 
365                      }
366 
367                      if (d<30) d=0;
368 
369                      if (d>30) d=30;
370 
371                      while (a!=c||b!=d)
372 
373                      {
374 
375                          map[i+48][a*2+b/30]=1;
376 
377                          b+=30;
378 
379                          if (b==60)
380 
381                          {
382 
383                              a++;
384 
385                              b=0;
386 
387                          }
388 
389                      }
390 
391                  }
392 
393              }
394 
395          }
396 
397          max=oo;
398 
399          for (j=0;j<48;j++)
400 
401          {
402 
403              temp=0;
404 
405              for (k=49;k<n+49;k++)
406 
407                  if (map[k][j]>0) temp++;
408 
409              if (temp<max)
410 
411                  max=temp;
412 
413          }
414 
415          ans=0;
416 
417          for (j=1;j<=max;j++)
418 
419          {
420 
421              memset(g,0,sizeof(g));
422 
423              memset(f,0,sizeof(f));
424 
425              memset(current,0,sizeof(current));
426 
427              for (i=0;i<=49+n;i++)
428 
429                  for (k=0;k<=49+n;k++)
430 
431                      g[i][k]=map[i][k];
432 
433              for (i=0;i<48;i++)
434 
435                  g[i][n+49]=j;
436 
437              ISAP(48,n+49);
438 
439              min=oo;
440 
441              for (i=0;i<48;i++)
442 
443                  if (f[i][n+49]<min)
444 
445                      min=f[i][n+49];
446 
447              if (min>ans) ans=min;
448 
449          }
450 
451          printf("%d\n",ans);
452 
453      }
454 
455  }
456 
457  int main()
458 
459  {
460 
461      init();
462 
463      //system("pause");
464 
465      return 0;
466 
467  }

G:聊天就是Repeat

時間限制: 1000ms 內存限制: 65536kB

描述
百度Hi作為百度旗下的即時聊天工具，在百度公司內部很是流行。要實現這樣的一個聊天工具，最重要的問題就是要能保證我發出的內容能原封不動的在接收同學那里顯示出來。今天，就給你一個機會，讓你模擬一下百度Hi傳遞信息的過程，把我發給Robin的聊天內容原封不動的輸出出來。

輸入
輸入的聊天內容數據有多組，每組數據占一行。

輸出
與輸入聊天內容完全相同的內容。請注意每組數據中的空格也要原封不動的被傳過去噢~

樣例輸入
Hello Robin
今天下午去五福頒獎，具體時間是2012年8月3日 15:40噢~

樣例輸出
Hello Robin
今天下午去五福頒獎，具體時間是2012年8月3日 15:40噢~

 1 #include <iostream>
 2 
 3 #include <string>
 4 
 5 /*
 6 
 7 author tilltheendwjx
 8 
 9 blog   http://blog.csdn.net/wjh200821或者http://www.cnblogs.com/tilltheendwjx/
10 
11 */
12 
13 using namespace std;
14 
15 int main()
16 
17 {
18 
19    
20 
21     while(1)
22 
23     {
24 
25           string str;
26 
27           getline(cin,str);
28 
29           if(str.length()<=0)
30 
31             break;
32 
33           cout<<str<<endl;
34 
35     }
36 
37    //system("pause");
38 
39    return 0;   
40 
41 }

H:用戶請求中的品牌

時間限制: 1000ms 內存限制: 65536kB

描述
餡餅同學是一個在百度工作，做用戶請求（query）分析的同學，他在用戶請求中經常會遇到一些很奇葩的詞匯。在比方說“johnsonjohnson”、“duckduck”，這些詞匯雖然看起來是一些詞匯的單純重復，但是往往都是一些特殊品牌的詞匯，不能被拆分開。為了偵測出這種詞的存在，你今天需要完成我給出的這個任務——“找出用戶請求中循環節最多的子串”。

輸入
輸入數據包括多組，每組為一個全部由小寫字母組成的不含空格的用戶請求（字符串），占一行。用戶請求的長度不大於100,000。
最后一行輸入為#，作為結束的標志。

輸出
對於每組輸入，先輸出這個組的編號（第n組就是輸出“Case n:”）；然后輸出這組用戶請求中循環節最多的子串。如果一個用戶請求中有兩個循環節數相同的子串，請選擇那個字典序最小的。

樣例輸入
ilovejohnsonjohnsonverymuch
duckduckgo
aaabbbcccisagoodcompany
#

樣例輸出
Case 1: johnsonjohnson
Case 2: duckduck
Case 3: aaa

  1 #include <stdio.h>
  2 
  3 #include<cstring>
  4 
  5 #include<math.h>
  6 
  7 #include<string.h>
  8 
  9 #define MAXN  100002
 10 
 11 int wa[MAXN], wb[MAXN], wv[MAXN], wd[MAXN], Height[MAXN], sa[MAXN], rank[MAXN];
 12 
 13 int n;
 14 
 15 inline bool IsEqual(int *r, int a, int b, int l)
 16 
 17 {
 18 
 19     return (r[a] == r[b] && r[a + l] == r[b + l]);
 20 
 21 }
 22 
 23 void da(int *r, int m = 27)
 24 
 25 {
 26 
 27     int i, j, p, *x = wa, *y = wb, *t;
 28 
 29     memset(wd, 0, sizeof(wd));
 30 
 31     for (i = 0; i < n; i++) wd[x[i] = r[i]]++; x[n] = y[n] = 0;
 32 
 33     for (i = 1; i < m; i++) wd[i] += wd[i - 1];
 34 
 35     for (i = n - 1; i >= 0; i--) sa[--wd[x[i]]] = i;
 36 
 37     for (p = 1, j = 1; p <= n; m = p, j *= 2)
 38 
 39     {
 40 
 41         for(p = 0, i = n - j; i < n; i++) y[p++] = i;
 42 
 43         for(i = 0; i < n; i++)if(sa[i] >= j)y[p++] = sa[i] - j;
 44 
 45         for(i = 0; i < n; i++) wv[i] = x[y[i]];
 46 
 47         memset(wd, 0, sizeof(wd));
 48 
 49         for(i = 0; i < n; i++) wd[wv[i]]++;
 50 
 51         for(i = 1; i < m; i++) wd[i] += wd[i - 1];
 52 
 53         for(i = n - 1; i >= 0; i--) sa[--wd[wv[i]]] = y[i];
 54 
 55         for(t = x, x = y, y = t, i = 1, p = 2,x[sa[0]] = 1; i < n; i++)
 56 
 57             x[sa[i]] = IsEqual(y, sa[i-1], sa[i], j) ? p - 1 : p++;
 58 
 59     }
 60 
 61 }
 62 
 63 void CalHeight(int *r)
 64 
 65 {
 66 
 67     int i, j, k;
 68 
 69     for (i = 0; i < n; i++)rank[sa[i]] = i;
 70 
 71     for (i = 0, Height[0] = k = 0; i < n; Height[rank[i++]] = k)
 72 
 73         for (k?k--:0, j=(rank[i]>0)?sa[rank[i]-1]:0; rank[i]>0&&r[i+k]==r[j+k]; k++);
 74 
 75 }
 76 
 77 int ffmin[MAXN][20];
 78 
 79 void setf()
 80 
 81 {
 82 
 83  int i,j;
 84 
 85  memset(ffmin,0,sizeof(ffmin));
 86 
 87  for(i=1;i<=n;i++){
 88 
 89   ffmin[i][0]=Height[i];
 90 
 91  }
 92 
 93  for(j=1;j<=(int)(log((double)(n+1))/log(2.0));j++)
 94 
 95   for(i=1;i+(1<<j)-1<=n;i++)
 96 
 97    ffmin[i][j]=ffmin[i][j-1]<ffmin[i+(1<<(j-1))][j-1]?ffmin[i][j-1]:ffmin[i+(1<<(j-1))][j-1];
 98 
 99 }
100 
101 int findmin(int l,int r)
102 
103 {
104 
105  int k=(int)(log(1.0*(r-l+1))/log(2.0));
106 
107  return ffmin[l][k]<ffmin[r-(1<<k)+1][k]?ffmin[l][k]:ffmin[r-(1<<k)+1][k];
108 
109 }
110 
111 char str[MAXN];
112 
113 int r[MAXN];
114 
115 int sp;
116 
117 int tsp;
118 
119 int maxl;
120 
121 int main()
122 
123 {
124 
125     int cases=0,i;
126 
127     while(scanf("%s",&str)!=EOF&&str[0]!='#')
128 
129     {
130 
131       cases++;
132 
133       printf("Case %d: ",cases);
134 
135       n=strlen(str);
136 
137       memset(r, 0, sizeof(r));
138 
139       maxl=1;
140 
141       for (i = 0; i < n; i++)
142 
143        r[i] = str[i] - 'a' + 1;
144 
145        da(r);
146 
147        CalHeight(r);
148 
149        setf();
150 
151        int l,max=1;
152 
153        sp=0;
154 
155        for(l=1;l<=n/2;l++){
156 
157        int cur=0;
158 
159        while(cur+l<n){
160 
161        if(r[cur]==r[cur+l]){
162 
163        int s,e;
164 
165        int k,lcp;
166 
167        s=rank[cur];
168 
169        e=rank[cur+l];
170 
171        if(s>e){
172 
173         s^=e;
174 
175         e^=s;
176 
177         s^=e;
178 
179        }
180 
181           s++;
182 
183           lcp=findmin(s,e);
184 
185        tsp=cur;
186 
187        int ss=0;
188 
189                     for (int p=cur - 1; p>= 0 && p > (cur-l) && r[p] == r[p + l];p--)
190 
191            if(++ss == (l-(lcp%l)))
192 
193             tsp= p;
194 
195            else if(rank[tsp] > rank[p])
196 
197             tsp= p;
198 
199        k=(lcp+ss)/l+1;
200 
201        if(k>max){
202 
203        max=k;
204 
205        maxl=l;
206 
207        sp=tsp;
208 
209        }
210 
211        else if(k==max&&rank[tsp]<rank[sp]){
212 
213         sp=tsp;
214 
215         maxl=l;
216 
217        }
218 
219        }
220 
221        cur+=l;
222 
223       }
224 
225       }
226 
227       if(max>1){
228 
229         for(i=sp;i<sp+max*maxl;i++)
230 
231          printf("%c",str[i]);
232 
233         printf("\n");
234 
235       }
236 
237       else{
238 
239        char c='z';
240 
241       for(i=0;i<n;i++)
242 
243        if(str[i]<c)
244 
245        c=str[i];
246 
247       printf("%c\n",c);
248 
249       }
250 
251      }
252 
253      return 0;
254 
255 }

I:地圖的省錢計划

時間限制: 1000ms 內存限制: 65536kB

描述
百度地圖有自己的一套坐標系（你可以把它看作一個笛卡爾坐標系），在這套坐標系里，一個標准單位為1km。而在這坐標系上針對地理信息進行標注的數據，大多數時候是通過購買的方式完成的。為了節約數據更新的成本，數據組里的鑫哥想出了一個好主意——自己測數據。
鑫哥按照他的預想開始實驗；在每組試驗中，鑫哥選取了三個已經被准確標注在百度地圖的坐標系里的移動運營商的基站作為信號接收點（這里可以准確的得到信號的接收時間信息）。當信號接收點附近的用戶手機簽到時，三個信號接收點就會先后接收到這個信號，並可以准確的知曉接收到信號的時間（將第一個信號點接收到信號的時間記為0秒時刻）。由此，我們就可以確定用戶手機簽到的位置的在地圖的准確坐標了。
現在已知以下數據：
1.三個信號接收點在百度地圖坐標系中的具體坐標(x1,y1), (x2,y2), (x3,y3)；
2.三個信號點得到用戶發出的信號的時間t1, t2, t3（t1, t2, t3 ≥ 0），單位s; t1, t2, t3至少有一個數為0；
3.信號的轉播速度C，單位m/s；
請幫助鑫哥寫個程序，計算下用戶發出信號的位置在百度地圖坐標系內的坐標（這個點是唯一的）。

輸入
輸入包含多組數據，每組數據格式如下：
C
x1 y1 x2 y2 x3 y3
t1 t2 t3
最后一組數據為0，表示輸入結束。

輸出
針對每組測試數據，請先輸出這個組的編號（第n組就是輸出“Case n:”）；然后換行輸出信號發出點的坐標(x,y) 。x，y應該由空格分隔，並被舍入到小數點后第六位。

樣例輸入
1000
0 1 1 1 2 1
0 0.6 1.6
1000
0 0 0 1 1 0
0.4142135 0 0
1000
0 0 1 0 2 1
0 0.414213562373 1
1000
0 0 0 -1 0 1
0 0 1
1000
0 0 0 1 0 -1
0 1 0
1000
0 0 1 0 -1 0
0 1 0
1000
0 0 -1 0 1 0
0 0 1
100
0 0 0 1 1 0
0 10 10
0

樣例輸出
Case 1:
0.200000 1.000000
Case 2:
1.000000 1.000000
Case 3:
0.000000 1.000000
Case 4:
0.000000 -0.500000
Case 5:
0.000000 -0.500000
Case 6:
-0.500000 0.000000
Case 7:
-0.500000 0.000000
Case 8:
0.000000 0.000000

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cstring>
 4 #include<cstdlib>
 5 #include<cassert>
 6 #include<string>
 7 #include<algorithm>
 8 #include<fstream>
 9 #include<sstream>
10 #include<set>
11 #include<map>
12 #include<vector>
13 #include<queue>
14 #include<deque>
15 #include<complex>
16 #include<numeric>
17 using namespace std;
18 double x[10], y[10], t[10];
19 bool solve(int i, int j, int k)
20 {
21     double x1, y1, x2, y2, t1, t2;
22     x1 = x[j] -x[i];
23     x2 = x[k] -x[i];
24     y1 = y[j] -y[i];
25     y2 = y[k] -y[i];
26     t1 = t[j] -t[i];
27     t2 = t[k] -t[i];
28     
29     double A1 = x1*x1 + y1*y1 - t1*t1;
30     double A2 = x2*x2 + y2*y2 - t2*t2;
31     double A = A1*y2-A2*y1, B = A1*x2-A2*x1, C = A1 * t2 - A2 * t1;
32     double cita = atan2(B, A);
33     double sum = asin(- C/sqrt(A*A+B*B+1e-15));
34     
35     double alpha = sum - cita;
36     double r;
37     if (abs(A1)>abs(A2))
38         r = A1/(t1 + x1 *cos(alpha) + y1 * sin(alpha))/2;
39     else
40         r = A2/(t2 + x2 *cos(alpha) + y2 * sin(alpha))/2;
41     
42     if (r<0)
43     {
44         sum = - sum + 3.141592653579;
45         alpha = sum - cita;
46         if (abs(A1)>abs(A2))
47             r = A1/(t1 + x1 *cos(alpha) + y1 * sin(alpha))/2;
48         else
49             r = A2/(t2 + x2 *cos(alpha) + y2 * sin(alpha))/2;
50     }
51             
52         
53     printf("%.6f %.6f\n", r * cos(alpha) + x[i], r * sin(alpha) + y[i]);
54 }
55 int main()
56 {
57     for (int dd = 1; ; ++ dd)
58     {
59         double c;
60         scanf("%lf", & c);
61         c/=1000;
62         if (abs(c) < 1e-6)
63             break;
64         scanf("%lf %lf %lf %lf %lf %lf", x, y, x+1, y+1, x+2, y+2);
65         scanf("%lf %lf %lf", t, t+1, t+2);
66         printf("Case %d:\n", dd);
67         t[0] *= c;
68         t[1] *= c;
69         t[2] *= c;
70         if (solve(0, 1, 2))
71             continue;        
72     }
73     return 0;
74 }

J:百度的新大廈

時間限制: 1000ms 內存限制: 65536kB

描述
繼百度搜索框大廈之后，百度又於2012年初在深圳奠基了新的百度國際大廈，作為未來百度國際化的橋頭堡。不同於百度在北京的搜索框大廈，新的百度國際大廈是一棟高樓，有非常多的樓層，讓每個樓中的電梯都能到達所有樓層將是一個極為不明智的設計。因此，設計師給出了一個特別的設計——一共大廈有m個電梯，每個電梯只有兩個按鈕，（針對第i個電梯）兩個按鈕分別可以使電梯向上或ui層向下一定di層；百度國際大廈很高，你永遠到不了頂層，也就是說電梯沒有上限，但是，電梯不可以鑽入地下，也就是說是有下限的。我們將每層樓用整數標記，為了體現IT公司的特質，我們以0作為地面這一層的標記。
如果你某天在百度國際大廈的0層，僅可以選擇m個電梯中的一個乘坐（不可以中途換電梯），請你計算，你按電梯中的按鈕n次后（每次兩個按鈕選一個按），可以到達的最低樓層數。

輸入
輸入的第一行包括兩個整數，分別為n和m（1 ≤ n ≤ 1,000,000，1 ≤ m ≤ 2,000），表示按電梯按鈕的次數和大廈中的電梯數量。接下去的m行，每行包括2個由空格分割的數字，分別表示了提供的m個電梯中的某一個的上行按鈕上升一次的層數ui和下行按鈕下降一次的層數di（1 ≤ ui,di ≤ 1000）

輸出
輸出一個正整數，表示選用m個電梯中的一個后，在電梯里按電梯中的按鈕n次后（每次兩個按鈕選一個按），可以到達的最低樓層數。

樣例輸入
10 3
15 4
15 12
7 12

樣例輸出
13

提示
按鈕上的移動樓層數無法改變，比方說從8層向下9層是不可行的

  1 #include <stdio.h>
  2 
  3 #include <stdlib.h>
  4 
  5 #include <math.h>
  6 
  7 /*
  8 
  9 author tilltheendwjx
 10 
 11 blog   http://blog.csdn.net/wjh200821或者http://www.cnblogs.com/tilltheendwjx/
 12 
 13 */
 14 
 15 int main()
 16 
 17 {
 18 
 19     int n,m;
 20 
 21     int *a;
 22 
 23     int *b;
 24 
 25     int i=0;
 26 
 27     int reault=0;
 28 
 29     int j=0;
 30 
 31     int tmp;
 32 
 33     int low=1;
 34 
 35     int high=0;
 36 
 37     scanf("%d%d",&n,&m);
 38 
 39     high=n;
 40 
 41     int mid;
 42 
 43     a=(int *)malloc(sizeof(int)*m);
 44 
 45     b=(int *)malloc(sizeof(int)*m);
 46 
 47     for(i=0;i<m;i++)
 48 
 49     {
 50 
 51         scanf("%d%d",&a[i],&b[i]);
 52 
 53     }
 54 
 55     for(i=0;i<m;i++)
 56 
 57     {
 58 
 59         low=1;
 60 
 61         high=n;
 62 
 63         while((high-low)>2)
 64 
 65         {
 66 
 67            mid=(low+high)/2;
 68 
 69            tmp=a[i]*mid-b[i]*(n-mid);
 70 
 71            if(tmp>0)
 72 
 73             {
 74 
 75                  high=mid;     
 76 
 77             }
 78 
 79             else
 80 
 81             {
 82 
 83                  low=mid+1;
 84 
 85             }           
 86 
 87                       
 88 
 89         }
 90 
 91         for(j=low;j<=high;j++)
 92 
 93         {
 94 
 95                  tmp=a[i]*j-b[i]*(n-j);
 96 
 97                  if(tmp>0)
 98 
 99                  {break;}      
100 
101         }    
102 
103         if(reault==0)
104 
105            reault=tmp;
106 
107         else if(reault>tmp)
108 
109            reault=tmp;
110 
111         else
112 
113            reault=reault;
114 
115           
116 
117     }
118 
119     printf("%d",reault);
120 
121     //system("pause");
122 
123    return 0;  
124 
125 }

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 百度之星資格賽代碼全集： 2016百度之星資格賽題解【2018百度之星資格賽】1001 調查問卷百度之星資格賽 1003 度度熊與邪惡大魔王 DP 完全背包 2017"百度之星"程序設計大賽 - 資格賽（題解報告） 2021百度之星復賽 2018百度之星大賽游記百度之星 2019 決賽游記 2020百度之星程序設計大賽初賽一 2018百度之星開發者大賽－paddlepaddle學習