2016ACM/ICPC亚洲区大连站现场赛题解报告（转）

时间  2019-11-10
标签 2016acm acm icpc 现场 题解 报告 栏目 应用数学 繁體版
原文   原文链接

http://blog.csdn.net/queuelovestack/article/details/53055418php

 

 

下午重现了一下大连赛区的比赛,感受有点神奇,重现时竟然改了现场赛的数据范围,本来过的人数比较多的题结果重现过的变少了,而本来现场赛全场过的人最少的题重现作出的人反而多了一堆,不过仍是不影响最水的6题,然而残酷的现实是6题才有机会拿铜...(╥╯^╰╥)java

连接→2016ACM/ICPC亚洲区大连站-重现赛node

 

 Problem 1001 Wrestling Match

Accept: 0    Submit: 0
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)
ios

 Problem Description

Nowadays, at least one wrestling match is held every year in our country. There are a lot of people in the game is "good player”, the rest is "bad player”. Now, Xiao Ming is referee of the wrestling match and he has a list of the matches in his hand. At the same time, he knows some people are good players,some are bad players. He believes that every game is a battle between the good and the bad player. Now he wants to know whether all the people can be divided into "good player" and "bad player". git

 

 Input

Input contains multiple sets of data.For each set of data,there are four numbers in the first line:N (1 ≤ N≤ 1000)、M(1 ≤M ≤ 10000)、X,Y(X+Y≤N ),in order to show the number of players(numbered 1toN ),the number of matches,the number of known "good players" and the number of known "bad players".In the next M lines,Each line has two numbersa, b(a≠b) ,said there is a game between a and b .The next line has X different numbers.Each number is known as a "good player" number.The last line contains Y different numbers.Each number represents a known "bad player" number.Data guarantees there will not be a player number is a good player and also a bad player.app

 

 Output

If all the people can be divided into "good players" and "bad players”, output "YES", otherwise output "NO".ide

 Sample Input

5 4 0 0
1 3
1 4
3 5
4 5
5 4 1 0
1 3
1 4
3 5
4 5
2

 Sample Output

NO
YES

 Problem Idea

 

解题思路:svg

【题意】优化

这个题目意思，感受仍是存疑的(￣へ￣)，我只能以本人过了此题的想法来解释ui

N个选手，M场摔跤比赛，已知N个选手中有X个选手是"good player"，Y个选手是"bad player"

问是否能够将N个选手划分红"good player"和"bad player"两个阵营，使得每场摔跤比赛的两位选手一定是一位来自"good player"，一位来自"bad player"

【类型】
搜索(bfs or dfs)
【分析】

有挺多人要求解释样例的，由于不太明白为啥不告诉2是哪个阵营就没法划分阵营了？明明(1,5)和(3,4)也不知道是哪一阵营

可是，咱们能够这样理解一下，即使我不知道(1,5)是属于"good player"阵营仍是属于"bad player"阵营，他们只能属于一种阵营

而2是没有告诉你和其余选手的关系，那么2能够同属于两个阵营，显然这与题目要求" there will not be a player number is a good player and also a bad player"不符

好了，接下来说作法，首先考虑已经告诉你是哪一个阵营的选手A，那么和A选手比赛的选手B一定对立阵营的，若选手B和选手A是同一阵营，那显然是没法继续划分的，bfs or dfs一下，将已知阵营的选手肯定

而后开始处理未知阵营但有比赛的选手，咱们彻底能够假设其中一方为"good player"，那么另外一方就是"bad player"，接着仍是bfs or dfs判断

处理完以后，再遍历一遍每一个选手，看是否还有未知阵营的选手存在便可

重现的时候被本身蠢哭了，(ಥ _ ಥ)，由于每输入一个已知阵营的选手，我都会去搜索判一次，而后遇到冲突就break了，致使题目尚未彻底输入就被我结束了，因而WA了好几发，心疼本身

【时间复杂度&&优化】
O(n)

题目连接→HDU 5971 Wrestling Match

 Source Code

 

