连云港2011NOIP第一次模拟赛题目及解题报告

连云港NOIP2011提高组首次模拟赛

竞赛时间：2011年10月29日上午8：3030—

—11：30注意事项：

1、C/C++中函数main()的返回值类型必须是int ，程序正常结束时的返回值必须是0。

2、C/C++64位整型输入输出均使用I64d 。

试题名称郭嘉的等差数列

陆逊的情报站诸葛亮的战争

程序名arithseq station war 输入文件名arithseq.in station.in war.in 输出文件名arithseq.out

station.out

war.out 时限1s

1s 1s

内存限制128MB

分值100100100

300

1.郭嘉的等差数列(arithseq.pas/cpp/c)

[问题描述]

郭嘉在曹操这过得逍遥自在，但是有一天曹操给了他一个任务：曹操有一个人数为N 的军队，每个人的武力值为Ai ，他想要自己的军队武力值成为一个公差为d 的等差数列。由于每个人的武力值参差不齐，所以他需要对部分人进行训练，使得满足他的要求(训练可以随意调整士兵的武力值，包括负数，郭嘉只能调整武力值却不能改变相对位置)。

曹操想问郭嘉：如果军队武力值成为一个公差为d 的等差数列，最少需要训练多少个人？

[输入格式](arithseq.in)

第一行两个整数N 和d，表示士兵个数和曹操要求的公差；

第二行N 个整数：A1，A2，A3，……，An ，按顺序给出了这N 个数。[输出格式](arithseq.out)

输出一个正整数，表示满足曹操要求，训练最少的人数。[数据规模]

20%的数据：N≤100

100%的数据：0≤N ，d≤105，|Ai|≤109

样例输入样例输出52

73514

3

2.陆逊的情报站

(station.pas/cpp/c)

[题目描述]

夷陵之战打响，陆逊奉命抵抗刘备的进攻。陆逊认为:取得这场战争胜利的关键就是拥有足够的情报!(T_T)

陆逊手下有若干个情报站，每个情报站里有若干个情报小队，情报站内部每两个小队之间可能存在多条情报通道，每条通道传递情报具有一定的时间，各情报站之间不许互传情报。陆逊在每个情报站的两个不同小队里分别安排情报员，然后在每个情报站里选取一个小队作为对外情报传递出口，让这两名情报员通过这里向外传递情报，为保证信息通畅，要求两条情报总传递时间最小，但不允许情报经过同一个小队（对外出口小队除外）。

所有情报外传出口确定后，陆逊会派出一名武官与最多k个情报出口建立传信通道，并使这个武官作为一个新的传信出口取代之前他所联接的传信出口，如此不断增加武官，直到只有一个可接受所有信息的总传信出口，直接受陆逊指挥(最后一个武官到陆逊不花费时间)。所有武官建立的传信通道传信时间都是相同的，为q。

要求输出当所有情报员发出情报后，最短多长时间陆逊可以收到所有信息。

[输入格式](station.in)

第一行三个整数N，q，k，表示共有N个情报站，武官建立的传信通道传信时间q，武官与最多k个情报出口建立传信通道。

下面有N个部分，描述了N个情报站的情况。

对于每一部分：

第一行有m，x，a，b。表示共有m个情报小队，每个情报小队编号为1~m，有x条传信通道，情报员位于第a和第b小队。接下来x行，每行分别是整数u，v，t。表示情报小队u，v之间存在一条传信通道，传信时间为t。

[输入格式](station。out)

输出共N+1行。前N行表示每个情报站中对外传信出口所在小队的序号。(如果有多个，输出序号最小的一个)

最后一行，输出一个整数T，表示陆逊得到所有情报的最短时间。

样例输入样例输出

222 3313 122 135 231 3313 122 135 2312 2 4

[样例解释]:

都取2号小队为传递出口，并且1小队、3小队到2小队的最短时间为2。

然后设置一个武官，分别与之建立连接，其连接线路的通讯时间为2

