oi初级数学知识

根据一些书上的记载，上帝的一次失败的创世经历是这样的：

第一天，上帝创造了一个世界的基本元素，称做“元”。

第二天，上帝创造了一个新的元素，称作“α”。“α”被定义为“元”构成的集合。容易发现，一共有两种不同的“α”。

第三天，上帝又创造了一个新的元素，称作“β”。“β”被定义为“α”构成的集合。容易发现，一共有四种不同的“β”。

第四天，上帝创造了新的元素“γ”，“γ”被定义为“β”的集合。显然，一共会有16种不同的“γ”。

如果按照这样下去，上帝创造的第四种元素将会有65536种，第五种元素将会有2^65536种。这将会是一个天文数字。

然而，上帝并没有预料到元素种类数的增长是如此的迅速。他想要让世界的元素丰富起来，因此，日复一日，年复一年，他重复地创造着新的元素……

然而不久，当上帝创造出最后一种元素“θ”时，他发现这世界的元素实在是太多了，以致于世界的容量不足，无法承受。因此在这一天，上帝毁灭了世界。

至今，上帝仍记得那次失败的创世经历，现在他想问问你，他最后一次创造的元素“θ”一共有多少种？

上帝觉得这个数字可能过于巨大而无法表示出来，因此你只需要回答这个数对p取模后的值即可。

你可以认为上帝从“α”到“θ”一共创造了10^9次元素，或10^18次，或者干脆∞次。

一句话题意：

接下来T行，每行一个正整数p，代表你需要取模的值

T行，每行一个正整数，为答案对p取模后的值

3
2
3
6

0
1
4

对于100%的数据，T<=1000,p<=10^7

分析：这道题是欧拉定理的经典应用，一开始看到题面的我想到的就是找规律，可是涉及到∞，脑洞太小想不出来，但是它给定的模数是有限的，我们能不能从这个模数下手呢？

我们接下来有两种思路：1.把模数越变越小，到最后直接出结果，类似于递归的过程 2.把次数的无穷化为有限，一般而言可以用欧拉定理和费马小定理，但是这道题给的模数不一定满足费马小定理的条件，欧拉定理也不一定满足，但是我们可以用欧拉定理的推论来解决.这两个思路结合起来就是本题的解.

那么我们设答案为f(p),

--图片摘自Codeplay0314的博客.

注意边界，φ（x）= 0,当x = 1的时，因为如果x=1,显然原题是无解的.

这道题也说明了：若

存在，那么

也一定存在。当m=1时，

存在，所以

对于所有正整数m,都有

存在.

#include <cstdio>
#include <queue>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>

using namespace std;

int t, p;

long long qpow(long long a, long long b, long long mod)
{
    long long res = 1;
    while (b)
    {
        if (b & 1)
            res = res * a % mod;
        b >>= 1;
        a = a * a % mod;
    }
    return res;
}

long long phi(int x)
{
    long long res = x;
    for (long long i = 2; i <= sqrt(x);i++)
    {
        if (x % i == 0)
        {
            while (x % i == 0)
                x /= i;
            res = res / i * (i - 1);
        }
    }
    if (x > 1)
        res = res / x * (x - 1);
    return res;
}

long long solve(int x)
{
    if (x == 1)
        return 0;
    long long t = phi(x);
    return qpow(2, solve(t) + t, x);
}

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &p);
        printf("%lld
",solve(p));
    }
return 0;
}

十四、积性函数

线性筛与积性函数之间有一定的联系，如果题目要求我们求出质数的同时求出欧拉函数值，我们可以利用积性函数的性质在筛法中求出欧拉函数值：

void shai()
{
    phi[1] = 1;
    for (int i = 2; i <= maxn; i++)
    {
        if (!vis[i])
        {
            prime[++tot] = i;
            phi[i] = i - 1;
        }
        for (int j = 1; j <= tot; j++)
        {
            int t = prime[j] * i;
            if (t > maxn)
                break;
            vis[t] = 1;
            if (i % prime[j] == 0)
            {
                phi[t] = phi[i] * j;
                break;
            }
            else
            phi[t] = phi[i] * phi[j];
        }
    }
}

现在来解释一下代码：这个线性筛和之前的模板不太一样，原理是相同的，当i % prime[j] == 0的时候就代表找到了最小表示的最小质数，不能继续往下筛了，如果i是一个质数，那么它的phi肯定是i-1，如果i,prime[j]互质，那么利用积性函数的定义直接来就好了。

否则，如果i刚好是prime[j]的倍数，则利用欧拉函数的第三条性质即可.