[cpp]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. /*Sherlock and Watson and Adler*/  
  2. #pragma comment(linker, "/STACK:1024000000,1024000000")  
  3. #include<stdio.h>  
  4. #include<string.h>  
  5. #include<stdlib.h>  
  6. #include<queue>  
  7. #include<stack>  
  8. #include<math.h>  
  9. #include<vector>  
  10. #include<map>  
  11. #include<set>  
  12. #include<list>  
  13. #include<bitset>  
  14. #include<cmath>  
  15. #include<complex>  
  16. #include<string>  
  17. #include<algorithm>  
  18. #include<iostream>  
  19. #define eps 1e-9  
  20. #define LL long long  
  21. #define PI acos(-1.0)  
  22. #define bitnum(a) __builtin_popcount(a)  
  23. using namespace std;  
  24. const int N = 1005;  
  25. const int M = 10005;  
  26. const int inf = 1000000007;  
  27. const int mod = 1000000007;  
  28. struct edge  
  29. {  
  30.     int v,to;  
  31. }e[2*M];  
  32. struct node  
  33. {  
  34.     int u,k;  
  35.     node(){}  
  36.     node(int _u,int _k):u(_u),k(_k){}  
  37. };  
  38. int p,v[N],a[M],b[M],h[N];  
  39. bool flag;  
  40. void add_edge(int u,int v)  
  41. {  
  42.     e[p].v=v;  
  43.     e[p].to=h[u];  
  44.     h[u]=p++;  
  45. }  
  46. void bfs(int u,int k)  
  47. {  
  48.     queue<node> q;  
  49.     int i;  
  50.     v[u]=k;  
  51.     q.push(node(u,k));  
  52.     while(!q.empty())  
  53.     {  
  54.         u=q.front().u;  
  55.         k=q.front().k;  
  56.         q.pop();  
  57.         for(i=h[u];i+1;i=e[i].to)  
  58.         {  
  59.             if(v[e[i].v]==k)  
  60.             {  
  61.                 flag=false;  
  62.                 return ;  
  63.             }  
  64.             if(!v[e[i].v])  
  65.             {  
  66.                 v[e[i].v]=-k;  
  67.                 q.push(node(e[i].v,-k));  
  68.             }  
  69.         }  
  70.     }  
  71. }  
  72. int main()  
  73. {  
  74.     int n,m,x,y,s,i;  
  75.     while(~scanf("%d%d%d%d",&n,&m,&x,&y))  
  76.     {  
  77.         p=0;  
  78.         flag=true;  
  79.         memset(v,0,sizeof(v));  
  80.         memset(h,-1,sizeof(h));  
  81.         for(i=0;i<m;i++)  
  82.         {  
  83.             scanf("%d%d",&a[i],&b[i]);  
  84.             add_edge(a[i],b[i]);  
  85.             add_edge(b[i],a[i]);  
  86.         }  
  87.         for(i=0;i<x;i++)  
  88.         {  
  89.             scanf("%d",&s);  
  90.             if(v[s]==-1)  
  91.                 flag=false;  
  92.             bfs(s,1);  
  93.         }  
  94.         for(i=0;i<y;i++)  
  95.         {  
  96.             scanf("%d",&s);  
  97.             if(v[s]==1)  
  98.                 flag=false;  
  99.             bfs(s,-1);  
  100.         }  
  101.         for(i=0;i<m&&flag;i++)  
  102.             if(!v[a[i]]&&!v[b[i]])  
  103.                 bfs(a[i],1);  
  104.         for(i=1;i<=n&&flag;i++)  
  105.             if(!v[i])  
  106.             {  
  107.                 flag=false;  
  108.                 break;  
  109.             }  
  110.         if(flag)  
  111.             puts("YES");  
  112.         else  
  113.             puts("NO");  
  114.     }  
  115.     return 0;  
  116. }  

 

 

 Problem 1004 A Simple Math Problem

Accept: 0    Submit: 0
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)

 Problem Description

Given two positive integers a and b,find suitable X and Y to meet the conditions: 

 X+Y=a 

 Least Common Multiple (X, Y) =b

 

 Input

Input includes multiple sets of test data.Each test data occupies one line,including two positive integers a(1≤a≤2*10^4),b(1≤b≤10^9),and their meanings are shown in the description.Contains most of the 12W test cases.

 

 Output

For each set of input data,output a line of two integers,representing X, Y.If you cannot find such X and Y,output one line of "No Solution"(without quotation).

 Sample Input

6 8
798 10780

 Sample Output

No Solution
308 490

 Problem Idea

 

解题思路:

【题意】

给你两个整数a和b

求X和Y，知足X+Y=a，且LCM(X,Y)=b [LCM(X,Y)表示X和Y的最小公倍数]

若不存在，输出"No Solution"

不然输出X最小的解

