2016广东工业大学新生杯决赛网络同步赛暨全国新生邀请赛 题解&源码

Problem A: pigofzhou的巧克力棒

Description

众所周知，pigofzhou有许多妹子。有一天，pigofzhou得到了一根巧克力棒，他想把这根巧克力棒分给他的妹子们。具体地，这根巧克力棒长为 n，他想将这根巧克力棒折成 n 段长为 1 的巧克力棒，然后分给妹子们。

但是他妹子之一中的 15zhazhahe 有强迫症。若它每次将一根长为 k 的巧克力棒折成两段长为 a 和 b 的巧克力棒，此时若 a=b，则15zhazhahe会得到一点高兴值。

pigofzhou想知道15zhazhahe最多能获得多少高兴值。

Input

输入数据为T组(T <= 10000)，每组数据读入一个n（n<=1000000000）

Output

一行一个整数代表能获得的最大高兴值

Sample Input

1

5

Sample Output

3

HINT

题目链接：http://gdutcode.sinaapp.com/problem.php?cid=1049&pid=0

ps：关于这题 数学不好就真的只能找规律了。
首先 关于查找n！中k的因子是有数学公式的：

n!=n*(n-1)(n-2)……3*2*1

=(k*2k*3k…..*mk)*a a是不含因子k的数的乘积，显然m=n/k;

=(k^m)*(1*2*3…*m)*a

=k^m*m!*a

比如说例子代码：

int gs(int n,int k)

{

int num=0;

while(n)

{

num+=n/k;

n/=k;

}

return num;

}

下面给出AC代码：

 #include <bits/stdc++.h>
 using namespace std;
 int main()
 {
     int T;
     long long n,sum;
     while(scanf("%d",&T)!=EOF)
     {
         while(T--)
         {
             sum=;
             scanf("%lld",&n);
             while(n)
             {
                 sum+=(n/);
                 n/=;
             }
             printf("%lld\n",sum);
         }
     }
     return ;
 }

Problem B: Zhazhahe究竟有多二

Description

Zhazhahe竟然能二到把耳机扔到洗衣机里去洗，真的是二到了一种程度，现在我们需要判断一下zhazhahe二的程度（就是计算zhazhahe的脑残值有几个2的因子），下面给你一个n，n!表示zhazhahe的脑残值。

Input

输入一个正整数t(0<t<3000)表示样例组数，每组样例输入一个正整数n(0<n<1e18)，n!表示zhazhahe的脑残值

Output

输出一个正整数表示zhazhahe二的程度

Sample Input

3

2

4

15

Sample Output

1

3

11

HINT

题目链接：http://gdutcode.sinaapp.com/problem.php?cid=1049&pid=1

题解：思路和上一题基本上是一样的，代码几乎相同！不理解看上一题的题解！

下面给出AC代码：

 #include <bits/stdc++.h>
 using namespace std;
 int main()
 {
     int T;
     long long n,ans,i,sum;
     while(scanf("%d",&T)!=EOF)
     {
         while(T--)
         {
             scanf("%lld",&n);
             sum=;
             while(n)
             {
                 n/=;
                 sum+=n;
             }
             printf("%lld\n",sum);
         }
     }
     return ;
 }

Problem C: 剁手女生节

Description

由于女生节准备到了，ming打算给班上女生送一份大礼。没错，就是数学练习册！
ming先前就已经收藏了 n 本练习册了，一直不舍得做，这次突然决定把它们都拿出来当作礼物送出去！
但是，ming班上一共有 4 个女生，为了不要显得自己偏爱哪一个，他觉得每个女生都应该分到同等数量的练习册。
这样的话，原来的 n 本就可能不太够了。于是他去逛亚马当商城。
他发现，最近ACM（Association of Counting Method）又出版了好多新版数学练习册：高数、线代、离散、概率论…
而且商店有三种促销优惠套餐：
第一种：任选 1 本练习册，送欧几里德主题套尺。只需 a 个比特币；
第二种：任选 2 本练习册，送莱布尼兹同款2B铅笔。只需 b 个比特币；
第三种：任选 3 本练习册，送爱因思坦专用橡皮擦。只需 c 个比特币。
那么问题来了：吃土ming如何用最少的比特币购买若干本练习册，使得全部（包括原来的n本）可以平分给四个女生？