例13：

2818: Gcd

Time Limit: 10 Sec Memory Limit: 256 MB
Submit: 5930 Solved: 2636
[Submit][Status][Discuss]

Description

给定整数N，求1<=x,y<=N且Gcd(x,y)为素数的
数对(x,y)有多少对.

Input

一个整数N

Output

如题

Sample Input

4

Sample Output

4

HINT

hint

对于样例(2,2),(2,4),(3,3),(4,2)

1<=N<=10^7

Source

湖北省队互测

分析：这道题是比较典型的gcd(a,b) = c求个数之类的问题，做法和这道题：传送门差不多，首先我们假设gcd(a,b) = g,这样不能直接统计，那么我们可以得到a = a' * g,b = b' * g, (a',b') = 1,同时约掉g,就变成了求互质的数的个数。不过这和bzoj2705有点不太一样，它并没有一个确定的数，不过我们可以分类讨论.

1.如果x < y,那么从1到maxn枚举y,答案就是Σφ(y).

2.如果x > y,一样的，不过答案就是Σφ(x).

3.如果x = y,那么情况只有一种:x = y = 1,但是这种情况已经在上面两种情况中被算了，所以总的答案就是2*Σφ(i) - 1 (1 <= i <= maxn)

那么这个maxn就很显然了，就是n除以当前的g.

这个题的数据范围有点大，需要用到线性算法，我们既要求出质数，又要推出欧拉函数值，那么直接用线性筛就能解决.

#include <cstdio>
#include <queue>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>

using namespace std;

int n,tot = 0;
const int maxn = 10000010;
int p[maxn], prime[maxn], f[maxn];
long long sum[maxn];
long long ans;

void init()
{
    p[1] = 1;
    for (int i = 2; i <= n; ++i) {
        if (!f[i]) {
            prime[++tot] = f[i] = i;
            p[i] = i - 1;
        }
        for (int j = 1; j <= tot; ++j) {
            long long t = i * prime[j];
            if (t > n) break;
            f[t] = prime[j];
            p[t] = p[i] * (prime[j] - (prime[j] < f[i]));
            if (prime[j] == f[i]) break;
        }
    }

}

int main()
{
    scanf("%d", &n);
    init();
    for (int i = 1; i <= n; i++)
        sum[i] = sum[i - 1] + p[i];
    for (int i = 1; i <= tot; i++)
        ans += 2 * sum[n / prime[i]] - 1;
    printf("%lld", ans);

    return 0;
}

例14：

bzoj2721 [Violet 5]樱花

分析：这道题对于我这种蒟蒻来说还是很有难度啊。

思路非常巧妙，既然不定方程要有有限个数解，那么这个肯定会对解有所限制，也就是本题中的正整数.这个时候我们要表示出方程中的一个根x,设z = n!,那么x=yz/(y-z),这样的话不能得到答案，我们要得到的式子一定是分母只能有乘积的形式，并且同一个字母不能同时在分子分母中出现，因为我们就是利用正整数的整除性来求解的，可以看出x和y都大于z,所以我们设y = z + d,带入,就消掉了y，可以得到x = z^2/d + z,因为x是正整数，所以z^2/d必须是整数，所以d是z^2的因子，那么我们只需要求出z^2有多少个约数就好了.

求约数的个数要用到乘法原理和线性筛，z可以表示为p1^k1 * p2^k2 * p3^k3*...*pn^kn这种形式，每个质因数可以选1到ki个或不选，而约数就是由不同的质因子通过相乘组合起来的，所以约数的个数就等于(k1 + 1)*(k2 + 1)*...*(kn + 1),而我们要求z^2的因子个数，总不可能直接平方吧......可以发现每个质因子的次数扩大了两倍，那么每个质因子就有2*ki + 1种选择，和上面一样直接乘法原理出答案.

因为z = n!,所以枚举1到n中的质数i的倍数，看i出现了几次，就能得到ki.

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<cmath>

using namespace std;

const int mod = 1000000007;

int prime[1000010], tot, cnt[1000010],n;
bool vis[1000010];

long long ans = 1;

void init()
{
    for (int i = 2; i <= n; i++)
    {
        if (!vis[i])
            prime[++tot] = i;
        for (int j = 1; j <= tot; j++)
        {
            if (prime[j] * i > n)
                break;
            vis[prime[j] * i] = 1;
            if (i % prime[j] == 0)
                break;
        }
    }
}

