var
        flag:boolean; 
        f:array[0..1000000] of Longint; 
        a:array[1..1000000] of Longint; 
        n,i,j,k,sum,l,r,mid:longint; 
begin
        readln(n); 
        for i:=1 to n do
        begin
                read(a[i]); 
                inc(sum,a[i]); 
                f[i]:=f[i-1]+a[i]; 
        end; 
        for i:=n downto 1 do
        begin
                if sum mod i<>0 then continue; 
                k:=sum div i; 
  
                flag:=true; 
                l:=1; 
                for j:=1 to i do	//依次判断i组是否可以组成.
                begin
                        r:=n; 
                        while l<=r do
                        begin
                                mid:=(l+r) div 2; 
                                if f[mid]=k then break; 
                                if f[mid]>=k then r:=mid-1 else l:=mid+1; 
                        end; //二分是找当前这一组的和是否能组成.
                        if f[mid]<>k then
                        begin
                                flag:=false; 
                                break; 
                        end; 
                        inc(k,sum div i); //能组成就下一组，同时更新要找的数以及上限l.
                        l:=mid+1; 
                end; 
  
                if flag then break; //如果这i组都可以组成则直接break.
        end; 
        if flag then writeln(sum div i) else writeln(sum); 
end.

var
        i,j,n,tot,sum,s,max:longint; 
        a:array[0..1000000] of longint; 
begin
        readln(n); 
        for i:=1 to n do
        begin
                 read(a[i]); 
                 inc(sum,a[i]); 
                 if a[i]>max then max:=a[i]; 
        end; 
        for i:=n downto 1 do
        begin
                 if (sum mod i<>0) or (sum div i<max) then continue; //这里就是优化和pd
                 s:=sum div i; 
  
                 tot:=0; 
                 for j:=1 to n do
                 begin
                          inc(tot,a[j]); 
                          if tot>s then break; 
                          if tot=s then tot:=0; 
                 end; //这里直接模拟.
                 if tot=0 then break; 
        end; 
        if tot=0 then writeln(s) else writeln(sum); 
end.

第五题：

兰姐姐是来自火星的女王。相信你们一定对兰姐姐不熟悉，她统领整个火星，在各方面拥有最高权力。很久很久以前，兰爸爸是火星的国王，去世以后，两个女儿争夺王位。火星上最聪明的人是辣椒酱，他帮助兰姐姐夺得了王位，而兰姐姐的姐姐Horse没有得到王位，便离开火星前往地球修行。几年后，兰姐姐越来越思念姐姐，便决定到地球上找姐姐。今天，她找到了自己失散已久的姐姐Horse的家，但是要进门就必须答对一个大难题，作为一个大犇犇犇，她很快就解出来了，你行吗？

题目是这样的：现在有一个序列a，a的长度为n，一开始a[i]=i(1≤i≤n)，现在有m个操作，每个操作的格式是这样的：x  y表示把当前的a[x]与a[y]交换。我们把这m个操作叫做一轮操作，现在问，在经过多少轮操作之后，序列a又会回到原来的样子（原来的样子就是指a[i]=i(1≤i≤n)）

Input

第一行，两个整数n，m，n表示a的长度，m表示操作数

接下来m行，每行一个操作x y，表示把当前的ax与ay交换保证（1≤x,y≤n）

Output

只有一个数，表示在经过多少轮之后，序列a又会回到原来的样子

Sample Input

4 4
1 4
3 4
2 3
1 4

Sample Output

3

HINT
50％数据保证1≤n,m≤1000，答案小于等于1000
100％数据保证1≤n,m≤500000，答案小于等于2^31-1

这道题目考试时没捞到1分，就是因为读题不仔细，当然也有一部分题目描述不完整的情况，但是，为什么其他人能明白，归根到底还是自身的问题，已经说了是多少轮操作之后才会得到原来的序列，一轮操作——必定是完整的一轮，不然怎么叫一轮操作，那就叫一些操作。

所以这题用模拟的方法可以拿到50分，但是我们可以进一步优化。

我们先用数据来模拟交换的一轮：

1 2 3 4

4 2 3 1

4 2 1 3

4 1 2 3

3 1 2 4

我们可以留下一轮繁琐操作的本质，也就是1个位置换来换去，到底换到了哪儿。