Input

每组输入是一行四个整数：n，a，b，c（1 <= n，a，b，c <= 1e9）意思如题目描述。

Output

对每组输入，输出一行一个整数，表示ming要花的最少的比特币数。

Sample Input

3

1 1 3 4

6 2 1 1

4 4 4 4

Sample Output

3

1

HINT

题目链接：http://gdutcode.sinaapp.com/problem.php?cid=1049&pid=2

思路：三种情况，讨论即可！给出两种写法：

 #include <bits/stdc++.h>
 #define ll long long int
 using namespace std;
 int main()
 {
     ll t;
     scanf("%lld",&t);
     while(t--)
     {
         ll n,a,b,c;
         scanf("%lld%lld%lld%lld",&n,&a,&b,&c);
         if(n%==)
             printf("0\n");
         else
         {
             ll x=(-(n%));
             if(x==)printf("%lld\n",min(min(a,c*),c+b));
             if(x==)printf("%lld\n",min(min(*a,b),c*));
             if(x==)printf("%lld\n",min(min(*a,a+b),c));
         }
     }
     return ;
 }

DP写法：

 #include <bits/stdc++.h>
 using namespace std;
 long long dp[];
 const long long inf=<<;
 void init(int x)
 {
     for(int i=;i<=;i++)
         dp[i]=i?inf:;
 }
 int main()
 {
     int m[];
     int T,n,x;
     while(scanf("%d",&T)!=EOF)
     {
         while(T--)
         {
             scanf("%d",&n);
             for(int i=;i<=;i++)
             scanf("%d",&m[i]);
             x=n%;
             if(!x)
                 cout<<<<endl;
             else
             {
                 init(x);
                 for(int i=;i<=-x;i++)
                     for(int j=;j<=;j++)
                     if(i>=j)
                     dp[i]=min(dp[i],dp[i-j]+m[j]);
                 long long minx=inf;
                 for(int j=;j<=;j++)
                     minx=min(minx,dp[j*-x]);
                 printf("%lld\n",minx);
             }
         }
     }
     return ;
 }

Problem D: 勤奋的涟漪2

Description

涟漪进入集训队后，他会去实验室训练或者去操场锻炼。 接下来n天，每天的情况是一下4种中的一种： 1.当天体育馆关门了和没有训练赛 2.当天体育馆关门了和有训练赛 3.当天体育馆开放和没有训练赛 4.当天体育馆开放和有训练赛 涟漪知道之后n天的情况。  涟漪每一天可以休息，或者打训练赛（当天有训练赛）或者运动（当天体育馆开放）。 涟漪要制定一个训练计划，决定每天干什么，但是涟漪不会连续两天都运动或者连续两天都打训练赛， 请帮涟漪找出她最少休息的天数（她不打训练赛和运动）。    休息的时候，她会做下面的数学题

Input

第一行一个整数t（t<=100）,代表测试数据， 第二行一个整数 n（1<=n<=100） 第三行有n个数a1,a2,a3,....an(0<=ai<=3)) ai=0 ,代表第一种情况 ai=1,代表第二种情况 ai=2 ,代表第三种情况 ai=3 ,代表第四种情况

Output

输出 一个数 表示（涟漪休息的天数） 乘以（数学题的答案的积）。

Sample Input

4

7

1 3 3 2 1 2 3

1

1

1

2

1

3

Sample Output

HINT

题目链接：http://gdutcode.sinaapp.com/problem.php?cid=1049&pid=3

分析：四次导数，结果为-24，注意这个好像没有什么了！

下面给出AC代码：

 #include <bits/stdc++.h>
 using namespace std;
 const int MAX=;
 int n,a[MAX];
 int main()
 {
     int T;
     cin>>T;
     while(T--)
     {
     scanf("%d",&n);
     for(int i=;i<=n;i++)  scanf("%d",&a[i]);
     int l=;
     while(a[l]==) l++;
     for(int i=l+;i<=n;i++)
     {
         if(a[i]==)
         {
             if(a[i-]!=)  a[i]=-a[i-];
         }
         else
         {
             if(a[i]==a[i-])  a[i]=;
         }
     }
     int ans=;
     for(int i=;i<=n;i++)
     {
         if(!a[i]) ans++;
     }
     cout<<ans*(-)<<endl;
     }
     return ;
 }

