Bi-shoe and Phi-shoe

最新推荐文章于 2020-01-08 16:43:58 发布

onion___

最新推荐文章于 2020-01-08 16:43:58 发布

阅读量194

点赞数

分类专栏： OJ题目综合

本文链接：https://blog.csdn.net/onion___/article/details/78479549

版权

OJ题目综合专栏收录该内容

18 篇文章 0 订阅

订阅专栏

A - Bi-shoe and Phi-shoe LightOJ - 1370

题目链接： https://cn.vjudge.net/contest/183461#problem

Bamboo Pole-vault is a massively popular sport in Xzhiland. And Master Phi-shoe is a very popular coach for his success. He needs some bamboos for his students, so he asked his assistant Bi-Shoe to go to the market and buy them. Plenty of Bamboos of all possible integer lengths (yes!) are available in the market. According to Xzhila tradition,

Score of a bamboo = Φ (bamboo’s length)

(Xzhilans are really fond of number theory). For your information, Φ (n) = numbers less thann which are relatively prime (having no common divisor other than 1) ton. So, score of a bamboo of length 9 is 6 as 1, 2, 4, 5, 7, 8 are relatively prime to 9.

The assistant Bi-shoe has to buy one bamboo for each student. As a twist, each pole-vault student of Phi-shoe has a lucky number. Bi-shoe wants to buy bamboos such that each of them gets a bamboo with a score greater than or equal to his/her lucky number. Bi-shoe wants to minimize the total amount of money spent for buying the bamboos. One unit of bamboo costs 1 Xukha. Help him.
Input

Input starts with an integer T (≤ 100), denoting the number of test cases.

Each case starts with a line containing an integer n (1 ≤ n ≤ 10000) denoting the number of students of Phi-shoe. The next line containsn space separated integers denoting the lucky numbers for the students. Each lucky number will lie in the range[1, 106].

Output

For each case, print the case number and the minimum possible money spent for buying the bamboos. See the samples for details.

Sample Input

3

5

1 2 3 4 5

6

10 11 12 13 14 15

2

1 1

Sample Output

Case 1: 22 Xukha

Case 2: 88 Xukha

Case 3: 4 Xukha

筛选出一个最小的素数，使得其欧拉函数大于等于幸运数

求最小素数的和

    notprime[i]为真表明i为合数，否则i为素数（因为全局变量初始值为false，筛选法预处理只做一次，所以不需要初始化）。算法的核心就是不断将notprime[i]标记为true的过程，首先从小到大进行枚举，遇到notprime[i]为假的，表明i是素数，将i保存到数组primes中，然后将i的倍数都标记为合数，由于i*2、i*3、i*(i-1)在[1, i)的筛选过程中必定已经被标记为合数了，所以i的倍数只需要从i*i开始即可，避免不必要的时间开销。
  虽然这个算法有两个嵌套的轮询，但是第二个轮询只有在i是素数的时候才会执行，而且随着i的增大，它的倍数会越来越少，所以整个算法的时间复杂度并不是O(n^2)，而且远远小于O(n^2)，在notprime进行赋值的时候加入一个计数器count，计数器的值就是该程序的总执行次数，对MAXP进行不同的值测试发现 int(count / MAXP) 的值随着MAXP的增长变化非常小，总是维持在2左右，所以这个算法的复杂度可以近似看成是O(n)，更加确切的可以说是O(nC)，其中C为常数，C一般取2。
  事实上，实际应用中由于空间的限制（空间复杂度为O(n)），MAXP的值并不会取的很大，10^7基本已经算是极限了

int b[N] = {1, 1, 0};//素数表
void notprime()// 素数筛选法  Eratosthenes筛选法
{
    for(int i = 2 ; i < N ; i++)
    {
        if(!b[i])
        {
            for(int j = i + i ; j <= N ; j += i)
                b[j] = 1;
        }
    }
}
int main()
{
    notprime();
    int t, n, m, z;
    scanf("%d", &t);
    for(z = 1; z <= t; z++)
    {
        long long  sum = 0;
        scanf("%d", &n);
        while(n--)
        {
            scanf("%d", &m);
            for(int i = m + 1 ; ; i++)
            {
                if(b[i] == 0)//是素数
                {
                    sum += i;
                    break;
                }
            }
        }
        printf("Case %d: %lld Xukha\n", z, sum);
    }
    return 0;
}