则总的最短时间为4。(最后若干名直接与陆逊相连的武官或传递出口不消耗时间)

[数据规模和约定]

数据保证每个情报站的连通性。

100%数据N≤100，2≤k≤10，1≤q≤100。对于所有小分队，m≤100，2≤x≤5000，1≤t≤100。

3.诸葛亮的战争

(war.pas/cpp/c)

[题目描述]

诸葛亮无聊的时候喜欢带兵去进攻魏国，他的手下共有N名武将，每名武将都有一个武力值Ai。由于武将整天不学数学，他们的武力值不能被超过15的质数整除。可是有M对武将存在矛盾，有矛盾的武将不能同时出征。所以诸葛亮需要消除他们之间的矛盾。(定义武将x，y之间存在矛盾当且仅当他们的武力值之积Ax*Ay的约数个数不是奇数)智慧的诸葛亮想出了一个办法来消除矛盾。具体的做法是:花费C*DS(k)个金币，使某名武将的武力值由Ai变为Ai*k(k为正整数)。(C为给定常数，DS(k)表示k的约数个数)。(可以对任意武将进行任意次操作)

现在诸葛亮想知道他最少需要花费多少金币才能消除武将之间的矛盾，使得他们顺利出征。

[输入格式](war.in)

第一行两个正数N和C。(N为武将的个数，C为描述中的给定常数)

第二行N个正整数，表示A1…AN。(表示N名武将的武力值)

数据保证任意Ai无法被大于15的质数整除。

第三行一个正整数M。(矛盾个数)

以下M行每行两个正整数x，y，表示武将x，y之间存在矛盾。(可能本身已经满足DS(Ax*Ay)为奇数)

[输出格式](war.out)

输出一个正整数，最少需要花费的金币数。（若无解则输出-1）

样例输入样例输出

53

18

2630508

3

34

12

13

[样例解释]

将3号武将的能力值扩大为原来的15倍;

15的约数为13515，共4个。因此，费用=4×3=12;

将2号武将的能力值扩大为原来的3倍;

3的约数为13，共2个。因此，费用=2×3=6;

操作过后N个数分别为218450508，可以消除所有矛盾;

总的费用为12+6=18;这是最优方案。

[数据规模]

10%的数据，1

30%的数据，N≤15，M≤100；

50%的数据，N≤100，M≤1000；

60%的数据，N≤1000，M≤5000；

对于另外10%的数据，M=N-1，任意一个Ai必然与他人有矛盾且1

对于另外10%的数据，M=N-1，任意一个Ai必然与他人有矛盾；

100%的数据，N≤100000，M≤200000，C<10，任意Ai无法被大于15的质数整除。

连云港NOIP2011提高组首次模拟赛

竞赛时间：2011年10月29日下午1：3030—

—4：30注意事项：

1、C/C++中函数main()的返回值类型必须是int，程序正常结束时的返回值必须是0。

2、C/C++64位整型输入输出均使用I64d。

试题名称曹操的困惑

刘备的游戏周瑜的刁难程序名aox game rect 输入文件名aox.in game.in rect.in 输出文件名aox.out game.out rect.out 时限1s

2s 1s

内存限制128MB

分值

100100100

300

4.曹操的困惑

（aox.c/cpp/pas）

【问题描述】

曹操钻研古书的时候，深深着迷于伏羲的二进制思想。在这个基础上，他居然早于后世两千年发明了二进制中的与（and），或（or），异或（xor）运算！但很快曹操就被自己提出的一个问题难住了。

现在曹操的手下有N个士兵，每个士兵有一个战斗力A，第i个士兵的战斗力是Ai。每对士兵之间有一个和谐度。按照曹操的想法，每对士兵的和谐度，是这对士兵的战斗力的and，or，xor值的和。而曹操军队的总战斗力是每对士兵之间的和谐度之和。无奈曹操的士兵太多了，曹操无法知道他的军队战斗力的总和。你做为曹操的谋士，被迫要求计算这个无聊的数字。