Problem E: 穷游中国在统题

Description

Travel_poorly队是广工大目前最年轻的金牌队伍，队内成员分别是tmk、YFQ、Maple。这天他们接到教练的order要给新生杯统题，统题是个不轻松的工作，要评估各个题目的难度，设计出一套有梯度的套题，使得做题的情况有区分度。tmk很快想出了解决的办法，他给每道题目都设置了一个难度值，然后按照难度值进行筛选题目，这时候他发现难度值刚开始有可能是无序的，于是他决定要让全部题目都按照难度值从小到大排好序。 这时候YFQ说让他来排序，排序是一个展现算法魅力的过程，他要通过一种有趣的方法来给题目的难度值排序： 首先他把题目划分成很多组，每组的题目都是连续的，例如某一组包含从i到j的题目，那么这一组包含的是第i，i+1，i+2，i+3，...，j题。 这样每道题都属于某一个组，然后他再到组内把题目按照难度值进行从小到大排序。 当每个组内都进行排序之后，最终全部题目的难度值将按照从小到大的顺序排列好。 我们知道每一组里面的题目越多，排序的压力就越大，所以Maple提出一个合理的要求，就是让每个组里面的题目数量尽可能的少，聪明的ACMer，你知道Travel_poorly一共要分出多少个组吗？

Input

第一行是一个整数t ( t<= 10 )，表示有t组数据。在每组数据中： 第一行是一个整数n ( n<=1000 00 )，表示题目的总数； 第二行是n个整数A1,A2,A3...An ( 0<=Ai<= 1000 000 000)，表示每道题目的难度值

Output

对于每组数据，输出一个正整数，表示一共要分出多少个组能满足Travel_poorly的要求，每两组样例之间输出一个空行。

Sample Input

2

5

3 2 5 4 6

5

5 4 3 2 1

Sample Output

3

1

HINT

题目链接：http://gdutcode.sinaapp.com/problem.php?cid=1049&pid=4

思路：

ps：想了半天没明白题意。。最后看了下别人写的代码才略懂，，引用一下大神的话

比如3 2 5 4 6

排序之后是 2 3 4 5 6

那么排序后的2所谓的位置到排序前2所在的位置这一个区间是必须被分在一个区间内的。

所以题目就变成了判断原来位置和排序后位置的区间的问题

显然相交的区间需要合并成一个区间

然后计算区间个数即可

但是注意，当难度值一样的时候，还是按照原来的顺序比较好。

下面给出AC代码：

 #include<bits/stdc++.h>
 using namespace std;
 const int N=+;
 struct zxc
 {
     int xx,mm;
 } a[N];
 bool cmp(struct zxc x,struct zxc y)
 {
     return x.mm<y.mm;
 }
 int main()
 {
     int t,c=;
     cin>>t;
     while(t--)
     {
         int n,i,j;
         cin>>n;
         for(i=; i<=n; i++)
         {
             a[i].xx=i;//记录原先所在的位置
             cin>>a[i].mm;
         }
         stable_sort(a+,a+n+,cmp);//稳定排序
         int tot=;
         i=;
         while(i<=n)
         {
             tot++;
             int k=a[i].xx;
             for(j=i; j<=k; j++)//相交的区间合并
                 if(a[j].xx>k)
                     k=a[j].xx;
             i=k+;
         }
         cout<<tot<<endl<<endl;
     }
 }

Problem F: 神偷TMK

Description

