北大的上机题目Word格式.docx

北大的上机题目Word格式.docx

《北大的上机题目Word格式.docx》由会员分享，可在线阅读，更多相关《北大的上机题目Word格式.docx（13页珍藏版）》请在冰豆网上搜索。

8.for（index=1;

index<

=nb;

index++）

9.book[index]=0;

10.for（index=0;

nr;

index++）{

11.cin>

reader[index];

12.book[reader[index]]+=1;

14.for（index=0;

15.if（book[reader[index]]>

1）

16.cout<

book[reader[index]]-1<

17.else

18.cout<

BeiJu"

19.}

20.}

21.return0;

22.}

Pro3：

中位数

排序然后输出

2.#include<

algorithm>

3.usingnamespacestd;

4.constintMAXN=10010;

5.intmain（）{

6.intnum,in[MAXN],index;

7.

8.while（cin>

num&

&

num!

=0）{

9.for（index=0;

10.cin>

in[index];

11.sort（&

in[0],&

in[num]）;

12.if（num%2!

=0）

13.cout<

in[num/2]<

14.else

15.cout<

（in[num/2]+in[num/2-1]）/2<

17.return0;

18.}

Pro4：

买房子

推出公式直接计算结果

6.intn,k,index,sum,count;

n>

k）{

9.sum=200,count=n;

20;

11.if（count>

=sum）{

index+1<

13.break;

15.count+=n;

16.sum+=（sum*k）/100;

17.}

18.if（index==20）

19.cout<

Impossible"

Pro5：

坠落的蚂蚁

悲剧的WA了几十次，虽然原理掌握了，但是实践起来却很差。

注意两个蚂蚁相遇可以等价直接穿越过去。

stdio.h>

3.#include<

4.#include<

stack>

5.usingnamespacestd;

6.constintMAXN=110;

7.structnode{

8.intpos;

9.intdir;

10.};

11.nodeant[MAXN];

12.boolcmp（nodea,nodeb）{

13.if（a.pos<

b.pos）returntrue;

14.returnfalse;

15.}

16.intmain（）{

17.intn,cnt,i,pos;

18.stack<

int>

left;

19.stack<

right;

20.

21.while（scanf（"

%d"

&

n）==1）{

22.for（i=0;

i<

n;

i++）

23.scanf（"

%d%d"

ant[i].pos,&

ant[i].dir）;

24.sort（&

ant[0],&

ant[n],cmp）;

25.for（i=0;

i++）{

26.if（ant[i].dir==0）break;

27.if（ant[i].dir==1）left.push（ant[i].pos）;

28.}

29.for（i=n-1;

i>

=0;

i--）{

30.if（ant[i].dir==0）break;

31.if（ant[i].dir==-1）right.push（ant[i].pos）;

32.}

33.

34.if（left.size（）==right.size（））printf（"

Cannotfall!

\n"

）;

35.elseif（left.size（）>

right.size（））{

36.for（i=0;

right.size（）;

37.left.pop（）;

38.printf（"

%d\n"

100-left.top（））;

39.}else{

40.for（i=0;

left.size（）;

41.right.pop（）;

42.printf（"

right.top（））;

43.}

44.while（left.empty（）==false）left.pop（）;

45.while（right.empty（）==false）right.pop（）;

46.}

47.return0;

48.}

Pro6：

放苹果

数的拆分问题，推荐看看整数分拆。

纯粹的数学问题。

4.intf（intm,intn）{

5.if（m<

0）return0;

6.if（m==0||n==1）return1;

7.returnf（m,n-1）+f（m-n,n）;

8.}

9.intmain（）{

10.intnum,m,n;

11.

12.scanf（"

num）;

13.while（num--）{

14.scanf（"

m,&

n）;

15.printf（"

f（m,n））;

Pro7：

Repeater

考察递归的实现。

3.#defineINF1000000000

4.#defineMAXN3010

6.charmat[MAXN][MAXN];

7.charin[10][10];

8.intn,size,rc;

9.voidpaint（intx,inty,intrc_t,intsize_t）{

10.inti,j;

11.if（rc_t==1）{

12.for（i=0;

13.for（j=0;

j<

j++）{

14.mat[x+i][y+j]=in[i][j];

16.return;

17.}else{

18.for（i=0;

19.for（j=0;

j++）

20.if（in[i][j]!

='

'

）

21.paint（x+i*size_t/n,y+j*size_t/n,rc_t-1,size_t/n）;

23.}

24.intmain（）{

25.inti,j;

26.charch;

27.while（scanf（"

n）==1&

n!

28.ch=getchar（）;

29.for（i=0;

30.for（j=0;

31.in[i][j]=getchar（）;

32.ch=getchar（）;

33.}

34.scanf（"

rc）;

35.for（i=0,size=1;

rc;

36.size=size*n;

37.for（i=0;

size;

38.for（j=0;

39.mat[i][j]='

;

40.paint（0,0,rc,size）;

41.for（i=0;

42.for（j=0;

43.putchar（mat[i][j]）;

44.putchar（'

\n'

45.}

Pro8：

IWannaGoHome

最短路，第一次见的询问的类型，处理的时候将连接分属两个party的城市路径取为有向的，属于同一个Party内的城市取为无向的，然后用最短路算法就出来了。

2.#defineMAXR10010

3.#defineMAXC610

4.#defineINF1000000000

5.structnode{

6.ints;

7.inte;

8.intw;

9.};

10.intmat[MAXC][MAXC];

11.intn,m,city[MAXC];

12.noderoad[MAXR];

13.voiddijkstra（）{

14.intmin,flag,i;

15.intdist[MAXC],visited[MAXC];

16.for（i=0;

=n;

17.dist[i]=INF;

18.visited[i]=0;

20.dist[1]=0;

21.while

（1）{

22.min=INF,flag=-1;

23.for（i=1;

24.if（visited[i]==0&

dist[i]<

min）{

25.min=dist[i];

26.flag=i;

27.}

28.if（flag==-1||flag==2）break;

29.visited[flag]=1;

30.for（i=1;

31.if（visited[i]==0&

mat[flag][i]+min<

dist[i]）

32.dist[i]=mat[flag][i]+min;

34.if（flag==2）printf（"

dist[2]）;

35.elseprintf（"

-1\n"

36.}

37.intmain（）{

38.inti,j,flag;

39.while（scanf（"

40.scanf（"

m）;

m;

42.scanf（"

%d%d%d"

road[i].s,&

road[i].e,&

road[i].w）;

43.for（i=1;

44.scanf（"

flag）;

45.city[i]=flag;

47.for（i=0;

48.for（j=0;

49.mat[i][j]=INF;

50.for（i=0;

51.if（city[road[i].s]==city[road[i].e]）{

52.mat[road[i].s][road[i].e]=mat[road[i].e][road[i].s]=road[i].w;

53.}elseif（city[road[i].s]==1&

city[road[i].e]==2）

54.mat[road[i].s][road[i].e]=road[i].w;

55.elsemat[road[i].e][road[i].s]=road[i].w;

56.}

57.dijkstra（）;

58.}

59.return0;

60.}

------------数学是计算机人的很重要的工具

中位数定义：

一组数据按从小到大的顺序依次排列，处在中间位置的一个数或最中间两个数据的平均值（如果这组数的个数为奇数，则中位数为位于中间位置的那个数；

如果这组数的个数为偶数，则中位数是位于中间位置的两个数的平均值）.

给出一组无序整数，求出中位数，如果求最中间两个数的平均数，向下取整即可（不需要使用浮点数）

输入

该程序包含多组测试数据，每一组测试数据的第一行为N，代表该组测试数据包含的数据个数，1<

=N<

=10000.

接着N行为N个数据的输入，N=0时结束输入

输出

输出中位数，每一组测试数据输出一行

样例输入

4

10

30

20

40

3

50

1

2

样例输出

25

解法是：

[cpp]viewplaincopyprint?

4.

5.intmain（）

6.{

8.intn;

cin>

9.while（n!

10.{

11.int*arr=newint[n];

12.for（inti=0;

i<

++i）

13.cin>

arr[i];

14.

15.sort（arr,arr+n）;

16.

17.intmid=n>

1;

18.if（n&

1==1）

arr[mid]<

20.else

21.cout<

（（arr[mid-1]+arr[mid]）>

1）<

22.

23.cin>

24.}

25.return0;

26.}

某程序员开始工作，年薪N万，他希望在中关村公馆买一套60平米的房子，现在价格是200万，假设房子价格以每年百分之K增长，并且该程序员未来年薪不变，且不吃不喝，不用交税，每年所得N万全都积攒起来，问第几年能够买下这套房子（第一年房价200万，收入N万）

有多行，每行两个整数N（10<

=N<

=50）,K（1<

=K<

=20）

针对每组数据，如果在第20年或者之前就能买下这套房子，则输出一个整数M，表示最早需要在第M年能买下，否则输出Impossible，输出需要换行

5010

4010

408

8

Impossible

解法为：

3.

4.intmain（）

5.{

6.intN,K;

N>

K）

8.{

9.floatprice=200;

10.floatearn=N;

11.intyear=1;

12.while（earn<

price）

13.{

14.if（year>

20）

15.{

17.break;

19.//cout<

year:

year<

earn:

earn<

price"

price<

20.earn+=N;

21.price=price*（1.0+（float）K/100）;

22.year++;

24.if（year<

=20）

25.cout<

27.return0;