【输入格式】(aox.in)

输入有若干行，第一行只有一个数N（1<=N<=1000000），代表曹操的士兵数。

第 2...N+1行，每行有一个数Ai（0<=Ai<=30000）,代表该士兵的战斗力。

【输出格式】(aox.out)

一个整数表示军队总战斗力。答案保证在2^63-1以内。

【样例输入】

3

1

2

3

【样例输出】

18

【样例解释】

有3个士兵战斗力分别为1，2，3。

有3对士兵，分别为（1，2），和谐度是(1and2)+(1or2)+(1xor2)=6；

(1，3)，和谐度为(1and3)+(1or3)+(1xor3)=6；

(2，3)，和谐度为(2and3)+(2or3)+(2xor3)=6；

故军队总战斗力为6+6+6=18。

【数据规模】

对于50%的数据，1<=N<=10000

对于100%的数据，1<=N<=1000000

【提示】

输入数据较大，C++选手请使用scanf/fscanf避免TLE。

5.刘备的游戏

（game.c/cpp/pas）

【问题描述】

刘备无聊的时候很喜欢和诸葛亮玩游戏。

有一次刘备发明了一个这样的游戏，在一个口袋里放了R 个红石子和B 个黑石子，然后让诸葛亮每次从袋子里取出一个石子。如果诸葛亮取出的是一个红石子，他就从刘备那儿赢到了1两银子；如果诸葛亮取出的是一个黑石子，他就要输给刘备1两银子。所有石子取出的机会是均等的。

诸葛亮不情愿地和刘备玩起了游戏，显然他不愿意输钱（刘备给他的薪水还不够他花），所以一旦他发现某时刻他取石子不会更优的时候，他就可以选择不取石子了。

现在诸葛亮很好奇，对于一个游戏，在他采取最优策略的情况下，平均每次能赢多少两银子呢？诸葛亮在打仗方面是个行家，但玩游戏实在是一窍不通，所以他只好求助于你，你能帮帮他吗？

【输入格式】(game.in)

输入只有一行，第一行只有两个数R 和B(1<=R,B <=5000)，中间用空格隔开。【输出格式】(game.out)

一个实数表示，诸葛亮采取最优策略的情况下，平均每次能赢的银子数。答案四舍五入保留三位小数。【样例输入1】21

【样例输出1】1.333

【样例输入2】56

【样例输出2】0.550

【样例1解释】

设3个石子分别为R 1，R 2，B 取出的石子只能是这几种情况：

R 1R 2B：取出两个R 后，显然就可以不取石子了，赢得2两银子；R 1BR 2：赢得1两银子；BR 1R 2：赢得1两银子。

R 1与R 2交换后又可以得到3种，实质和上面一样。R 2R 1B，R 2R 1B，R 2BR 1。

故平均每次能赢得(2+1+1+2+1+1)/6=8/6=1.333两银子。【数据规模】

对于30%的数据，1<=R +B <=13对于100%的数据，1<=R,B <=5000

6.周瑜的刁难

（rect.c/cpp/pas）

【问题描述】

屡次败给诸葛亮后，周瑜感到非常郁闷。

为了排解心中的怒气，他命令手下造了大量的诸葛亮稻草人。每天周瑜都会把一些稻草人摆成一个R*C的矩形，矩形的每个方格上都有一个稻草人。然后周瑜站在这个矩形的左上角，向矩形的右下角射箭。周瑜的箭术过人，他能穿透任意多的诸葛亮稻草人。弓箭经过的方格上的稻草人难逃厄运，报废掉了。看着被毁坏的诸葛亮稻草人，周瑜心花怒放。

众所周知，周瑜是个很抠门的人。制造诸葛亮稻草人需要大量的银子，所以周瑜不希望坏掉太多的稻草人，所以他每天都选择毁坏掉N个稻草人。周瑜还是个喜新厌旧的人，他希望每天能看到一种不同的稻草人摆放矩形。矩形是可以旋转的，即R*C和C*R等价。周瑜毫不费力地算出了摆放方案数，于是他决定刁难你一下。不甘示弱的你决定写个程序计算这个数回击周瑜，顺便替诸葛亮出这口恶气。

