原題：
When participating in programming contests, you sometimes face the following problem: You know
how to calcutale the output for the given input values, but your algorithm is way to o slow to ever
pass the time limit. However hard you try, you just can’t discover the prop er break-off conditions that
would bring down the numb er of iterations to within acceptable limits.
Now if the range of input values is not to o big, there is a way out of this. Let your PC rattle for half
an hour and pro duce a table of answers for all p ossible input values, enco de this table into a program,
submit it to the judge, et voila: Accepted in 0.000 seconds! (Some would argue that this is cheating,
but rememb er: In love and programming contests everything is p ermitted).
Faced with this problem during one programming contest, Jimmy decided to apply such a ’technique’. But however hard he tried, he wasn’t able to squeeze all his pre-calculated values into a program
small enough to pass the judge. The situation lo oked hop eless, until he discovered the following property regarding the answers: the answers where calculated from two integers, but whenever the two
input values had a common factor, the answer could b e easily derived from the answer for which the
input values were divided by that factor. To put it in other words:
Say Jimmy had to calculate a function
Answer(x, y) wherex
andy
are both integers in the range
[1, N]. When he knowsAnswer(x,
y), he can easily deriveAnswer(k∗
x, k∗
y), wherek
is any integer
from it by applying some simple calculations involvingAnswer(x, y)
andk.
For example if
N = 4, he only needs to know the answers for 11 out of the 16 possible input value
combinations:
Answer(1,1),
Answer(1,2),
Answer(2,1),
Answer(1,3),
Answer(2,3),
Answer(3,2),
Answer(3,1),
Answer(1,4),
Answer(3,4),
Answer(4,3) and
Answer(4,1). The other 5 can be derived from them
(Answer(2,2),
Answer(3,3) and
Answer(4,4) from
Answer(1,1),
Answer(2,4) from
Answer(1,2), and
Answer(4,2) from
Answer(2,1)). Note that the function
Answer is not symmetric,
so Answer(3,2) can not
be derived from Answer(2,3).
Now what we want you to do is: for any values of
N from 1 upto and including 50000, give the
number of function Jimmy has to pre-calculate.
Input
The input file contains at most 600 lines of inputs. Each line contains an integer less than 50001 which
indicates the value of
N. Input is terminated by a line which contains a zero. This line should not be
processed.
Output
For each line of input produce one line of output. This line contains an integer which indicates how
many values Jimmy has to pre-calculate for a certain value ofN.
Sample Input
250
Sample Output
3
19
題意：
對於兩個整數x,y，定義二元組(x,y)與二元組(x*k,y*k) （k爲正整數）重複（即只保留(x,y)即可），對於1<=x,y<=n，求最簡有多少個不重複的二元組。
思路：
本質爲x,y互素的二元組有多少個，設當x<y時，有f(n)個這樣的二元組，則可轉化爲歐拉函數求解小於y且與y互素的正整數有多少個，即f(n)=phi(2)+phi(3)+……+phi(n)。同理x>y時，f(n)=phi(2)+phi(3)+……+phi(n)。當x=y時，只有x=y=1時互素，則答案爲2*f(n)+1。
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <queue>
#include <deque>
#include <string>
#include <cmath>
#include <vector>
#include <utility>
#include <set>
#include <map>
#include <climits>
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#define INF 2147483647
using namespace std;
typedef long long ll;
int N,phi[50005];
void phi_table(int n,ll &ans)
{
memset(phi,0,sizeof(phi));
phi[1]=1;
for(int i=2; i<=n; i++)
{
if(!phi[i])
for(int j=i; j<=n; j+=i)
{
if(!phi[j])
phi[j]=j;
phi[j]=phi[j]/i*(i-1);
}
ans+=phi[i];
}
}
int main()
{
while(scanf("%d",&N)&&N)
{
ll res=0;
phi_table(N,res);
printf("%lld\n",2*res+1);
}
return 0;
}