f[1]=1，2

f[2]=2，3

f[3]=3，1

f[4]=4，4

f[i]表示的是第i个位置一轮操作之后换到了f[i]这个位置。

我们可以发现4他是不换的，所以4要回到原来的位置只用1次。而1,2,3可以发现他们是组成了一个循环

1-2-3-1，所以1,2,3回到原来的位置只用3次，他们的最小公倍数gbs(1,3)=3，所以答案=3

再举一个栗子：

5 3

1 2

2 3

4 5

交换一轮：

1 2 3 4 5

2 1 3 4 5

2 3 1 4 5

2 3 1 5 4

f[1]=1,3

f[2]=2,1

f[3]=3,2

f[4]=4,5

f[5]=5,4

1,2,3组成了一个循环1-3-2-1

4,5组成了一个循环4-5-4

1,2,3用3次，4,5用2次，gbs(3,2)=6

从这里我们就可以发现，其实我们只要看f数组组成了多少个循环，然后求出n个循环个数的公倍数即可。

代码：

type
        arr=array[1..500000] of int64; 
var
        a:arr; 
        f:Array[1..500000,0..1] of longint; 
        x,y:Array[1..500000] of Longint; 
        bz:array[1..500000] of boolean; 
        n,m,ans,answer,t,tot:int64; 
        i,j:Longint; 
function gcd(x,y:int64):int64; 		//求出gbs——公倍数.
var
        z,xx,yy:int64; 
begin
        xx:=x; yy:=y; 
        while x mod y<>0 do
        begin
                z:=x mod y; 
                x:=y; 
                y:=z; 
        end; 
  
        exit(xx*yy div y); 
end; 
procedure sort(l,r:Longint); 		//快排用于方便模拟.
var
        i,j,mid,p:longint; 
begin
        i:=l; j:=r; 
        mid:=f[(i+j) div 2,0]; 
        while i<j do
        begin
                while f[i,0]<mid do inc(i); 
                while f[j,0]>mid do dec(j); 
                if i<=j then
                begin
                        p:=f[i,0]; f[i,0]:=f[j,0]; f[j,0]:=p; 
                        p:=f[i,1]; f[i,1]:=f[j,1]; f[j,1]:=p; 
                        inc(i); dec(j); 
                end; 
        end; 
        if l<j then sort(l,j); 
        if i<r then sort(i,r); 
end; 
  
begin
        readln(n,m); 
        for i:=1 to m do readln(x[i],y[i]); 
        for i:=1 to n do a[i]:=i; 
  
        for i:=1 to m do
        begin
                 t:=a[x[i]]; a[x[i]]:=a[y[i]]; a[y[i]]:=t; 		//交换一轮后的根本.
        end; 
        for i:=1 to n do
        begin
                f[i,0]:=a[i]; 
                f[i,1]:=i; 
        end; 								//判断出第i个位置到底是换到了哪里，表示为f[i,1].
        sort(1,n); 
  
        fillchar(bz,sizeof(bz),true); 
        answer:=1; 
        for i:=1 to n do
                if bz[i] then						//优化——已经有在循环里的数，无需再次判断。
                begin
                        j:=f[i,1]; 
                        ans:=1; 
                        while j<>i do					//while 循环用于找当前第i个数是在哪个循环，ans用来记录这个循环每个数要回到自己位置的个数.
                        begin
                                bz[j]:=false; 
                                j:=f[j,1]; 
                                inc(ans); 
                        end; 
                        answer:=gcd(answer,ans); 
                end; 
        writeln(answer); 
end.

小结：

这次考试考得不好，但收获才是最重要的，通过这次比赛，我明白了思维不要局限于1面，越广越好，像第1题犯得这种错误，以后不能再犯，还有从这次比赛结束后，我需要对自己进行几点要求：

1、做题时要快。根据题目的难度与实现的时间应该成正比，难的题目要能快速想到方法，简单的题目要能快速实现。

2、保证少提交次数。也就是在最少的次数AC一道题目，因为在考试时只有一次提交的机会，平时做题时如果不严谨，做的马马虎虎就提交，也不看优化数据之类的，考试时就惨了。

另：本文纯属原稿，若有打错字，或说错的地方请见谅。