TMK十分喜欢打CS，据说GDUTACM新生杯的一等奖的奖品的星际CS的真人CS游戏团体券，他毅然报了名。 然而TMK等不及决赛的来临，希望能早日可以玩真人CS。于是TMK打算把真人CS游戏团体券从师兄那里偷出来。 几听打探，TMK发现真人CS游戏团体券锁在了工一730的保险箱里面。但是他不知道密码。他突然想起了yfq给了他一个锦囊，当有困难的时候打开来看。 锦囊里面的纸条上有一串小写字母"abhcujzqacehbfjkbacxmcnjkaecfiallcxcbbcad",TMK灵机一动，密码应该是这串字母出现最多的字母和第二多的字母按字典序连接在一起吧。于是TMK在密码箱上按下了那两个字母，那么现在问那两个字母是什么

Input

Output

按字典序输出这串字母出现最多的字母和第二多的字母，中间无空格。

Sample Input

Sample Output

HINT

题目链接：http://gdutcode.sinaapp.com/problem.php?cid=1049&pid=5

思路：这道题就不说了，输出ab!

下面给出AC代码：

 #include<bits/stdc++.h>
 using namespace std;
 int main()
 {
 cout<<'a'<<'b'<<endl;
 return ;
 }

Problem G: 神偷TMK后续

Description

TMK十分喜欢打CS，据说GDUTACM新生杯的一等奖的奖品的星际CS的真人CS游戏团体券，他毅然报了名。 然而TMK等不及决赛的来临，希望能早日可以玩真人CS。于是TMK打算把真人CS游戏团体券从师兄那里偷出来。 几听打探，TMK发现真人CS游戏团体券锁在了工一730的保险箱里面。但是他不知道密码。他突然想起了yfq给了他一个锦囊，当有困难的时候打开来看。 锦囊里面的纸条上有一串小写字母"abhcujzqacehbfjkbacxmcnjkaecfiallcxcbbcad",TMK灵机一动，密码应该是这串字母出现最多的字母和第二多的字母按字典序连接在一起吧。于是TMK在密码箱上按下了那两个字母，保险箱开了。 TMK发现里面有n张星际CS的真人CS游戏团体券，但tmk只想拿k张，因为tmk觉得拿太多就会没时间学习了。 现在问TMK一共有多少种取法

Input

题目包含多组数据，每组测试数据包含一行，两个数n和k(1<=n<=10,0<=k<=n)

Output

每组测试数据包含一个整数表示TMK的取法

Sample Input

3 2

3 0

Sample Output

3

1

HINT

题目链接：http://gdutcode.sinaapp.com/problem.php?cid=1049&pid=6

思路：一个组合问题，求C（ｎ，ｋ）；

下面给出AC代码：

 #include<bits/stdc++.h>
 using namespace std;
 int main()
 {
     int n,k;
     while(~scanf("%d%d",&n,&k))
     {
         int a=,b=,c=;//一定要赋值1；
     for(int i=n;i>=; i--)
         a*=i;
     for(int i=k; i>=; i--)
         b*=i;
     for(int i=(n-k); i>=; i--)
         c*=i;
     printf("%d\n",a/(b*c));
     }
     return ;
 }

Problem H: 《为什么会变成这样呢》

Description

“第一次有了喜欢的人，还得到了一生的挚友，两份喜悦互相重叠，这双重的喜悦又带来了更多更多的喜悦，本应已经得到了梦幻一般的幸福时光，然而，为什么，会变成这样呢？”双重的喜悦感却无法带来更多的幸福，现在，雪菜在很多喜悦感之中只想要得到两份不重叠的喜悦感（其他的喜悦感都是重叠的），你能帮她找出这两份不同的喜悦感是多少吗？

Input

第一行一个整数T，代表数据的组数（1<=T<=10）,接下来T组数据，每组数据的第一行是一个整数n（1<=n<=1000000），第二行是n个整数ai（0 <= ai <= 1000000000）代表喜悦感，每两个整数之间有一个空格，题目保证有且仅有两个不同的整数出现一次，其他的整数都是出现两次。

Output

对于每组数据，输出两个整数，分别代表两份不同的喜悦感，中间有一个空格，并且喜悦感较小的先输出。

Sample Input

2

6

2 2 1 1 3 4

4

1 1 3 4

Sample Output

3 4

3 4

HINT

题目链接：http://gdutcode.sinaapp.com/problem.php?cid=1049&pid=7