【类型】
数学推导题
【分析】

现场赛的时候，咋看一眼感受是水题啊，a的范围才10^4，那我枚举一下X和Y，而后判断它们的最小公倍数是否是b不就完事了？

但看作的人并很少，又仔细看了下题，发现题目组数有点多，12万，好吧，放弃暴力枚举

首先，学过最小公倍数的咱们知道，两数之积等于两数的最大公约数乘最小公倍数，用式子表示以下

X*Y=LCM(X,Y)*GCD(X,Y)

因而，咱们不妨假设GCD(X,Y)=k，那么咱们能够知道

假设X≥Y，则

这个方程组仍是好解的

无解的状况有以下三种(知足任意一种都是无解):

【时间复杂度&&优化】
O(1)

题目连接→HDU 5974 A Simple Math Problem

 Source Code

 

[cpp]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. /*Sherlock and Watson and Adler*/  
  2. #pragma comment(linker, "/STACK:1024000000,1024000000")  
  3. #include<stdio.h>  
  4. #include<string.h>  
  5. #include<stdlib.h>  
  6. #include<queue>  
  7. #include<stack>  
  8. #include<math.h>  
  9. #include<vector>  
  10. #include<map>  
  11. #include<set>  
  12. #include<list>  
  13. #include<bitset>  
  14. #include<cmath>  
  15. #include<complex>  
  16. #include<string>  
  17. #include<algorithm>  
  18. #include<iostream>  
  19. #define eps 1e-9  
  20. #define LL long long  
  21. #define PI acos(-1.0)  
  22. #define bitnum(a) __builtin_popcount(a)  
  23. using namespace std;  
  24. const int N = 1005;  
  25. const int M = 10005;  
  26. const int inf = 1000000007;  
  27. const int mod = 1000000007;  
  28. __int64 gcd(__int64 a,__int64 b)  
  29. {  
  30.     if(a%b)  
  31.         return gcd(b,a%b);  
  32.     return b;  
  33. }  
  34. int main()  
  35. {  
  36.     __int64 a,b,k,d,X,Y,s;  
  37.     while(~scanf("%I64d%I64d",&a,&b))  
  38.     {  
  39.         k=gcd(a,b);  
  40.         d=a*a-4*k*b;  
  41.         if(d<0)  
  42.         {  
  43.             puts("No Solution");  
  44.             continue;  
  45.         }  
  46.         s=(__int64)sqrt(1.0*d);  
  47.         if(s*s!=d||(s+a)%2)  
  48.         {  
  49.             puts("No Solution");  
  50.             continue;  
  51.         }  
  52.         X=(s+a)/2;  
  53.         Y=a-X;  
  54.         if(X>Y)  
  55.             swap(X,Y);  
  56.         printf("%I64d %I64d\n",X,Y);  
  57.   
  58.     }  
  59.     return 0;  
  60. }  

 

 

 Problem 1006 Detachment

Accept: 0    Submit: 0
Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)

 Problem Description

In a highly developed alien society, the habitats are almost infinite dimensional space.

In the history of this planet,there is an old puzzle.

You have a line segment with x units’ length representing one dimension.The line segment can be split into a number of small line segments: a1,a2, … (x= a1+a2+…) assigned to different dimensions. And then, the multidimensional space has been established. Now there are two requirements for this space: 

1．Two different small line segments cannot be equal ( ai≠aj when i≠j).

2．Make this multidimensional space size s as large as possible (s= a1∗a2*...).Note that it allows to keep one dimension.That's to say, the number of ai can be only one.

Now can you solve this question and find the maximum size of the space?(For the final number is too large,your answer will be modulo 10^9+7)

 

 Input

The first line is an integer T,meaning the number of test cases.

Then T lines follow. Each line contains one integer x.

1≤T≤10^6, 1≤x≤10^9

 

 Output

Maximum s you can get modulo 10^9+7. Note that we wants to be greatest product before modulo 10^9+7.

 Sample Input

1
4

 Sample Output

4

 Problem Idea

 

解题思路:

【题意】

给定一个天然数x，让你给出一种拆分方式x=a1+a2+...(ai≠aj)，使得每一个小部分的乘积s=a1*a2*...最大

【类型】
贪心构造
【分析】

此题关键在于得出如何能使乘积s最大

