数论一

1、UVa 10916  Factstone Benchmark(对数函数的利用--乘化加)

　　题意：给出年份，每个10年对应一个当前计算机可支持的字节位数，计算n! < max（max 为当前计算机能表示的最大整数），求最大n.

　　思路：字节数k = （year - 1940) / 10,  问题就转化成 n ! < 2 ^ k < (n + 1) !, 对两边同取对数，因为log(a*b) = log(a) + log(b);所以log(n!) = sum(log(i)), ( 1<= i <= n), 只要找到最小的sum(log(i)) > k * log（2） ，答案就是i- 1.

#include<iostream>
#include<cmath>
using namespace std;
int main()
{
    int y;
    while (~scanf("%d", &y)&&y)
    {
        int n = (y - 1940) / 10;
        double re = pow(2.0,1.0*n)*log(2.0);
        double sum = 0;
        for(int i=1;;i++)
        {
            sum += log(1.0*i);
            if (sum > re)
            {
                printf("%d
", i - 1);
                break;
            }
        }
    }
    return 0;
}

2、zoj 1239 Hanoi Tower Troubles Again!

　　题意：给出n个柱子，从第一个柱子开始放珠子，珠子编号从1开始，要求每个柱子上相邻两个珠子的和是平方数。

　　思路：

h(1) = 1：1个柱子时，放上1之后，2就放不上去了，不满足柱子上相邻的球之和为平方数（1 + 2 = 3，不是平方数）；
h(2) = 3：2个柱子时，1和2各放在1个柱子上，3可以放在1上面（1 + 3 = 4 = 2 ^ 2）；
h(i) = h(i - 1) + i + 1：i为奇数时，在i - 1柱子的基础上增加了一个柱子，这时候可以再放i + 1个球；
h(i) = h(i - 1) + i：i为偶数时，在i - 1柱子的基础上增加了一个柱子，这时候可以再放i个球。
f(n) = f(n - 1) + (n + 1) / 2 + (n + 1) / 2 (n > 2)

//h(1) = 1：1个柱子时，放上1之后，2就放不上去了，不满足柱子上相邻的球之和为平方数（1 + 2 = 3，不是平方数）；
//h(2) = 3：2个柱子时，1和2各放在1个柱子上，3可以放在1上面（1 + 3 = 4 = 2 ^ 2）；
//h(i) = h(i - 1) + i + 1：i为奇数时，在i - 1柱子的基础上增加了一个柱子，这时候可以再放i + 1个球；
//h(i) = h(i - 1) + i：i为偶数时，在i - 1柱子的基础上增加了一个柱子，这时候可以再放i个球。
// f(n) = f(n - 1) + (n + 1) / 2 + (n + 1) / 2    (n > 2)
#include<iostream>
using namespace std;
int re[55];
void Init()
{
    re[1] = 1, re[2] = 3;
    for (int i = 3; i <= 50; i++) re[i] = re[i - 1] + (i + 1) / 2 + (i + 1) / 2;
}
int main()
{
    Init();
    int t;
    scanf("%d", &t);
    while (t--)
    {
        int n;
        scanf("%d", &n);
        printf("%d
", re[n]);
    }
    return 0;
}

3、hdu1465 不容易系列之一（错排）

　　题意：求所有错排的错排方案数。

　　思路：

错排数公式：f[n] = (n - 1) * (f[n - 1] + f[n - 2]);
也可以这么想;
(1).f[1] = 0; f[2] = 1;
(2).如果确定f[n - 1] 和 f[n - 2] 的话。
f[n] 中必然包含 f[n - 1] * (n - 1)种情况。 即把新加入的一封和之前的任一一封交换，所得到的必然是错排。

//错排数公式：f[n] = (n - 1) * (f[n - 1] + f[n - 2]);
//也可以这么想;
//(1).f[1] = 0; f[2] = 1;
//(2).如果确定f[n - 1] 和 f[n - 2] 的话。
//f[n] 中必然包含 f[n - 1] * (n - 1)种情况。 即把新加入的一封和之前的任一一封交换，所得到的必然是错排。
//f[n] 中另一部分就是f[n - 2] * (n - 1) 即之前的 n - 1 封中有一封没有错排，把这封与新加入的一封交换进行错排。
#include<iostream>
using namespace std;
long long re[25];
void Init()
{
    re[1] = 0, re[2] = 1;
    for (int i = 3; i <= 20; i++) re[i] = (re[i - 1] + re[i - 2])*(i - 1);
}
int main()
{
    Init();
    int n;
    while (~scanf("%d", &n))
    {
        printf("%lld
",re[n]);
    }
    return 0;
}

4、HDU 3625 Examining the Rooms（第一类斯特林数）

　　题意：有n个房间，n！个钥匙，在房间中，最多可以破k扇门，然后得到其中的钥匙，去开其它的门，但是第一扇门不可以破开，求可以打开所有门的概率。

　　思路：

求N个房间形成1~K个环有多少种可能，然后除以总的分配方案数即为题目要我们求的概率。

第一类斯特林数S(N, K) = S(N - 1, K - 1) + (N - 1)*S(N - 1, k)恰恰就是求N个元素形成K个非空循环排列的方法数。

S(N,M)-S(N-1,M-1)，表示N个元素形成M个环，减去1独自成环，即剩下的N-1个元素形成M-1个环，算得的结果便是所求值。

//求N个房间形成1~K个环有多少种可能，然后除以总的分配方案数即为题目要我们求的概率
//第一类斯特林数S(N, K) = S(N - 1, K - 1) + (N - 1)*S(N - 1, k)恰恰就是求N个元素形成K个非空循环排列的方法数
//S(N,M)-S(N-1,M-1)，表示N个元素形成M个环，减去1独自成环，即剩下的N-1个元素形成M-1个环，算得的结果便是所求值
#include<iostream>
using namespace std;
long long stl[25][25], cal[25];
void Init()
{
    cal[0] = cal[1] = 1;
    for (int i = 2; i <= 20; i++) cal[i] = cal[i - 1] * i;
    for (int i = 1; i <= 20; i++)
    {
        stl[i][i] = 1;
        for (int j = 1; j < i; j++)
        {
            stl[i][j] = stl[i - 1][j - 1] + (i - 1)*stl[i - 1][j];
        }
    }
}
int main()
{
    int t;
    scanf("%d", &t);
    Init();
    while (t--)
    {
        int n, k;
        scanf("%d%d", &n, &k);
        long long ans = 0;
        for (int i = 1; i <= k; i++)
        {
            ans += stl[n][i] - stl[n - 1][i - 1];
        }
        printf("%.4lf
", 1.0*ans / cal[n]);
    }
    return 0;
}

5、hdu 4045 Machine scheduling(组合+第二类斯特林数)

　　题意：有N个机器，每天选出R个机器，而且每两个机器的编号差要大于等于K，而且每天将R个机器最多分为M组工作，问最多有多少种方案 。

　　思路：

首先是从N个机器中选出R个满足条件的机器有多少种。然后将R个机器最多分为M组有多少种，答案为二者的乘积。

对于后者：

为第二类Strling数的和 ： S[n][1] + S[n][2] + ... + S[n][m]。

S(p,k)的递推公式是：S(p,k)=k*S(p-1,k)+S(p-1,k-1) ,1<= k<=p-1
边界条件：S(p,p)=1 ,p>=0 ；S(p,0)=0 ,p>=1。

对于前者：

1:如果是把n个求放入k个盒子中（每个盒子必须要有球），那么由插板法得 方案数为 C(n-1,k-1);
2:如果是把n个求放入k个盒子中（盒子可以为空），那么由插板法得 方案数为 C(n + k - 1, k - 1);
要从n个元素编号1~n中选出r个元素来，使得任意两个元素编号相差>=k
解法：先按照 1 k + 1 2 * k + 1 .... (r - 1)*k + 1 也就是刚好 间隔 k个排列下来
那么 总共n个元素，剩余 n - (r - 1)*k - 1个元素可以看成空格，极为space, 将它们插入这r个元素的r + 1个空档中，
这样就能保证枚举了素有的方法数，切满足任意两个元素编号相差 >= k的要求
所以这个问题简化为：将space个元素分配到r + 1个区域中，可以为空(每两个机器之前至少有K个间隔，那么如果还剩余一些位置，则把这些多余的插入到R个机器中。那么剩余位置便是N - ((R - 1)*K + 1), 对于R个机器，R + 1个位置，接下来便是把N - ((R - 1)*K + 1)分为R + 1个集合，而且可以为空。做法是添加R + 1个物品，然后用插板法，这样保证 每一个集合都至少有一个，然后再把每一个集合都减掉一个便是结果，最终结果便是C[N - ((R - 1)*K + 1) + R + 1 - 1][R]。)

//有N个机器，每天选出R个机器，而且每两个机器的编号差要大于等于K，而且每天将R个机器最多分为M组工作，问最多有多少种方案 
//1:如果是把n个求放入k个盒子中（每个盒子必须要有球），那么由插板法得 方案数为 C(n-1,k-1);
//2:如果是把n个求放入k个盒子中（盒子可以为空），那么由插板法得 方案数为 C(n + k - 1, k - 1);
//要从n个元素编号1~n中选出r个元素来，使得任意两个元素编号相差>=k
//解法：先按照 1 k + 1 2 * k + 1 .... (r - 1)*k + 1 也就是刚好 间隔 k个排列下来
//那么 总共n个元素，剩余 n - (r - 1)*k - 1个元素可以看成空格，极为space, 将它们插入这r个元素的r + 1个空档中，
//这样就能保证枚举了素有的方法数，切满足任意两个元素编号相差 >= k的要求
//所以这个问题简化为：将space个元素分配到r + 1个区域中，可以为空(每两个机器之前至少有K个间隔，那么如果还剩余一些位置，则把这些多余的插入到R个机器中。那么剩余位置便是N - ((R - 1)*K + 1), 对于R个机器，R + 1个位置，接下来便是把N - ((R - 1)*K + 1)分为R + 1个集合，而且可以为空。做法是添加R + 1个物品，然后用插板法，这样保证 每一个集合都至少有一个，然后再把每一个集合都减掉一个便是结果，最终结果便是C[N - ((R - 1)*K + 1) + R + 1 - 1][R]。)
#include<iostream>
using namespace std;
const int maxn = 1010;
const int MOD = 1e9 + 7;
long long C[maxn][maxn];
long long stri2[maxn][maxn];//第二类斯特林数
void Init()
{
    memset(C, 0, sizeof(C));
    for (int i = 0; i < maxn; i++)
    {
        C[i][0] = 1;
        for (int j = 1; j <= i; j++)
        {
            C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
        }
    }
    for (int i = 1; i < maxn; i++)
    {
        stri2[i][0] = 0;
        stri2[i][i]=stri2[i][1] = 1;
        for (int j = 1; j < i; j++)
        {
            stri2[i][j] = (stri2[i - 1][j] * j + stri2[i - 1][j - 1]) % MOD;
        }
    }
}
int main()
{
    Init();
    int n, r, k, m;
    while (~scanf("%d%d%d%d", &n, &r, &k, &m))
    {
        int res = n - (r - 1)*k - 1;
        if (res < 0)
        {
            printf("0
");
            continue;
        }
        long long ans = 0;
        for (int i = 0; i <= m; i++) ans = (ans + stri2[r][i]) % MOD;
        ans = (ans*C[res + r][r]) % MOD;
        printf("%lld
", ans);
    }
    return 0;
}

6、HDU 1023 Train Problem II(卡特兰数+模拟大数乘除<高精度递推>)

　　题意：给你一个数n，表示有n辆火车，编号从1到n，从远方驶过来，问你有多少种出站的可能。

　　思路：

1.Catalan数的组合公式为 Cn=C(2n,n) / (n+1);
2.此数的递归公式为 h(n ) = h(n-1)*(4*n-2) / (n+1)。

http://blog.163.com/lz_666888/blog/static/1147857262009914112922803/

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int cat[110][110];//每一位存放大数的4位
//Catalan数的组合公式为 Cn=C(2n,n) / (n+1);
//递推公式为 h(n) = h(n - 1)*(4 * n - 2) / (n + 1);
int length[110];//记录每一位卡特兰数的位数
const int MOD = 10000;
void Init()
{//求出1~100位卡特兰数
    memset(cat, 0, sizeof(cat));
    cat[1][0] = 1;
    int len = 1;
    length[1] = 1;
    for (int i = 2; i <= 100; i++)
    {
        //乘法
        int r = 0;
        for (int j = 0; j < len; j++)
        {
            int temp = cat[i - 1][j] * (4 * i - 2);
            cat[i][j] = (temp+r)%MOD;
            r = (temp + r) / MOD;
        }
        //进位
        while (r)
        {
            cat[i][len++] = r %MOD;
            r /= MOD;
        }
        //除法
        r = 0;
        for (int j = len - 1; j >= 0; --j)
        {
            int temp = r * MOD + cat[i][j];
            cat[i][j] = temp / (i + 1);
            r = temp % (i + 1);
        }
        //除法结束后高位0处理
        while (cat[i][len - 1] == 0)
        {
            len--;
        }
        length[i] = len;
    }
}
int main()
{
    Init();
    int n;
    while (~scanf("%d", &n))
    {
        int len = length[n];
        printf("%d", cat[n][len - 1]);
        for (int j = len - 2; j >= 0; j--) printf("%.4d", cat[n][j]);
        printf("
");
    }
    return 0;
}

7、HDU 1297 Children’s Queue(模拟大数加法<高精度递推>)

　　题意：F代表女孩，M代表男孩，女孩不能单独出现但是可以不出现，即不能出现MFM这种情况，给定一个数n，问有多少种站队方式。

　　思路：

一个长度n的队列可以看成一个n - 1的队列再追加的1个小孩，这个小孩只可能是：
a.男孩，任何n - 1的合法队列追加1个男孩必然是合法的，情况数为f[n - 1]；
b.女孩，在前n - 1的以女孩为末尾的队列后追加1位女孩也是合法的，我们可以转化为n - 2的队列中追加2位女孩；
一种情况是在n - 2的合法队列中追加2位女孩，情况数为f[n - 2]；
但我们注意到本题的难点，可能前n - 2位以女孩为末尾的不合法队列（即单纯以1位女孩结尾），也可以追加2位女孩成为合法队列，而这种n - 2不合法队列必然是由n - 4合法队列 + 1男孩 + 1女孩的结构，即情况数为f[n - 4]。
f[n] = f[n - 1] + f[n - 2] + f[n - 4]。

//一个长度n的队列可以看成一个n - 1的队列再追加的1个小孩，这个小孩只可能是：
//a.男孩，任何n - 1的合法队列追加1个男孩必然是合法的，情况数为f[n - 1]；
//b.女孩，在前n - 1的以女孩为末尾的队列后追加1位女孩也是合法的，我们可以转化为n - 2的队列中追加2位女孩；
//一种情况是在n - 2的合法队列中追加2位女孩，情况数为f[n - 2]；
//但我们注意到本题的难点，可能前n - 2位以女孩为末尾的不合法队列（即单纯以1位女孩结尾），也可以追加2位女孩成为合法队列，而这种n - 2不合法队列必然是由n - 4合法队列 + 1男孩 + 1女孩的结构，即情况数为f[n - 4]。
//f[n] = f[n - 1] + f[n - 2] + f[n - 4]
#include<iostream>
#include<cstring>
using namespace std;
int f[1010][1010];
int length[1010];
void Init()
{
    memset(f, 0, sizeof(f));
    f[1][0] = 1;
    f[2][0] = 2;
    f[3][0] = 4;
    f[4][0] = 7;
    int len = 1;
    length[1] = length[2] = length[3] = length[4] = 1;
    for (int i = 5; i <= 1000; i++)
    {
        for (int j = 0; j < len; j++)
        {
            f[i][j] += f[i - 1][j] + f[i - 2][j] + f[i - 4][j];
            f[i][j + 1] += f[i][j] / 10000;
            f[i][j] %= 10000;
        }
        while (f[i][len]) len++;
        length[i] = len;
    }
}
int main()
{
    Init();
    int n;
    while (~scanf("%d", &n))
    {
        int len = length[n];
        printf("%d", f[n][len - 1]);
        for (int i = len - 2; i >= 0; i--) printf("%04d", f[n][i]);
        printf("
");
    }
    return 0;
}

8、hdu 1466 计算直线交点数

　　题意：平面上有n条直线，且无三线共点，问这些直线能有多少种不同交点数。比如,如果n=2,则可能的交点数量为0(平行)或者1(不平行)。

　　思路：

分析加入第N条直线的情况(这里以N=4为例)： 
（分类方法：和第N条直线平行的在a组，其余在b组） 
1、 第四条与其余直线全部平行 ：

0+4*0+0=0； 

2、 第四条与其中两条平行：

交点数为0+(n-1)*1+0=3; 

3、 第四条与其中一条平行：

这两条平行直线和另外两点直线的交点数为(n-2)*2=4,

而另外两条直线既可能平行也可能相交，

因此可能交点数为： 0+（n-2）* 2+0=4    或者  0+(n-2)*2+1=5     

4、 第四条直线不与任何一条直线平行，交点数为：0+(n-3)*3+0=3  或0+ (n-3)*3+2=5  或0+ (n-3)*3+3=6 

即n=4时，有0个，3个，4个，5个，6个不同交点数。

所以从上述n=4的分析过程中，我们发现： 

m条直线的交点方案数 =（m - r）条平行线与r条直线交叉的交点数 + r条直线本身的交点方案 = （m - r ）* r + r 条之间本身的交点方案数（0 < = r < m ）

将 n 条直线排成一个序列，直线 2 和直线 1 最多只有一个交点，直线 3 和直线 1 和直线 2 最多有两个交点......直线n和其他 n - 1 条直线最多有 n - 1 个交点,由此得出 n 条直线互不平行且无三线共点的最多交点数：max = 1 + 2 + . . . + (n - 1) = n * (n - 1) / 2。

其中每个自由直线与每个平行直线都有一个交点，j自由直线与i平行直线的交点数为 j * i，所以n条直线的交点数等于自由直线与平行直线的交点加上自由直线内部形成的交点。

————————以上摘自：http://blog.csdn.net/wang907553141/article/details/52165629

#include<iostream>
using namespace std;
const int maxn = 210;
bool dp[25][maxn];//dp[i][j]表示i条直线相交时是否有j个交点
void Init()
{
    for (int i = 0; i <= 20; i++) dp[i][0] = true;//所有的直线都平行
    for (int i = 2; i <= 20; i++)
    {//i条直线
        for (int j = 1; j < i; j++)
        {//枚举和第i条边相交的边的数目
            for (int k = 0; k < maxn; k++)
            {//枚举j条边的交点情况
                if (dp[j][k]) dp[i][(i - j)*j + k] = true;
            }

        }
    }
}

int main()
{
    Init();
    int n;
    while (~scanf("%d", &n))
    {
        for (int i = 0; i < maxn; i++)
        {
            if (dp[n][i])
            {
                if (i > 0) printf(" ");
                printf("%d", i);
            }
        }
        printf("
");
    }
    return 0;
}

 9、SPOJ 2832 Find The Determinant III(n阶行列式求值)

　　题意：求矩阵行列式A的值%P。

　　思路：辗转相除法求n阶行列式的值对mod取模。

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;

const int inf = 0x3f3f3f3f;
const double eps = 1e-15;
typedef long long LL;
const int N = 250;

LL mat[N][N];

LL Det(int n, int mod)
{//辗转相除法求n阶行列式的值对mod取模
    //输入：mat[][]矩阵
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < n; ++j)
        {
            mat[i][j] %= mod;
        }
    }
    LL res = 1;
    for (int i = 0; i < n; ++i)
    {
        if (!mat[i][i])
        {
            bool flag = false;
            for (int j = i + 1; j < n; ++j)
            {
                if (mat[j][i])
                {
                    flag = true;
                    for (int k = i; k < n; ++k)
                    {
                        swap(mat[i][k], mat[j][k]);
                    }
                    res = -res;
                    break;
                }
            }
            if (!flag)
            {
                return 0;
            }
        }
        for (int j = i + 1; j < n; ++j)
        {
            while (mat[j][i])
            {
                LL t = mat[i][i] / mat[j][i];
                for (int k = i; k < n; ++k)
                {
                    mat[i][k] = (mat[i][k] - t * mat[j][k]) % mod;
                    swap(mat[i][k], mat[j][k]);
                }
                res = -res;
            }
        }
        res = (res * mat[i][i]) % mod;
    }
    return (res + mod) % mod;
}

int main()
{
    int n;
    LL p;
    while (~scanf("%d%lld", &n, &p))
    {
        for (int i = 0; i < n; ++i)
        {
            for (int j = 0; j < n; ++j)
            {
                scanf("%lld", &mat[i][j]);
            }
        }
        LL ans = Det(n, p);
        printf("%lld
", ans);
    }
    return 0;
}

 10、uva 10791 Minimum Sum LCM

　　题意：求最大公约数为N的数的集合（至少包含2个），同时集合中数的和最少

　　思路：要使和最少，则为质因数。（注意大质因数、单因数、1等特殊情况）

#include<iostream>
#include<cmath>
#include<cstdio>
using namespace std;
long long Cal(long long ini)
{
    int  cnt=0;
    long long tmp,x=ini;
    long long ans=0;
    for (int i = 2; i <= sqrt(ini) + 1; i++)
    {
        tmp = 1;
        bool is = false;
        while(x%i == 0)
        {
            if (!is)
            {
                is = true;
                cnt++;
            }
            x = x / i;
            tmp = tmp * i;
        }
        if (is) ans += tmp;
    }
    if (x == ini) ans = ini + 1;
    else if (cnt == 1 || x != 1) ans += x;
    return ans;
}
int main()
{
    long long n;
    int Case = 1;
    while (~scanf("%lld", &n) && n)
    {
        printf("Case %d: %lld
", Case++, Cal(n));
    }
    return 0;
}