思路：

Single number 问题，其他数都出现了k（k>1)次，只有一个数出现了一次，求这个数。

考虑把出现了多次数消掉，如果k是偶数，则可用异或法；如果k是奇数，则可以用求和再求余法，出现k次的数模k为0，和里最终剩下的是那个single
number %k，还是不行，再利用一个性质，小于k的数对k取模就是这个数本身，分别求single number的每一位

 #include <iostream>
 #include <cstdio>
 using namespace std;
 unsigned long long FindFirstBitIs1 (long long num){
     long long indexBit = ;
     while ((num & ) ==  && indexBit < ){
         num >>= ;
         ++indexBit;
     }
     return indexBit;
 }

 long long IsBit1 (long long data, unsigned long long indexof1){
     data >>= indexof1;
     return data & ;
 }

 void FindNumsAppearOnce (long long data[], long long n, long long &num1, long long &num2){
     long long result = ;
     long long i;
     for (i=; i<n; ++i){
         result ^= data[i];
     }
     unsigned long long indexof1 = FindFirstBitIs1 (result);
     num1 = ;
     num2 = ;
     for (i=; i<n; ++i){
         if (IsBit1 (data[i], indexof1))
             num1 ^= data[i];
         else
             num2 ^= data[i];
     }
 }

 int main(){
     int T;
     cin>>T;
     while(T--){
         long long num1 = ,num2 = ;
         long long n;
         scanf("%lld",&n);
         long long *a=new long long[n];
         for(long long i=;i<n;i++){
             scanf("%lld",&a[i]);
         }
         FindNumsAppearOnce(a,n,num1,num2);
         printf("%lld %lld\n",min(num1,num2),max(num1,num2));
         delete[] a;
     }
     return ;
 }

Problem I: 只会做水题的jiakin

Description

听说ACM新生杯来了许多大佬，吓得只会做水题的jiakin开始做水题。 题目在一个n行m列二维网格中，位于右下角的格子。现在有若干种水管，类型及状态如下：

在网格中有一些格子布置着水管（只有一种类型一种状态），现在jiakin从最左上的格子开始灌水(即最左上的格子一直有水)，且水只能沿水管向右或者向下流，问：jiakin能否成功做好水题。（如图：满足条件）

Input

第一行一个整数T（T < 10）,代表T组测试数据。 每组数据第一行有两个整数n和m(n,m<=1000)，表示网格的行数和列数。 接下去n行，每行有m个格式为(x,y)的一组数据，代表水管的类型和状态，其中（0，0）表示没水管。

Output

对每组数据第一行“Case x:”，x代表第x组数据。 第二行如果jiakin能成功水题则输出“Well done!”，否则输出“What a pity!”.

Sample Input

3

4 4

(0,0)(4,0)(4,0)(4,0)

(4,0)(4,0)(4,0)(4,0)

(4,0)(4,0)(4,0)(4,0)

(4,0)(4,0)(4,0)(4,0)

3 3

(2,2)(4,0)(4,0)

(3,2)(2,2)(0,0)

(2,1)(2,3)(2,0)

3 3

(2,0)(4,0)(0,0)

(3,0)(3,2)(0,0)

(2,3)(2,0)(2,0)

Sample Output

Case 1:

What a pity!

Case 2:

Well done!

Case 3:

What a pity!

HINT

题目链接：http://gdutcode.sinaapp.com/problem.php?cid=1049&pid=8

思路：只要理顺就好了！