按照以往经验，必然是取一段连续天然数可以使得乘积最大，而这段连续天然数可从2开始(为啥不从1开始?从1开始还不如将这个1给这段连续天然数的最后一个数)，因而咱们能够获得形如2+3+4+...+k(k=2,3,...)的式子，而x是10^9内的任意整数，咱们不可能刚好可以凑成连续天然数之和，可能会多出△x

而这个△x的值，我能够保证它的范围为0≤△x≤k，相信大于等于0仍是好理解的，为何会小于等于k呢?由于当它大于k时，原式不是能够增长一项?即2+3+4+...+k+(k+1)

那么多出来的△x怎么处理呢?显然是从后往前均摊给连续天然数中的(k-1)个数，为啥从后往前?由于若咱们从前日后，老是会使连续天然数重复，很差处理

因而，在咱们分配完△x以后，咱们大体会获得下述两种式子:

①2*3*...*(i-1)*(i+1)*...*k*(k+1)

②3*4*...*i*(i+1)*...*k*(k+2)

显然，咱们要计算此结果，能够借助阶乘，而阶乘中缺失的项，咱们除掉就能够了，那么便会涉及除法取模，显然须要用到乘法逆元

作法讲解完毕，如下是为何连续段乘积最大的大概证实:

【时间复杂度&&优化】
O(logn)

题目连接→HDU 5976 Detachment

 Source Code

 

[cpp]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. /*Sherlock and Watson and Adler*/  
  2. #pragma comment(linker, "/STACK:1024000000,1024000000")  
  3. #include<stdio.h>  
  4. #include<string.h>  
  5. #include<stdlib.h>  
  6. #include<queue>  
  7. #include<stack>  
  8. #include<math.h>  
  9. #include<vector>  
  10. #include<map>  
  11. #include<set>  
  12. #include<list>  
  13. #include<bitset>  
  14. #include<cmath>  
  15. #include<complex>  
  16. #include<string>  
  17. #include<algorithm>  
  18. #include<iostream>  
  19. #define eps 1e-9  
  20. #define LL long long  
  21. #define PI acos(-1.0)  
  22. #define bitnum(a) __builtin_popcount(a)  
  23. using namespace std;  
  24. const int N = 45000;  
  25. const int M = 10005;  
  26. const int inf = 1000000007;  
  27. const int mod = 1000000007;  
  28. __int64 inv[N]={0,1};//逆元筛  
  29. __int64 f[N]={1,1};//阶乘  
  30. int main()  
  31. {  
  32.     int t,i,x,l,r,mid,k;  
  33.     __int64 ans;  
  34.     for(i=2;i<N;i++)  
  35.     {  
  36.         inv[i]=inv[mod%i]*(mod-mod/i)%mod;  
  37.         f[i]=(f[i-1]*i)%mod;  
  38.     }  
  39.     scanf("%d",&t);  
  40.     while(t--)  
  41.     {  
  42.         scanf("%d",&x);  
  43.         if(x<=1)  
  44.         {  
  45.             printf("%d\n",x);  
  46.             continue;  
  47.         }  
  48.         l=k=2,r=N;  
  49.         while(l<=r)  
  50.         {  
  51.             mid=(l+r)/2;  
  52.             if((mid+2)*(mid-1)/2<=x)  
  53.                 l=mid+1,k=max(k,mid);  
  54.             else  
  55.                 r=mid-1;  
  56.         }  
  57.         //printf("%d\n",k);  
  58.         x-=(k+2)*(k-1)/2;  
  59.         if(x==k)//3*4*...*(k-1)*k*(k+2)  
  60.             ans=(f[k]*inv[2])%mod*(k+2)%mod;  
  61.         else if(x==0)  
  62.             ans=f[k];  
  63.         else  
  64.             ans=(f[k+1]*inv[k-x+1])%mod;  
  65.         printf("%I64d\n",ans);  
  66.     }  
  67.     return 0;  
  68. }  

 

 

 Problem 1008 To begin or not to begin

Accept: 0    Submit: 0
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)

 Problem Description

A box contains black balls and a single red ball. Alice and Bob draw balls from this box without replacement, alternating after each draws until the red ball is drawn. The game is won by the player who happens to draw the single red ball. Bob is a gentleman and offers Alice the choice of whether she wants to start or not. Alice has a hunch that she might be better off if she starts; after all, she might succeed in the first draw. On the other hand, if her first draw yields a black ball, then Bob’s chances to draw the red ball in his first draw are increased, because then one black ball is already removed from the box. How should Alice decide in order to maximize her probability of winning? Help Alice with decision.

 

 Input

