资源描述
Problem Description
Calculate A + B.
Input
Each line will contain two integers A and B. Process to end of file.
Output
For each case, output A + B in one line.
Sample Input
1 1
Sample Output
2
#include<stdio.h>
void main()
{
int a,b;
while(scanf("%d %d",&a,&b)!=EOF)
{
printf("%d\n",a+b);
}
}
Problem Description
Hey, welcome to HDOJ(Hangzhou Dianzi University Online Judge).
In this problem, your task is to calculate SUM(n) = 1 + 2 + 3 + ... + n.
Input
The input will consist of a series of integers n, one integer per line.
Output
For each case, output SUM(n) in one line, followed by a blank line. You may assume the result will be in the range of 32-bit signed integer.
Sample Input
1
100
Sample Output
1
5050
#include<stdio.h>
void main()
{
int n,sum,i;
while(scanf("%d",&n)!=EOF)
{
sum=0;
for( i=0;i<=n;i++)
sum+=i;
printf("%d\n\n",sum);
}
}
Problem Description
I have a very simple problem for you. Given two integers A and B, your job is to calculate the Sum of A + B.
Input
The first line of the input contains an integer T(1<=T<=20) which means the number of test cases. Then T lines follow, each line consists of two positive integers, A and B. Notice that the integers are very large, that means you should not process them by using 32-bit integer. You may assume the length of each integer will not exceed 1000.
Output
For each test case, you should output two lines. The first line is "Case #:", # means the number of the test case. The second line is the an equation "A + B = Sum", Sum means the result of A + B. Note there are some spaces int the equation. Output a blank line between two test cases.
Sample Input
2
1 2
112233445566778899 998877665544332211
Sample Output
Case 1:
1 + 2 = 3
Case 2:
112233445566778899 + 998877665544332211 = 1111111111111111110
#include <stdio.h>
#include <string.h>
int main(){
char str1[1001], str2[1001];
int t, i, len_str1, len_str2, len_max, num = 1, k;
scanf("%d", &t);
getchar();
while(t--){
int a[1001] = {0}, b[1001] = {0}, c[1001] = {0};
scanf("%s", str1);
len_str1 = strlen(str1);
for(i = 0; i <= len_str1 - 1; ++i)
a[i] = str1[len_str1 - 1 - i] - '0';
scanf("%s",str2);
len_str2 = strlen(str2);
for(i = 0; i <= len_str2 - 1; ++i)
b[i] = str2[len_str2 - 1 - i] - '0';
if(len_str1 > len_str2)
len_max = len_str1;
else
len_max = len_str2;
k = 0;
for(i = 0; i <= len_max - 1; ++i){
c[i] = (a[i] + b[i] + k) % 10;
k = (a[i] + b[i] + k) / 10;
}
if(k != 0)
c[len_max] = 1;
printf("Case %d:\n", num);
num++;
printf("%s + %s = ", str1, str2);
if(c[len_max] == 1)
printf("1");
for(i = len_max - 1; i >= 0; --i){
printf("%d", c[i]);
}
printf("\n");
if(t >= 1)
printf("\n");
}
return 0;
}
Problem Description
Given a sequence a[1],a[2],a[3]......a[n], your job is to calculate the max sum of a sub-sequence. For example, given (6,-1,5,4,-7), the max sum in this sequence is 6 + (-1) + 5 + 4 = 14.
Input
The first line of the input contains an integer T(1<=T<=20) which means the number of test cases. Then T lines follow, each line starts with a number N(1<=N<=100000), then N integers followed(all the integers are between -1000 and 1000).
Output
For each test case, you should output two lines. The first line is "Case #:", # means the number of the test case. The second line contains three integers, the Max Sum in the sequence, the start position of the sub-sequence, the end position of the sub-sequence. If there are more than one result, output the first one. Output a blank line between two cases.
Sample Input
2
5 6 -1 5 4 -7
7 0 6 -1 1 -6 7 -5
Sample Output
Case 1:
14 1 4
Case 2:
7 1 6
注：最大子序列是要找出由数组成的一维数组中和最大的连续子序列。比如{5,-3,4,2}的最大子序列就是 {5,-3,4,2}，它的和是8,达到最大；而 {5,-6,4,2}的最大子序列是{4,2}，它的和是6。你已经看出来了，找最大子序列的方法很简单，只要前i项的和还没有小于0那么子序列就一直向后扩展，否则丢弃之前的子序列开始新的子序列，同时我们要记下各个子序列的和，最后找到和最大的子序列
#include<stdio.h>
int a[100005],str[100005],start[100005];
int main()
{
int t,n,i,num=1,end,max,k;
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
for(i=1;i<=n;i++)
{
scanf("%d",&a[i]);
}
str[1]=a[1];start[1]=1;
for(i=2;i<=n;i++)
{
if(str[i-1]>=0)
{
str[i]=str[i-1]+a[i];
start[i]=start[i-1];
}
else
{
str[i]=a[i];
start[i]=i;
}
}
max=str[1];end=1;
for(k=2;k<=n;k++)
{
if(str[k]>max)
{
max=str[k];
end=k;
}
}
printf("Case %d:\n",num);
num++;
printf("%d %d %d\n",max,start[end],end);
if(t)
printf("\n");
}
return 0;
}
Problem Description
Contest time again! How excited it is to see balloons floating around. But to tell you a secret, the judges' favorite time is guessing the most popular problem. When the contest is over, they will count the balloons of each color and find the result.
This year, they decide to leave this lovely job to you.
Input
Input contains multiple test cases. Each test case starts with a number N (0 < N <= 1000) -- the total number of balloons distributed. The next N lines contain one color each. The color of a balloon is a string of up to 15 lower-case letters.
A test case with N = 0 terminates the input and this test case is not to be processed.
Output
For each case, print the color of balloon for the most popular problem on a single line. It is guaranteed that there is a unique solution for each test case.
Sample Input
5
green
red
blue
red
red
3
pink
orange
pink
0
Sample Output
red
pink
#include<stdio.h>
#include<string.h>
char a[1000][15];
int b[1000];
int main()
{
int n,i,j,max,k;
while(scanf("%d",&n)!=EOF)
{
if(n==0)
break;
for(i=1;i<=n;i++)
{
b[i]=0;
scanf("%s",a[i]); //二维数组的神奇用法
}
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
if(strcmp(a[i],a[j])==0)
{
b[i]++;
}
}
max=b[1];
k=1;
for(i=2;i<=n;i++)
{
if(b[i]>max)
{
max=b[i];
k=i;
}
}
printf("%s\n",a[k]);
}
return 0;
}
Problem Description
A number sequence is defined as follows:
f(1) = 1, f(2) = 1, f(n) = (A * f(n - 1) + B * f(n - 2)) mod 7.
Given A, B, and n, you are to calculate the value of f(n).
Input
The input consists of multiple test cases. Each test case contains 3 integers A, B and n on a single line (1 <= A, B <= 1000, 1 <= n <= 100,000,000). Three zeros signal the end of input and this test case is not to be processed.
Output
For each test case, print the value of f(n) on a single line.
Sample Input
1 1 3
1 2 10
0 0 0
Sample Output
2
5
方法1：注函数介绍
void *memset(void *s, int ch, size_t n);
函数解释：将s中前n个字节替换为ch并返回s；
memset:作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法。
#include <stdio.h>
#include <string.h>
int main(){
int b[7][7];
int a[100];
int n;
int x, y, m, st, len;
while (scanf("%d %d %d", &x, &y, &m) == 3){
if (x==0 && y==0 && m==0){
break;
}
a[1] = 1;
a[2] = 1;
memset(b, 0, sizeof(b));
b[1][1] = 1;
n = 3;
for (;;){
a[n] = (a[n-1]*x+a[n-2]*y)%7;
if (b[a[n-1]][a[n]] != 0){
break;
}
b[a[n-1]][a[n]] = n-1;
++n;
}//计算周期
st = b[a[n-1]][a[n]];
len = n-1-st;//len为周期
if (m < st){
printf("%d\n", a[m]);
}
else{
printf("%d\n", a[st+(m-st)%len]);
}
}
return 0;
}
方法二
简单递归应为模运算中（a+b）%p=(a%p+b%p)%p;所以循环周期为7*7=49；
#include<stdio.h>
int a,b;
int f(int n){
if(n==2||n==1) return 1;
else return (a*f(n-1)+b*f(n-2))%7;
}
main()
{
while(scanf("%d%d",&a,&b)!=EOF&&a&&b)
{
__int64 n;
int m;
scanf("%I64d",&n);
m=n%49;
printf("%d\n",f(m));
}
}
Problem Description
The three hands of the clock are rotating every second and meeting each other many times everyday. Finally, they get bored of this and each of them would like to stay away from the other two. A hand is happy if it is at least D degrees from any of the rest. You are to calculate how much time in a day that all the hands are happy.
Input
The input contains many test cases. Each of them has a single line with a real number D between 0 and 120, inclusively. The input is terminated with a D of -1.
Output
For each D, print in a single line the percentage of time in a day that all of the hands are happy, accurate up to 3 decimal places.
Sample Input
0
120
90
-1
Sample Output
100.000
0.000
6.251
这个钟是个物理的钟，也就是说秒针每一秒走6度之后，分针就走了10分之1度，然后时针又走了120分之1度，当然钟表盘一圈是360度了~或者还可以继续拆，秒针每千分之一秒走千分之6度，然后分针就走万分之1度，时针就走十二万分之1度，就这样……
只要知道他是一个连续的钟，那就什么都好解决了
首先我们有一个东西是必然可以知道的，在0点的时候三根针是重合的，然后在12点的时候三跟针就又重合了（操，我最开始的时候居然想的是24的时候三根针才再次重复），也就是说一天被分为两个周期，每个周期12个小时。所以，只要我们求出在一个周期中三根针满足条件的总时间，我们就可以知道一天中三根针满足条件的总时间。所占百分比也自然就出来了……
好了，这东西肯定不能暴力，如果你按一秒为梯度来暴力解出每一秒的时候三根针之间的间距，然后把总时间求和，精度肯定不够，甚至可能是错误的解，当然，如果你以万分之一秒为梯度来暴力求解的话，那有可能就达到题目的精度了，但是，多半也就超时了
所以，就只有解方程了……
好，最开始我想的是用三个方程，分别表示三根针随时间的变化的角度的变化，就是说第0秒秒针的角度是0度，第1秒是6度，第30秒是180度，第59秒时60-6度……
然后把两跟针的度数相减，就得到了他们之间相距的角度……不过，我发现这个好麻烦……而且整个方程和给定的角度D完全没有关系，也很难根据那个D来解出我们想要的结果……
所以，换了，将方程改为随时间变化的针之间相距的角度的方程，也是三个。
首先，我们知道每根针的角速度：
Vs = 6度每秒 （60秒走一圈360度 360/60=6）
Vm = 1/10度每秒（3600秒，一个小时走一圈， 360/3600=0.1）
Vh = 1/120度每秒（12小时走一圈，360/（3600*12）= 1/120）
然后，就可以得到每两根之间的速度差了：
Vsm = Vs - Vm = 6 - 1/10 = 59/10
Vsh = Vs - Vh = 6 - 1/120 = 719/120
Vmh = Vm - Vh = 1/10 - 1/120 = 11/120
然后，时间乘以速度等于距离。
然后我们可以算出来：
秒针和分针之间的夹角在时间t = 0的时候是0度，在t = 1800/59（59分之1800秒）的时候达到最大值180度，然后从59分之1800秒开始就开始减少，当时间t到达59分之3600秒的时候，秒针和分针之间的夹角就又是0度了。（算法：Vsm * t = 180 ，所以 t = 180/Vsm = 180 /（59/10） = (180 * 10)/ 59
时针和秒的0度-180度-0度这三个点的时间t分别是 0, 120*180/719, 120*180*2/719
时针和分针:0, 180*120/11, 180*120*2/11
所以：
Dsm = (59/10) * t 或者 360 - (59/10) * t
Dsh = (719/120) * t 或者 360 - (719/120) * t
Dmh = (11/120) * t 或者 360 - (11/120) * t
#include<stdio.h>
double max(double a,double b,double c)
{
a=a>b?a:b;
a=a>c?a:c;
return a;
}
double min(double a,double b,double c)
{
a=a<b?a:b;
a=a<c?a:c;
return a;
}
void main()
{
double s=60;
double m=60*60;
double h=12*60*60;
double ws=360/s;
double wm=360/m;
double wh=360/h;
double wsm=ws-wm;
double wsh=ws-wh;
double wmh=wm-wh;
double tsm=360/(ws-wm);
double tsh=360/(ws-wh);
double tmh=360/(wm-wh);
double dsm[1444];
double dsh[1444];
double dmh[26];
double D;
while(scanf("%lf",&D)!=EOF&&D!=-1)
{
int i,j;
int sp[2],mp[2],hp[2];
double sum=0;
double x=0,y=0;
dsm[0]=(D*10)/59;
dsh[0]=(D*120)/719;
dmh[0]=(D*120)/11;
dsm[1]=tsm-dsm[0];
dsh[1]=tsh-dsh[0];
dmh[1]=tmh-dmh[0];
for(i=2,j=3;;i+=2,j+=2)
{
dsm[i]=dsm[i-2]+tsm;
dsm[j]=dsm[j-2]+tsm;
if(dsm[i]>43200&&dsm[j]>43200)
break;
}
for(i=2,j=3;;i+=2,j+=2)
{
dsh[i]=dsh[i-2]+tsh;
dsh[j]=dsh[j-2]+tsh;
if(dsh[i]>43200&&dsh[j]>43200)
break;
}
for(i=2,j=3;;i+=2,j+=2)
{
dmh[i]=dmh[i-2]+tmh;
dmh[j]=dmh[j-2]+tmh;
if(dmh[i]>43200&&dmh[j]>43200)
break;
}
sp[0]=mp[0]=hp[0]=0;
sp[1]=mp[1]=hp[1]=1;
while(y<=43200 && x<=43200)
{
x=max(dsm[sp[0]],dsh[mp[0]],dmh[hp[0]]);
y=min(dsm[sp[1]],dsh[mp[1]],dmh[hp[1]]);
if(x<y)
sum+=y-x;
if(y==dsm[sp[1]]) {sp[0]+=2;sp[1]+=2;}
if(y==dsh[mp[1]]) {mp[0]+=2;mp[1]+=2;}
if(y==dmh[hp[1]]) {hp[0]+=2;hp[1]+=2;}
}
printf("%.3lf\n",sum/432);
}
}
（不会）Problem Description
Have you ever played quoit in a playground? Quoit is a game in which flat rings are pitched at some toys, with all the toys encircled awarded.
In the field of Cyberground, the position of each toy is fixed, and the ring is carefully designed so it can only encircle one toy at a time. On the other hand, to make the game look more attractive, the ring is designed to have the largest radius. Given a configuration of the field, you are supposed to find the radius of such a ring.
Assume that all the toys are points on a plane. A point is encircled by the ring if the distance between the point and the center of the ring is strictly less than the radius of the ring. If two toys are placed at the same point, the radius of the ring is considered to be 0.
Input
The input consists of several test cases. For each case, the first line contains an integer N (2 <= N <= 100,000), the total number of toys in the field. Then N lines follow, each contains a pair of (x, y) which are the coordinates of a toy. The input is terminated by N = 0.
Output
For each test case, print in one line the radius of the ring required by the Cyberground manager, accurate up to 2 decimal places.
Sample Input
2
0 0
1 1
2
1 1
1 1
3
-1.5 0
0 0
0 1.5
0
Sample Output
0.71
0.00
0.75
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iostream>
using namespace std;
const int maxn=100011;
int n;
int q[maxn];
double x[maxn],y[maxn];
inline double dis( double x1, double y1, double x2, double y2 )
{
return sqrt( (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2) );
}
void qsortX( int l, int r )//对?数ºy组Á¨¦进?行D排?序¨°（ꡧ横¨¢坐Á?标À¨º从䨮小?到Ì?大䨮）ê?
{
int i=l,
j=r;
double mid=x[(l+r)/2];
do
{
while ( x[i]<mid ) i++;
while ( x[j]>mid ) j--;
if ( i<=j )
{
swap( x[i], x[j] );
swap( y[i], y[j] );
i++;
j--;
}
}
while ( i<=j );
if ( i<r ) qsortX( i, r );
if ( l<j ) qsortX( l, j );
}
void qsortY( int l, int r )
{
int i=l,
j=r;
double mid=y[q[(l+r)/2]];
do
{
while ( y[q[i]]<mid ) i++;
while ( y[q[j]]>mid ) j--;
if ( i<=j )
{
swap( q[i], q[j] );
i++;
j--;
}
}
while ( i<=j );
if ( i<r ) qsortY( i, r );
if ( l<j ) qsortY( l, j );
}
double findMin( int l, int r )
{
if ( l==r ) return 99999999;
if ( l+1==r ) return dis( x[l], y[l], x[r], y[r] );
double t1=findMin( l, (l+r)/2 ),//递ÌY归¨¦，ê?分¤?治?思?想?，ê?把ã?大䨮问¨º题¬a看¡ä若¨?干¨¦个?小?问¨º题¬a
t2=findMin( (l+r)/2+1, r ),
mid=(x[l]+x[r])/2,
min;
展开阅读全文
浙ICP备2021020529号-1 | 浙B2-20240490 