下面给出AC代码：

 #include <cstdio>
 #include <iostream>
 #include <climits>
 #include <cstring>

 using namespace std;

 struct node{
     int x,y;
 }g[][];

 bool f[][];

 int main(){
     freopen("input.txt","r",stdin);
     int T,n,m;
     scanf("%d\n",&T);
     for(int cnt=;cnt<=T;cnt++){
         scanf("%d %d\n",&n,&m);
         for(int i=;i<=n;i++){
             for(int j=;j<=m;j++)scanf("(%d,%d)",&g[i][j].x,&g[i][j].y);
             getchar();
         }
         memset(f,,sizeof f);
         f[][]=;
         for(int i=;i<=n;i++)
             for(int j=;j<=n;j++){
                 if(i==&&j==) continue;
                 if(g[i][j].x==&&g[i][j].y==){ //2 4
                     f[i][j]=;
                     continue;
                 }
                 if(g[i][j].x==&&g[i][j].y==){//2 5
                     f[i][j]=;
                     continue;
                 }

                 if(g[i][j].x==&&g[i][j].y==&&
                 ((g[i][j-].x==&&g[i][j-].y==)
                 ||(g[i][j-].x==&&g[i][j-].y==)
                 ||(g[i][j-].x==&&g[i][j-].y==)
                 ||(g[i][j-].x==&&g[i][j-].y==)
                 ||(g[i][j-].x==&&g[i][j-].y==))) f[i][j]=f[i][j-]; //(2,0)

                 if(g[i][j].x==&&g[i][j].y==&&
                 ((g[i-][j].x==&&g[i-][j].y==)
                 ||(g[i-][j].x==&&g[i-][j].y==)
                 ||(g[i-][j].x==&&g[i-][j].y==)
                 ||(g[i-][j].x==&&g[i-][j].y==)
                 ||(g[i-][j].x==&&g[i-][j].y==)
                 ||(g[i-][j].x==&&g[i-][j].y==))) f[i][j]=f[i-][j]; //(2,1)

                 if(g[i][j].x==&&g[i][j].y==&&
                 ((g[i][j-].x==&&g[i][j-].y==)
                 ||(g[i][j-].x==&&g[i][j-].y==)
                 ||(g[i][j-].x==&&g[i][j-].y==)
                 ||(g[i][j-].x==&&g[i][j-].y==)
                 ||(g[i][j-].x==&&g[i][j-].y==))) f[i][j]=f[i][j-]; //(2,2)

                 if(g[i][j].x==&&g[i][j].y==&&
                 ((g[i-][j].x==&&g[i-][j].y==)
                 ||(g[i-][j].x==&&g[i-][j].y==)
                 ||(g[i-][j].x==&&g[i-][j].y==)
                 ||(g[i-][j].x==&&g[i-][j].y==)
                 ||(g[i-][j].x==&&g[i-][j].y==)
                 ||(g[i-][j].x==&&g[i-][j].y==))) f[i][j]=f[i-][j]; //(2,3)

                 if(g[i][j].x==&&g[i][j].y==&&
                 ((g[i][j-].x==&&g[i][j-].y==)
                 ||(g[i][j-].x==&&g[i][j-].y==)
                 ||(g[i][j-].x==&&g[i][j-].y==)
                 ||(g[i][j-].x==&&g[i][j-].y==)
                 ||(g[i][j-].x==&&g[i][j-].y==))) f[i][j]=f[i][j-]; //(3,0)

                 if(g[i][j].x==&&g[i][j].y==&&
                 ((g[i-][j].x==&&g[i-][j].y==)
                 ||(g[i-][j].x==&&g[i-][j].y==)
                 ||(g[i-][j].x==&&g[i-][j].y==)
                 ||(g[i-][j].x==&&g[i-][j].y==)
                 ||(g[i-][j].x==&&g[i-][j].y==)
                 ||(g[i-][j].x==&&g[i-][j].y==))) f[i][j]=f[i-][j]; //(3,3)

                 if(g[i][j].x==&&g[i][j].y==){
                     if((g[i-][j].x==&&g[i-][j].y==)
                     ||(g[i-][j].x==&&g[i-][j].y==)
                     ||(g[i-][j].x==&&g[i-][j].y==)
                     ||(g[i-][j].x==&&g[i-][j].y==)
                     ||(g[i-][j].x==&&g[i-][j].y==)
                     ||(g[i-][j].x==&&g[i-][j].y==)) f[i][j]=f[i-][j];
                     if(f[i][j]) continue;
                     if((g[i][j-].x==&&g[i][j-].y==)
                     ||(g[i][j-].x==&&g[i][j-].y==)
                     ||(g[i][j-].x==&&g[i][j-].y==)
                     ||(g[i][j-].x==&&g[i][j-].y==)
                     ||(g[i][j-].x==&&g[i][j-].y==)) f[i][j]=f[i][j-];
                 }
                 if(g[i][j].x==&&g[i][j].y==){
                     if((g[i-][j].x==&&g[i-][j].y==)
                     ||(g[i-][j].x==&&g[i-][j].y==)
                     ||(g[i-][j].x==&&g[i-][j].y==)
                     ||(g[i-][j].x==&&g[i-][j].y==)
                     ||(g[i-][j].x==&&g[i-][j].y==)
                     ||(g[i-][j].x==&&g[i-][j].y==)) f[i][j]=f[i-][j];
                     if(f[i][j]) continue;
                     if((g[i][j-].x==&&g[i][j-].y==)
                     ||(g[i][j-].x==&&g[i][j-].y==)
                     ||(g[i][j-].x==&&g[i][j-].y==)
                     ||(g[i][j-].x==&&g[i][j-].y==)
                     ||(g[i][j-].x==&&g[i][j-].y==)) f[i][j]=f[i][j-];
                 }
                 if(g[i][j].x==&&g[i][j].y==){
                     if((g[i-][j].x==&&g[i-][j].y==)
                     ||(g[i-][j].x==&&g[i-][j].y==)
                     ||(g[i-][j].x==&&g[i-][j].y==)
                     ||(g[i-][j].x==&&g[i-][j].y==)
                     ||(g[i-][j].x==&&g[i-][j].y==)
                     ||(g[i-][j].x==&&g[i-][j].y==)) f[i][j]=f[i-][j];
                     if(f[i][j]) continue;
                     if((g[i][j-].x==&&g[i][j-].y==)
                     ||(g[i][j-].x==&&g[i][j-].y==)
                     ||(g[i][j-].x==&&g[i][j-].y==)
                     ||(g[i][j-].x==&&g[i][j-].y==)
                     ||(g[i][j-].x==&&g[i][j-].y==)) f[i][j]=f[i][j-];
                 }
             }
         if(f[n][m]){
             printf("Case %d:\n",cnt);
             puts("Well done!");
         }
         else{
             printf("Case %d:\n",cnt);
             puts("What a pity!");
         }
     }

     return ;
 } 