Multiple test cases (number of test cases≤50), process till end of input.

For each case, a positive integer k (1≤k≤10^5) is given on a single line.

 

 Output

For each case, output:

1, if the player who starts drawing has an advantage

2, if the player who starts drawing has a disadvantage

0, if Alice's and Bob's chances are equal, no matter who starts drawing

on a single line.

 Sample Input

1
2

 Sample Output

0
1

 Problem Idea

 

解题思路:

【题意】

箱子里有1个红球和k个黑球

Alice和Bob轮流不放回地从箱子里随机取出一个球

当某人取到红球时得到胜利，游戏结束

问先手是否获胜概率更大，概率更大，输出"1"；概率更小，输出"2"；概率相等，输出"0"

【类型】
几率水题
【分析】

此题关键仍是要多尝试，手动计算一下

当k=1时，一个红球和一个黑球，先手获胜的几率P为

当k=2时，一个红球和两个黑球，先手获胜的几率P为

当k=3时，一个红球和三个黑球，先手获胜的几率P为

故，当k时，先手获胜的几率P为

那我只需判断二者大小关系便可

【时间复杂度&&优化】
O(1)

题目连接→HDU 5978 To begin or not to begin

 Source Code

 

[cpp]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. /*Sherlock and Watson and Adler*/  
  2. #pragma comment(linker, "/STACK:1024000000,1024000000")  
  3. #include<stdio.h>  
  4. #include<string.h>  
  5. #include<stdlib.h>  
  6. #include<queue>  
  7. #include<stack>  
  8. #include<math.h>  
  9. #include<vector>  
  10. #include<map>  
  11. #include<set>  
  12. #include<list>  
  13. #include<bitset>  
  14. #include<cmath>  
  15. #include<complex>  
  16. #include<string>  
  17. #include<algorithm>  
  18. #include<iostream>  
  19. #define eps 1e-9  
  20. #define LL long long  
  21. #define PI acos(-1.0)  
  22. #define bitnum(a) __builtin_popcount(a)  
  23. using namespace std;  
  24. const int N = 5005;  
  25. const int M = 100005;  
  26. const int inf = 1000000007;  
  27. const int mod = 1000000007;  
  28. const int MAXN = 100005;  
  29. int main()  
  30. {  
  31.     int k,p;  
  32.     while(~scanf("%d",&k))  
  33.     {  
  34.         p=k/2+1;  
  35.         if(p>k+1-p)  
  36.             puts("1");  
  37.         else if(p<k+1-p)  
  38.             puts("2");  
  39.         else  
  40.             puts("0");  
  41.     }  
  42.     return 0;  
  43. }  

 

 

 Problem 1009 Convex

Accept: 0    Submit: 0
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)

 Problem Description

We have a special convex that all points have the same distance to origin point.
As you know we can get N segments after linking the origin point and the points on the convex. We can also get N angles between each pair of the neighbor segments.

Now give you the data about the angle, please calculate the area of the convex

 

 Input

There are multiple test cases.

The first line contains two integer N and D indicating the number of the points and their distance to origin. (3 <= N <= 10, 1 <= D <= 10)

The next lines contain N integers indicating the angles. The sum of the N numbers is always 360.

 

 Output

For each test case output one float numbers indicating the area of the convex. The printed values should have 3 digits after the decimal point.

 Sample Input

4 1
90 90 90 90
6 1
60 60 60 60 60 60

 Sample Output

2.000
2.598

 Problem Idea

 

解题思路:

【题意】

二维坐标中有N个点，它们到原点的距离均为D

将这N个点分别与原点相连，如今告诉你任意相邻两条线段的夹角为θi，求这N个点构成的凸包面积(N边形面积)

【类型】
三角形面积水题
【分析】

题目大概样子以下

由图可知，n边形的面积能够拆分红n个三角形面积之和

而已知每一个三角形的两边及两边夹角，咱们能够经过三角形面积公式算出每一个三角形的面积，相加之和即是最终的n边形面积

因为math.h头文件中封装的sin运算是以弧度制来计算的，而题目所给的是角度制，故咱们还需多一步角度转弧度

【时间复杂度&&优化】
O(1)

题目连接→HDU 5979 Convex

 Source Code

 