【输入格式】(rect.in)

输入只有一行且只有一个数N（1<=N<=1000000），代表每次被毁坏的稻草人数量。

【输出格式】(rect.out)

一个整数表示总方案数。

【样例输入】

4

【样例输出】

4

【样例解释】

4种方案如下图所示：

【数据规模】

对于40%的数据，1<=N<=10000

对于100%的数据，1<=N<=1000000

连云港2011NOIP第一次模拟赛解题报告

1.郭嘉的等差数列

只要看出此题的本质，此题就很简单了。其实就是求一个众数的过程，可以用hash或者是qsort+统计。

对于输入的每一个数a i，都可以根据i和题中给出的公差d来计算a i所在数列的首项a1。之后根据计算出来的首项的众数即可得到答案。

program arithseq;

var i,d,x:longint;

n,max,ans:int64;

s,v:array[1..100000]of int64;

procedure swap(var a,b:int64); var c:int64;

begin

c:=a;a:=b;b:=c;

end;

procedure qsort(l,r:longint);

var i,j:longint;

mid:int64;

begin

i:=l;j:=r;

mid:=s[(i+j)shr1];

while i<=j do

begin

while(s[i]

while(s[j]>mid)do dec(j);

if i<=j then

begin

swap(s[i],s[j]);

inc(i);dec(j);

end;

end;

if l

if i

end;

procedure init;

begin

assign(input,'arithseq.in');

assign(output,'arithseq.out'); reset(input);rewrite(output); end;

procedure over;

begin

close(input);close(output); end;

begin

init;

readln(n,d);

for i:=1to n do

begin

read(v[i]);

s[i]:=v[i]-(i-1)*d;

end;

qsort(1,n);

x:=s[1];

ans:=0;max:=1;

for i:=2to n do

begin

if(x=s[i])then inc(max)else

begin

if max>ans then ans:=max;

max:=1;

x:=s[i];

end;

end;

if max>ans then ans:=max; writeln(n-ans);

over;

end.

2．陆逊的情报站

题意很简单，考察的算法也很好写，但是思维量很大。题目中有一个限制：“传递时不能经过同一小队”。这个限制看上去很棘手，但分析清楚之后，你就会发现这只是一个障眼法。

下面给出解决该题的一个重要结论：最优的那条路径一定是最短路径，即如果两小队都走最短路径，那么他们就不可能在中途相遇。有人一定会问：“如果该图有割点不是就不成立了？”不，如果有割点，那么这个割点一定比先前算的那条路径更优。这个很容易想（试着画个图便可以知道）。解决了这个问题，我们就可以放心地求最短路径了。

根据范围分析我们应该用SPFA或者是堆+dijkstra，但是数据很弱，floyd就可以轻松跑过。下面的任务就是把求出的最短路的长度放到一个堆里，不断取出k个当前最小的长度，然后将其中最大的长度加上q再放回堆中（如果不足k个就全部取出），最后剩下的一个数就是答案（类似哈夫曼树的实现）。

program station;

var

n,q,ans,k,i,j,x,xx,yy,v,t,l,w,tot,m,a,b,tmp:longi nt;

heap:array[1..100]of longint;

f:array[1..100,1..100]of longint;

function max(a,b:longint):longint;

begin

if a>b then exit(a)else exit(b);

end;

function min(a,b:longint):longint;

begin

if a>b then exit(b)else exit(a);

end;

procedure floyd(m:longint);

var i,j,k:longint;

begin

for k:=1to m do

for i:=1to m do

if i<>k then

for j:=1to m do

if(k<>j)and(i<>j)then

begin

if(f[i,k]<>maxlongint)and (f[k,j]<>maxlongint)then

f[i,j]:=min(f[i,j],f[i,k]+f[k,j]);

end;

end;procedure swap(var a,b:longint);

var c:longint;

begin

c:=a;a:=b;b:=c;

end;

procedure insert(t:longint);

var i:longint;

begin

if tot=0then

begin

inc(tot);

heap[tot]:=t;

end else

begin

inc(tot);

heap[tot]:=t;

i:=tot;

while(i>1)and(heap[i]

begin

swap(heap[i],heap[i div2]);

i:=i div2;

end;

end;

end;

function update:longint;

var i:longint;

begin

update:=heap[1];

heap[1]:=heap[tot];

dec(tot);

i:=1;

while(i<=tot div2)and (heap[i]>min(heap[i*2],heap[i*2+1]))do begin

if heap[i*2]=min(heap[i*2],heap[i*2+1]) then

begin

swap(heap[i],heap[i*2]);

i:=i*2;

end else

begin

swap(heap[i],heap[i*2+1]);

i:=i*2+1;

end;

end;

end;

procedure init;

begin

assign(input,'station.in');assign(output,'station. out');

reset(input);rewrite(output);

end;

procedure over;

begin

close(input);close(output);

end;

begin

init;

readln(n,q,k);

ans:=-maxlongint;

for i:=1to n do

begin

readln(m,x,a,b);

for j:=1to m do

for l:=1to m do

f[j,l]:=maxlongint;

for j:=1to x do

begin

readln(xx,yy,v);

if f[xx,yy]>v then

begin

f[xx,yy]:=v;

f[yy,xx]:=v;

end;

end;

floyd(m);

f[a,a]:=0;f[b,b]:=0;

tmp:=maxlongint;

for j:=1to m do

begin

t:=max(f[a,j],f[b,j]);

if tmp>t then

begin

tmp:=t;

w:=j;

end;

end;

insert(tmp);

writeln(w);

end;

while tot>k do

begin

tmp:=-maxlongint;

for i:=1to k do

tmp:=max(tmp,update);

insert(tmp+q);

end;

if tot=1then writeln(update)else begin

ans:=-maxlongint;

for i:=1to tot do

ans:=max(ans,update);

writeln(ans+q);

end;

over;

end.

3．诸葛亮的战争

首先我们明确一个概念：有奇数个约数的数一定为完全平方数（因为约数总是成对出现的）。对于完全平方数p 可以分解为n 2

1B n B 2

B

1A A A +……+(唯一分解定理)。而B i 一定为

偶数。题目中又提示所有的数不会有超过大于15的质因数。这无疑提示我们要分解质因数后再考虑矛盾。

其次，通过简单的奇偶分析法即可证明：要想两个数的乘积为完全平方数，那么这两个数分解后的对应的指数一定同奇偶（也即相同的质因数的指数和为偶数）。那么对于a 1和a 2有矛盾，a 2和a 3有矛盾，a 3和a 4有矛盾，那么a 1,a 2,a 3,a 4之间有什么关系呢？显然每两个数对应指数是同奇偶的，那么这四个数对应的指数也是同奇偶的。那么会不会出现处理完一个矛盾，另一个矛盾又产生了这种情况呢？显然不会！我们在处理的时候直接处理一个集合，这样不会有任何问题（详见参考代码）。因为质数的约数最少，并且分解后的数都是质数，那么我们每一次操作时都乘上一个质数，这无疑是最优的。我们可以用BFS 求出每个集合，然后分别计算每个质因数的指数，并取奇数和偶数的个数中小的那一个累加起来（也即将集合中数的所有的质因数的指数改为同奇或同偶，并使这个操作代价最小）。最后再乘一个2*C 。

注意:一定要用BFS 来增广，如果用DFS 也必须人工模拟栈，不然会出现爆栈情况。program war;

const a:array[1..6]of integer=(2,3,5,7,11,13);const maxn=100000;

maxm=200000;

var i,j,n,num,m,c,tot:longint;

ans,tmp:int64;

f:array[0..maxn]of boolean;s,t:array[1..2*maxm]of longint;d,q:array[1..maxn]of longint;zhi:array[1..maxn,1..6]of longint;ff:array[1..6]of boolean;procedure init;begin

assign(input,'war.in');assign(output,'war.out');reset(input);rewrite(output);end;

procedure over;begin

close(input);close(output);end;

procedure swap(var a,b:longint);var c:longint;begin

c:=a;a:=b;b:=c;end;

procedure qsort(l,r:longint);var i,j,mid:longint;begin

i:=l;j:=r;mid:=s[(i+j)shr 1];while i<=j do begin

while s[i]mid do dec(j);if i<=j then begin

swap(s[i],s[j]);swap(t[i],t[j]);inc(i);dec(j);end;end;

if j>l then qsort(l,j);if i

function min(a,b:longint):longint;begin

if a>b then exit(b)else exit(a);end;

procedure bfs(k:longint);

var i,head,now:longint;

begin

f[k]:=true;

inc(tot);

q[tot]:=k;

head:=1;

while head<=tot do

begin

now:=q[head];

for i:=1to6do

if zhi[now,i]<>0then ff[i]:=true;

for i:=d[now-1]+1to d[now]do

if f[t[i]]=false then

begin

inc(tot);

q[tot]:=t[i];

f[t[i]]:=true;

end;

inc(head);

end;

end;

procedure check;

var i,j,tmp1,tmp2:longint;

begin

for i:=1to6do

if ff[i]=true then

begin

tmp1:=0;tmp2:=0;

for j:=1to tot do

if zhi[q[j],i]mod2=0then inc(tmp1) else inc(tmp2);

inc(tmp,min(tmp1,tmp2));

end;

inc(ans,tmp);

end;begin

init;

readln(n,c);

fillchar(zhi,sizeof(zhi),0);

for i:=1to n do

begin

read(num);

for j:=1to6do

begin

if num=1then break;

while(num mod a[j]=0)do

begin

inc(zhi[i,j]);

num:=num div a[j];

end;

end;

end;

readln(m);

for i:=1to m do

begin

read(s[i],t[i]);

s[i+m]:=t[i];

t[i+m]:=s[i];

end;

qsort(1,2*m);

for i:=1to2*m do

d[s[i]]:=i;

for i:=1to n do

if d[i]=0then d[i]:=d[i-1];

for i:=1to n do

if(f[i]=false)and(d[i-1]<>d[i])then

begin

tot:=0;tmp:=0;

fillchar(ff,sizeof(ff),false);

bfs(i);

check;

end;

writeln(ans*2*c);

over;

end.

12]2

)