Problem J: 质方数

Description

小z很喜欢研究各种各样的数字，最近他迷上了质数和平方数，他把一个质数的平方命名为”质方数”，现在他想知道，给出一个正整数，距离这个正整数最近的质方数是什么？（如果有2个距离相等的质方数，选择较小的一个）

Input

输入数据组数为T（T<=50）,每组数据输入一个正整数n，其中1<=n<=100,000,000;

Output

对于每个测试样例，输出距离最近的质方数，每个样例占一行。

Sample Input

2

3

8

Sample Output

4

49

HINT

题目链接：http://gdutcode.sinaapp.com/problem.php?cid=1049&pid=9

思路：打表吧！之前也不知道懵了哪里，怎么都不会过，还有这道题很坑，官方数据都是有问题的！我只能膜拜出题君了！

下面给出AC代码：

 #include <bits/stdc++.h>
 using namespace std;
 bool gcd(int n)
 {
     if(n==)
         return true;
     else
     {
         for(int i=;i<=sqrt((double)n);i++)
         if(n%i==)
         return false;
     }
     return true;
 }
 int main()
 {
     int T,n;
     while(scanf("%d",&T)!=EOF)
     {
         while(T--)
         {
             scanf("%d",&n);
             int count1,count2;
             int c;
             if(n==)
                 cout<<<<endl;
             if(n==)
                 cout<<<<endl;
             else if(n>=)
             {
                 int x=n;
                 int y=n;
                 while(x--)
                     if(gcd(x))
                     {
                         count1=n-x;
                         break;
                     }
                 while(y++)
                     if(gcd(y))
                     {
                         count2=y-n;
                         break;
                     }
                 if(count1<=count2)
                 {
                     n=x;
                     c=count1;
                 }
                 else
                 {
                     n=y;
                     c=count2;
                 }
                 cout<<n*n<<endl;
             }
         }
     }
     return ;
 }