[cpp]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. /*Sherlock and Watson and Adler*/  
  2. #pragma comment(linker, "/STACK:1024000000,1024000000")  
  3. #include<stdio.h>  
  4. #include<string.h>  
  5. #include<stdlib.h>  
  6. #include<queue>  
  7. #include<stack>  
  8. #include<math.h>  
  9. #include<vector>  
  10. #include<map>  
  11. #include<set>  
  12. #include<list>  
  13. #include<bitset>  
  14. #include<cmath>  
  15. #include<complex>  
  16. #include<string>  
  17. #include<algorithm>  
  18. #include<iostream>  
  19. #define eps 1e-9  
  20. #define LL long long  
  21. #define PI acos(-1.0)  
  22. #define bitnum(a) __builtin_popcount(a)  
  23. using namespace std;  
  24. const int N = 5005;  
  25. const int M = 100005;  
  26. const int inf = 1000000007;  
  27. const int mod = 1000000007;  
  28. const int MAXN = 100005;  
  29. int main()  
  30. {  
  31.     int n,d,i,x;  
  32.     double ans;  
  33.     while(~scanf("%d%d",&n,&d))  
  34.     {  
  35.         ans=0;  
  36.         for(i=0;i<n;i++)  
  37.         {  
  38.             scanf("%d",&x);  
  39.             ans+=d*d*sin(PI*x/180)/2;  
  40.         }  
  41.         printf("%.3f\n",ans);  
  42.     }  
  43.     return 0;  
  44. }  

 

 

 Problem 1010 Find Small A

Accept: 0    Submit: 0
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)

 Problem Description

As is known to all,the ASCII of character 'a' is 97. Now,find out how many character 'a' in a group of given numbers. Please note that the numbers here are given by 32 bits’ integers in the computer.That means,1digit represents 4 characters(one character is represented by 8 bits’ binary digits).

 

 Input

The input contains a set of test data.The first number is one positive integer N (1≤N≤100),and then N positive integersai (1≤ ai≤2^32 - 1) follow

 

 Output

Output one line,including an integer representing the number of 'a' in the group of given numbers.

 Sample Input

3
97 24929 100

 Sample Output

3

 Problem Idea

 

解题思路:

【题意】

给你n个32位整数,每一个整数能够表示成4个字符(由于一个字符在计算机中占8位)，问n个整数共包含多少个字符'a'

【类型】
签到题
【分析】

因为一个字符占二进制8位，因此每一个整数至关于转化为2^8=256进制数

那么将32位整数循环对256取模，看是否是97(字符'a')便可

其中须要注意的一点是，2^32-1已经超过了int型的范围，故须定义成 __int64 或 long long

int型的最大值为2^31-1

【时间复杂度&&优化】
O(1)

题目连接→HDU 5980 Find Small A

 Source Code

 

[cpp]  view plain  copy
 
 print?在CODE上查看代码片派生到个人代码片
  1. /*Sherlock and Watson and Adler*/  
  2. #pragma comment(linker, "/STACK:1024000000,1024000000")  
  3. #include<stdio.h>  
  4. #include<string.h>  
  5. #include<stdlib.h>  
  6. #include<queue>  
  7. #include<stack>  
  8. #include<math.h>  
  9. #include<vector>  
  10. #include<map>  
  11. #include<set>  
  12. #include<list>  
  13. #include<bitset>  
  14. #include<cmath>  
  15. #include<complex>  
  16. #include<string>  
  17. #include<algorithm>  
  18. #include<iostream>  
  19. #define eps 1e-9  
  20. #define LL long long  
  21. #define PI acos(-1.0)  
  22. #define bitnum(a) __builtin_popcount(a)  
  23. using namespace std;  
  24. const int N = 5005;  
  25. const int M = 100005;  
  26. const int inf = 1000000007;  
  27. const int mod = 1000000007;  
  28. const int MAXN = 100005;  
  29. int main()  
  30. {  
  31.     int n,i,ans;  
  32.     __int64 a;  
  33.     while(~scanf("%d",&n))  
  34.     {  
  35.         ans=0;  
  36.         for(i=0;i<n;i++)  
  37.         {  
  38.             scanf("%I64d",&a);  
  39.             while(a)  
  40.             {  
  41.                 if(a%256==97)  
  42.                     ans++;  
  43.                 a/=256;  
  44.             }  
  45.         }  
  46.         printf("%d\n",ans);  
  47.     }  
  48.     return 0;  
  49. }  
菜鸟成长记
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程