int main()
{
    scanf("%d", &n);
    init();
    for (int i = 1; i <= tot; i++)
        for (int j = prime[i]; j <= n; j += prime[i])
            for (int k = j; k % prime[i] == 0; k /= prime[i])
                cnt[i]++;
    for (int i = 1; i <= tot; i++)
        ans = (ans * 1LL * (cnt[i] * 2 + 1) % mod) % mod;

    printf("%lld
", ans);
    return 0;
}

例15：

CF632D Longest Subsequence

You are given array a with n elements and the number m. Consider some subsequence of a and the value of least common multiple (LCM) of its elements. Denote LCM as l. Find any longest subsequence of a with the value l ≤ m.

A subsequence of a is an array we can get by erasing some elements of a. It is allowed to erase zero or all elements.

The LCM of an empty array equals 1.

Input

The first line contains two integers n and m (1 ≤ n, m ≤ 10^6) — the size of the array a and the parameter from the problem statement.

The second line contains n integers ai (1 ≤ ai ≤ 10^9) — the elements of a.

Output

In the first line print two integers l and kmax (1 ≤ l ≤ m, 0 ≤ kmax ≤ n) — the value of LCM and the number of elements in optimal subsequence.

In the second line print kmax integers — the positions of the elements from the optimal subsequence in the ascending order.

Note that you can find and print any subsequence with the maximum length.

Examples

input

7 8
6 2 9 2 7 2 3

output

6 5
1 2 4 6 7

input

6 4
2 2 2 3 3 3

output

2 3
1 2 3
一句话题意：


分析：对于一个数k,它的所有约数的lcm肯定不大于k,也就是说对于每一个[1,m]中的数，我们只需要求出它的约数是a中的数的个数就好了，难道又要用筛法或质因数分解吗？其实不必，我们可以想到一个O(nm)的做法：枚举[1,m]中的每一个数，然后看看a中有多少个数整除它，显然T掉，能不能改进一下呢？
对于枚举的优化，要么是减少枚举层数，要么是减少对答案没有贡献的枚举，我们可以只用枚举整除数i的数，然后看看a中有没有这个数，这个操作可以用一个vis数组，只需要O（1）的时间查询。不过ai <= 10^9,我们似乎开不下这么大的vis数组，观察题目，发现m只有10^6,大于10^6的数我们可以不用考虑.
      其实相对于枚举约数，枚举倍数更容易，我们从一个数扩展，将它的倍数的计数器累加即可，其实两种方法都可以.

#include <cstdio>
#include <queue>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>

using namespace std;

const int maxn = 1000010;

int num[maxn], cnt[maxn],tot,a[maxn],ans,id,vis[maxn];
int n, m;

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
    {
        int t;
        scanf("%d", &t);
        a[i] = t;
        if (t > m)
            continue;
        ++num[t];
    }
    for (int i = 1; i <= n; i++)
    {
        if (!vis[a[i]])
        for (int j = a[i]; j <= m; j += a[i])
            cnt[j] += num[a[i]];
        vis[a[i]] = 1;
    }
    for (int i = 1; i <= m; i++)
        if (cnt[i] > ans)
        {
            ans = cnt[i];
            id = i;
        }
    printf("%d %d
", id, ans);
    for (int i = 1; i <= n; i++)
        if (id % a[i] == 0)
            printf("%d ", i);

    return 0;
}

例16：CF687B Remainders Game

题意：已知n个数,第i个为ci,给定一个数x mod ci的结果，再给点一个k,问能不能知道x mod k的值？

分析：刚看题目的我一脸蒙蔽，对题意有点不理解，能的情况似乎有很多，我该从哪里下手呢？

先从不能的情况来看，可以知道，如果不能知道x mod k的值，当且仅当有两个解x1,x2, x1 ≡ x2(mod ci)x1 ≢ x2 (mod k) 左边这个是不同余的意思，为什么是这样的呢？因为题目中说x mod k的值是唯一的，我们却会出现两个满足题意的x值 mod k的值不同，这就矛盾了。

那么我们怎样求解这两个同余式呢？如果x1 ≡ x2(mod ci),那么(x1 - x2) % ci = 0,所以x1 - x2一定是ci的最小公倍数的倍数，然后对第二个式子变形一下：(x1 - x2) % k != 0,也就是说k不整除lcm{ci}那么这道题就变成了要我们求解lcm{ci}到底是不是k的倍数。

但是直接求会lcm会爆掉啊，如果取模的话涉及到除法要求逆元复杂度又会爆炸，该怎么处理？正确的方法是分解质因数：将k表示为p1^k1 * p2 ^ k2 * ... *pn ^ kn的形式，如果lcm{ci}是k的倍数，那么p1^k1、p2^k2...pn^kn一定会全部出现在某些ci中，我们只需要在读入的时候检验一下打个标记就好了。一位大神说的对：lcm就是质因子的并集，gcd就是质因子的交集，遇到gcd、lcm,分解一下质因子不失为一种好的方法。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<cmath>

using namespace std;

int n, k, c,tot,prime[100010];
bool vis[100010];

int main()
{
    scanf("%d%d", &n, &k);
    for (int i = 2; i <= sqrt(k); i++)
    {
        if (k % i == 0)
        {
            int t = 1;
            while (k % i == 0)
            {
                t *= i;
                k /= i;
            }
            prime[++tot] = t;
        }
    }
    if (k)
        prime[++tot] = k;
    for (int i = 1; i <= n; i++)
    {
        int c;
        scanf("%d", &c);
        for (int j = 1; j <= tot; j++)
            if (c % prime[j] == 0)
                vis[j] = 1;
    }
    for (int i = 1; i <= tot; i++)
        if (!vis[i])
        {
        printf("No
");
        return 0;
        }
    printf("Yes
");

    return 0;
}

例17：

CF582A GCD Table

The GCD table G of size n × n for an array of positive integers a of length n is defined by formula

Let us remind you that the greatest common divisor (GCD) of two positive integers x and y is the greatest integer that is divisor of both xand y, it is denoted as . For example, for array a = {4, 3, 6, 2} of length 4 the GCD table will look as follows:

Given all the numbers of the GCD table G, restore array a.

Input

The first line contains number n (1 ≤ n ≤ 500) — the length of array a. The second line contains n2 space-separated numbers — the elements of the GCD table of G for array a.

All the numbers in the table are positive integers, not exceeding 109. Note that the elements are given in an arbitrary order. It is guaranteed that the set of the input data corresponds to some array a.

Output

In the single line print n positive integers — the elements of array a. If there are multiple possible solutions, you are allowed to print any of them.

Examples

input

4
2 1 2 3 4 3 2 6 1 1 2 2 1 2 3 2

output

4 3 6 2

input

1
42

output

input

2
1 1 1 1

output

1 1

题意：给出n个数之间任意两个数的gcd,求这n个数分别是多少.

分析：我们要从这个表中得到一些原数列的信息，显然，最大的那个数肯定是原数列中的数，然后把这个数去掉，并且将这个数和之前得到的数列中的数的gcd去掉，因为是一个矩形，所以一定会出现两次gcd,重复这种操作就能得到原数列中的数.

至于实现，最好用map、hash,如果一个一个找数会浪费很多时间.

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<cmath>
#include<map>

using namespace std;

map <int, int> m;

int a[510 * 510],n,tot,ans[510*510];

bool cmp(int x, int y)
{
    return x > y;
}

int gcd(int a, int b)
{
    if (!b)
        return a;
    return gcd(b, a % b);
}

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n * n; i++)
    {
        scanf("%d", &a[i]);
        m[a[i]]++;
    }
    sort(a + 1, a + n * n + 1,cmp);
    for (int i = 1; i <= n * n; i++)
    {
        if (!m[a[i]])
            continue;
        m[a[i]]--;
        for (int j = 1; j <= tot; j++)
            m[gcd(a[i], a[j])] -= 2;
        ans[++tot] = a[i];
    }
    for (int i = 1; i <= tot; i++)
        printf("%d ", ans[i]);

    return 0;
}

大BOSS

1876: [SDOI2009]SuperGCD

Time Limit: 4 Sec Memory Limit: 64 MB
Submit: 3744 Solved: 1349
[Submit][Status][Discuss]

Description

Sheng bill有着惊人的心算能力，甚至能用大脑计算出两个巨大的数的GCD（最大公约数）！因此他经常和别人比

赛计算GCD。有一天Sheng bill很嚣张地找到了你，并要求和你比赛，但是输给Sheng bill岂不是很丢脸！所以你

决定写一个程序来教训他。

Input

共两行：第一行：一个数A。第二行：一个数B。

0 < A , B ≤ 10 ^ 10000。

Output

一行，表示A和B的最大公约数。

Sample Input

12
54

Sample Output

6

HINT

Source

Day1

分析：这道题是一道非常烦人的高精度问题，求gcd谁都会，但是直接用欧几里得算法，高精度取模直接gg，而且还是压位的，打出来估计要半天.那么换一种方法：更相减损术：

第一步：任意给定两个正整数；判断它们是否都是偶数。若是，则用2约简；若不是则执行第二步。

第二步：以较大的数减较小的数，接着把所得的差与较小的数比较，并以大数减小数。继续这个操作，直到所得的减数和差相等为止。

则第一步中约掉的若干个2与第二步中等数的乘积就是所求的最大公约数。

其中所说的“等数”，就是最大公约数。求“等数”的办法是“更相减损”法。 ----摘自百度百科

也就是说我们只需要设计乘法，除法和减法就可以了。高精度算法就相当于模拟我们算术一样，只不过用程序跑而已，步骤是先操作，再进位、补位，最后看数组的长度有没有改变.

这道题一定要压位来处理，不然会tle,压位后的操作与没有压位差不多，只不过mod的数变了，以前是逢10进1，现在是逢n进1.

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<cmath>
#include<map>

using namespace std;

const int mod = 100000000;

int tot;

struct node
{
    int x[2010], len;
}a,b;

void read(node &c)
{
    char s[10010];
    scanf("%s", s);
    int len = strlen(s),cnt = 0,chengji = 1;
    for (int i = len - 1; i >= 0; i--)
    {
        cnt = cnt + (s[i] - '0')* chengji;
        chengji *= 10;
        if ((len - i) % 8 == 0)
        {
            c.x[++c.len] = cnt;
            cnt = 0;
            chengji = 1;
        }
    }
    if (cnt != 0)
        c.x[++c.len] = cnt;
}

void div1()
{
    for (int i = a.len; i >= 1; i--)
    {
        if (a.x[i] % 2 == 1)
            a.x[i - 1] += mod;
        a.x[i] >>= 1;
    }
    while (a.x[a.len] == 0 && a.len > 1)
        a.len--;
}

void div2()
{
    for (int i = b.len; i >= 1; i--)
    {
        if (b.x[i] % 2 == 1)
            b.x[i - 1] += mod;
        b.x[i] >>= 1;
    }
    while (b.x[b.len] == 0 && b.len > 1)
        b.len--;
}

bool check()
{
    if (a.len != b.len)
        return false;
    for (int i = 1; i <= a.len; i++)
        if (a.x[i] != b.x[i])
            return false;
    return true;
}

bool cmp()
{
    if (a.len > b.len)
        return true;
    else
        if (a.len < b.len)
            return false;
    for (int i = a.len; i >= 1; i--)
    {
        if (a.x[i] > b.x[i])
            return true;
        else
            if (a.x[i] < b.x[i])
                return false;
    }
    return true;
}

void jian(node &c, node d)
{
    for (int i = 1; i <= c.len; i++)
    {
        if (c.x[i] >= d.x[i])
            c.x[i] -= d.x[i];
        else
        {
            c.x[i] = c.x[i] + mod - d.x[i];
            c.x[i + 1]--;
        }
    }
    while (c.x[c.len] == 0 && c.len > 1)
        c.len--;
}

void mul()
{
    for (int i = 1; i <= a.len; i++)
        a.x[i] <<= 1;
    for (int i = 1; i <= a.len; i++)
        if (a.x[i] >= mod)
        {
        a.x[i] -= mod;
        a.x[i + 1]++;
        }
    while (a.x[a.len + 1])
        a.len++;
}

void print()
{
    printf("%d", a.x[a.len]);
    for (int i = a.len - 1; i >= 1; i--)
        printf("%08d", a.x[i]);
    printf("
");
}

int main()
{
    read(a);
    read(b);
    while (a.x[1] % 2 == 0 && b.x[1] % 2 == 0)
    {
        tot++;
        div1();
        div2();
    }
    while (!check())
    {
        if (cmp())
            jian(a, b);
        else
            jian(b, a);
        while (a.x[1] % 2 == 0)
            div1();
        while (b.x[1] % 2 == 0)
            div2();
    }
    while (tot--)
        mul();
    print();

    return 0;
}

陆陆续续添加了18道题，难度基本上是noip提高组+，推荐阅读进阶博客：传送门,谢谢大家的阅读，如果发现有什么错误，请指出！qq:1339623011,愿不吝赐教！

oi初级数学知识

Description

Input

Output

Sample Input

Sample Output

HINT

Source

2186: [Sdoi2008]沙拉公主的困惑

Description

Input

Output

Sample Input

Sample Output

3884: 上帝与集合的正确用法

Description

Input

Output

Sample Input

Sample Output

HINT

2818: Gcd

Description

Input

Output

Sample Input

Sample Output

HINT

Source

1876: [SDOI2009]SuperGCD

Description

Input

Output

Sample Input

Sample Output

HINT

Source