1([?×?+=i i x x xy tmp 4．曹操的困惑

这是一道思维量较大，代码量小的题。

首先题目给出了几个二进制的运算符，它启发我们从二进制入手。首先我们可以发现（x and y ）+（x xor y ）=（x or y ）（这个可以通过运算符的定义证明，此处略）。所以我们只要求出所有（x or y ）然后再乘以2即可。以下我举例谈谈算法，假设有5个数：10012010301141005101

可以发现0和1or 运算时，一个1贡献1（这里先不考虑权重），1和1or 运算，两个个1贡献1（所以需要除以一个2）。0和0or 运算，0无贡献。那么显然我们可以得到一个公式。

设x 为1的个数，y 为0的个数，对于每一位的贡献(2i-1为第i 位上的权重)。

根据这一思路，我们只要把所有的数分解为二进制，统计这些二进制数每一位上的0和1的个数，再利用上述公式计算即可。program aox;var i,j,n,k,tot:longint;ans,tmp,tmp0:int64;nn:array[1..100]of int64;num,ci:array[0..1000000]of int64;procedure init;begin assign(input,'aox.in');assign(output,'aox.out');reset(input);rewrite(output);end;procedure over;begin close(input);close(output);end;

begin init;

tmp:=1;nn[1]:=1;

fillchar(ci,sizeof(ci),0);tot:=0;ans:=0;for i:=2to 62do

begin tmp:=tmp*2;nn[i]:=tmp;end;readln(n);num[0]:=-1;for i:=1to n do

begin read(k);

num[i]:=-1;j:=0;while k>0do

begin

inc(j);if k mod 2=1then inc(ci[j]);k:=k div 2;if j>tot then tot:=j;end;end;for i:=1to tot do begin if num[i]=-1then begin

tmp0:=n-ci[i];

tmp:=ci[i]*tmp0+(ci[i]*(ci[i]-1)div 2);num[i]:=tmp;tmp:=tmp*nn[i];end

else tmp:=num[i]*nn[i];inc(ans,tmp);end;

writeln(ans*2);over;end.

5．刘备的游戏

这是一道概率型DP（可以不掌握）。

有兴趣的同学可以参考国家集训队论文汤可因的《浅析竞赛中一类数学期望问题的解决方法》。{注：翻牌的程序与本题一样——

FB}

/*Title:RedIsGood

Comment:用f[i,j]表示剩下i张红牌和j张黑牌获得钱的期望.决策只有2种,即翻牌与不翻牌.

不翻牌期望为0.翻到红/黑牌的概率分别为i/(i+j)和j/(i+j).所以期望为

(f[i-1][j]+1)*i/(i+j)+(f[i][j-1]-1)*j/(i+j).

需要利用滚动数组优化.*/

#include

#include

using namespace std;

const int maxn=5001;

class RedIsGood{

private:

double f[maxn][2];

double solve(int r,int b){

for(int i=0;i<=1;++i){

f[0][i]=0;

}

for(int i=0;i<=r;++i){

f[i][0]=i;

}

for(int j=1;j<=b;++j){

for(int i=1;i<=r;++i) {f[i][j&1]= max(0.0,(f[i-1][j&1]+1)*i/(i+j)+ (f[i][~j&1]-1)*j/(i+j));

}

}

return f[r][b&1];

}

public:

double getProfit(int r,int b){

return solve(r,b);

}

};

6．周瑜的刁难

首先，我们可以得到一个很显然的结论。对于（r，c）≠1的大格子{注：（r，c）表示r 与c的最大公约数}，它穿过的格子一定可以分解为（r，c）个小格子，即我们可以缩小范围。假设该条直线传过的格子数为N，函数g（r，c）=N，（r，c）=t，那么N=（r，c）*g （r/t,c/t）。下面我们来分析（r，c）=1的情况，可以证明此时N=r+c-1（这是一个很显然的结论，证明略去，可以打表获得）。综上可以得到N=r+c-gcd（r，c）。

但是不难发现直接枚举显然会超时，所以我们需要优化。

下面证明一个很显然的结论：

令t为r,c的最大公约数，则r=k1*t，c=k2*t

所以N=r+c-gcd（r，c）可以转换为N=（k1+k2-1）*t，所以可以得到一个结论：t一定为N的约数。那么我们就可以枚举N的约数。根据唯一分解定理约数的个数小于200。加上这样一个小优化可以通过所有的点，但这个方法不是最优的，更优的方法是利用容斥原理，这里不加介绍。有兴趣的同学可以参考刘汝佳的《数学方法与应用》。

program rect;

var n,i,j,ans,x,y:longint;

function gcd(m,n:longint):longint;

begin

if m mod n=0then exit(n)

else gcd:=gcd(n,m mod n); end;

procedure init;

begin

assign(input,'rect.in');assign(output,'rect.out'); reset(input);rewrite(output);

end;

procedure over;

begin

close(input);close(output);

end;

begin

init;

ans:=0;

readln(n);

for i:=1to n do

begin

j:=1;

if n mod i=0then

while j*i<=n do

begin

x:=j*i;

y:=n+i-x;

if y>=x then

begin

if gcd(y,x)=i then inc(ans);

end else break;

inc(j);

end;

end;

writeln(ans);

over;

end.

题解与5个pascal程序由李根编写。第5题C++程序由董麒麟提供。

整理排版由陈政儒完成。