C++博客-Vontroy-随笔分类-数论

HDU 1452 Happy 2004(因子和)

Vontroy — Sat, 02 Oct 2010 14:08:00 GMT

/*************************************************************
计算 2004^X的因子和 s(2004^X)   mod M, M=29

  s(2004^X)%29
  因子和 s是积性函数,即：gcd(a,b)=1==> s(a*b)= s(a)*s(b)

  2004^X=4^X * 3^X *167^X
  s(2004^X)=  s(2^(2X))* s(3^X) * s(167^X)

  如果 p是素数 ==> s(p^X)=1+p+p^2++p^X = (p^(X+1)-1) /(p-1)

  s(2004^X)=（2^(2X+1)-1）* (3^(X+1)-1)/2  *(167^(X+1)-1)/166

  167%29=22

  s(2004^X)=（2^(2X+1)-1）* (3^(X+1)-1)/2  *(22^(X+1)-1)/21

  (a*b)/c %M= a%M* b%M  * inv(c)

  c*inv(c)=1 %M    模为1的所有数  inv（c）为最小可以被c整除的

    inv(2)=15,  inv(21)=18    2*15=1 mod 29, 18*21=1 mod 29

  s(2004^X)=（2^(2X+1)-1）* (3^(X+1)-1)/2  *(22^(X+1)-1)/21
           =（2^(2X+1)-1）* (3^(X+1)-1)*15 *(22^(X+1)-1)*18
***************************************************************/

//hdu 1452
#include <iostream>
#include <cstdio>
#include <cmath>

using namespace std;

int _pow( int a, int n )
{
    int b = 1;
    while( n > 1 )
        if( n % 2 == 0 )
        {
            a = ( a * a ) % 29;
            n /= 2;
        }
        else
        {
            b = b * a % 29;
            n--;
        }
        return a * b % 29;
}
int main()
{
    int X;
    int a, b, c;
    while( cin >> X, X )
    {
        a = _pow( 2, 2 * X + 1 );
        b = _pow( 3, ( X + 1 ) );
        c = _pow( 22, ( X + 1 ) );

        cout << ( a - 1 ) * ( b - 1 ) * 15 * ( c - 1 ) * 18 % 29 << endl;
    }
    return 0;
}

Vontroy 2010-10-02 22:08 发表评论

POJ 1006 Biorhythms 中国剩余定理

Vontroy — Sat, 02 Oct 2010 12:18:00 GMT

/***************************************
比较经典的中国剩余定理~~

使33×28被23除余1，用33×28×6=5544

使23×33被28除余1，用23×33×19=14421

使23×28被33除余1，用23×28×2=1288

（5544×p+14421×e+1288×i）%（23×28×33）=n+d

n=（5544×p+14421×e+1288×i-d）%（23×28×33）
****************************************/

#include <iostream>
#include <cstdio>

using std :: cin;
using std :: cout;
using std :: endl;

int get__( int a, int b, int c )
{
    int ans;
    int cnt = 1;
    while( ( a * b * cnt ) % c != 1 )
    {
        cnt++;
    }
    return a * b * cnt;
}

int main()
{
    int _p = get__( 28, 33, 23 );
    int _e = get__( 23, 33, 28 );
    int _i = get__( 23, 28, 33 );

    int p, e, i, d;
    int cas = 1;
    while( cin >> p >> e >> i >> d )
    {
        if( p == e && e == i && i == d && d == -1 ) break;
        int ans = ( _p * p + _e * e + _i * i - d ) % ( 23 * 28 * 33 );
        if( ans <= 0 )
            printf("Case %d: the next triple peak occurs in %d days.\n", cas++, 21252 - ans - 2 * d);
        else
            printf("Case %d: the next triple peak occurs in %d days.\n", cas++, ans);
    }
    return 0;
}

Vontroy 2010-10-02 20:18 发表评论

HDU 1788 Chinese remainder theorem again

Vontroy — Sat, 02 Oct 2010 06:58:00 GMT

/**********************************
N % MI = MI - a
因为 a < MI
原式等价于 (N + a) % MI = 0
所以此题为求 M0 到 MI 的最小公倍数

(注意精度问题,用__int64)

***********************************/

#include <iostream>
#include <cstdio>

using namespace std;

__int64 gcd( __int64 a, __int64 b )
{
    if( b == 0 ) return a;
    return gcd( b, a % b );
}

__int64 lcm( __int64 a, __int64 b )
{
    return a * b / gcd( a, b );
}

int main()
{
    int n, k;
    int tmp;
    __int64 ans;
    while( cin >> n >> k, n || k )
    {
        ans = 1;
        for( int i = 0; i < n; i++ )
        {
            cin >> tmp;
            ans = lcm( ans, tmp );
        }
        cout << ans - k << endl;
    }
    return 0;
}

Vontroy 2010-10-02 14:58 发表评论

数论及数学常用知识代码

Vontroy — Sat, 02 Oct 2010 06:28:00 GMT

摘要: //数论模板#include#includeusing namespace std;//辗转相除法求最大公约数long gcd(long a, long b){ if(b==0) ... 阅读全文

Vontroy 2010-10-02 14:28 发表评论

HDU 1018 Big Number

Vontroy — Sat, 02 Oct 2010 06:22:00 GMT

斯特灵公式是一条用来取n阶乘近似值的数学公式。一般来说，当n很大的时候，n阶乘的计算量十分大，所以斯特灵公式十分好用，而且，即使在

n很小的时候，斯特灵公式的取值已经十分准确。

公式为：

这就是说，对于足够大的整数n，这两个数互为近似值。更加精确地：

或者：

Big Number

Time Limit: 20000/10000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 8759 Accepted Submission(s): 3879

Problem Description

In many applications very large integers numbers are required. Some of these applications are using keys for secure transmission of data, encryption, etc. In this problem you are given a number, you have to determine the number of digits in the factorial of the number.

Input

Input consists of several lines of integer numbers. The first line contains an integer n, which is the number of cases to be tested, followed by n lines, one integer 1 ≤ n ≤ 10⁷ on each line.

Output

The output contains the number of digits in the factorial of the integers appearing in the input.

Sample Input

2
10
20

Sample Output

7
19

//log10(n!)=(0.5*log(2*PI*n)+n*log(n)-n)/log(10)

#include <iostream>
#include <cstdio>
#include <cmath>

const double PI = 3.1415926;

int main()
{
    int n;
    int tmp;
    while( ~scanf("%d", &n ) )
    {
        for( int i = 0; i < n; i++ )
        {
            scanf("%d", &tmp);
            double cnt = 1;
            cnt += (0.5 * log( 2 * PI * tmp ) + tmp * log( tmp ) - tmp ) / log(10);
            printf("%d\n", (int)(cnt));
        }
    }
    return 0;
}

Vontroy 2010-10-02 14:22 发表评论

求两个或N个数的最大公约数(gcd)和最小公倍数(lcm)的较优算法

Vontroy — Sat, 02 Oct 2010 06:20:00 GMT

求两个或N个数的最大公约数(gcd)和最小公倍数(lcm)的较优算法

//两个数的最大公约数--欧几里得算法

int gcd(int a, int b)

{

     if (a < b)

          swap(a, b);

     if (b == 0)

           return a;

      else

            return gcd(b, a%b);

}

//n个数的最大公约数算法

//说明:

//把n个数保存为一个数组

//参数为数组的指针和数组的大小(需要计算的数的个数)

//然后先求出gcd(a[0],a[1]), 然后将所求的gcd与数组的下一个元素作为gcd的参数继续求gcd

//这样就产生一个递归的求ngcd的算法

int ngcd(int *a, int n)

{

    if (n == 1)  return *a;

    return gcd(a[n-1], ngcd(a, n-1));

}

//两个数的最小公倍数(lcm)算法

//lcm(a, b) = a*b/gcd(a, b)

int lcm(int a, int b)

{

        return a*b/gcd(a, b);

}

//n个数的最小公倍数算法

//算法过程和n个数的最大公约数求法类似

//求出头两个的最小公倍数,再将欺和大三个数求最小公倍数直到数组末尾

//这样产生一个递归的求nlcm的算法

int nlcm(int *a, int n)

{

      if (n == 1)

            return *a;

      else

            return lcm(a[n-1], nlcm(a, n-1));

}

Vontroy 2010-10-02 14:20 发表评论