C++博客-ACM___________________________-随笔分类-ACM ( 数论 )

HDOJ 1999 HDU 1999 不可摸数 ACM 1999 IN HDU

MiYu — Sun, 15 Aug 2010 10:00:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=1999
题目描述:

不可摸数

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 2613 Accepted Submission(s): 694

Problem Description
s(n)是正整数n的真因子之和，即小于n且整除n的因子和.例如s(12)=1+2+3+4+6=16.如果任何
数m，s(m)都不等于n,则称n为不可摸数.

Input
包含多组数据，首先输入T,表示有T组数据.每组数据1行给出n(2<=n<=1000)是整数。

Output
如果n是不可摸数，输出yes，否则输出no

Sample Input
3
2
5
8

Sample Output
yes
yes
no

题目分析:

标准的筛选法。求出每个数的因子和，

然后看因子和是否在1000以内，是的话就证明等于因子和的这个数是不可摸数。

代码如下: ( 奋斗哥代码 0rz................... )

#include <iostream>
#include <string.h>
#include <cmath>
using namespace std;

int sum[1000001], sign[1001];
int main()
{
    int nCases, num;
    scanf("%d", &nCases);
    for(int i = 1; i <= 500000; ++i)
        for(int j = 2*i; j <= 1000000; j += i)
            sum[j] += i;
    for(int i = 1; i <= 1000000; ++i)
        if(sum[i] < 1000)
            sign[sum[i]] = 1;

    while(nCases--)
    {
        scanf("%d", &num);
        if(sign[num])
            printf("no\n");
        else
            printf("yes\n");
    }
    return 0;
}

MiYu 2010-08-15 18:00 发表评论

HDOJ 1286 HDU 1286 找新朋友 ACM 1286 IN HDU

MiYu — Fri, 13 Aug 2010 14:58:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目描述:
http://acm.hdu.edu.cn/showproblem.php?pid=1286
题目地址:

找新朋友

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 1868 Accepted Submission(s): 809

Problem Description
新年快到了，“猪头帮协会”准备搞一个聚会，已经知道现有会员N人，把会员从1到N编号，其中会长的号码是N号，凡是和会长是老朋友的，那么该会员的号码肯定和N有大于1的公约数，否则都是新朋友，现在会长想知道究竟有几个新朋友？请你编程序帮会长计算出来。

Input
第一行是测试数据的组数CN（Case number，1<CN<10000），接着有CN行正整数N（1<n<32768），表示会员人数。

Output
对于每一个N，输出一行新朋友的人数，这样共有CN行输出。

Sample Input
2
25608
24027

Sample Output
7680
16016

题目分析:

这题用 gcd 的话, 就 TLE 了, 很无语, 所以只能用筛法了, 因为 num如果能整除 i ,i > 1, 那么对i 的倍数, 肯定有大于1的公约数.
其实题目就是求和 num 互质的数的个数, 可以使用 euler 公式, 0ms 过.
欧拉公式:
如果n的标准素因子分解式是p1^a1*p2^a2*……*pm^am，其中众pj(j=1,2,……,m)都是素数，
而且两两不等。则有　　φ(n)=n(1-1/p1)(1-1/p2)……(1-1/pm)
φ(n) 为小于 n ,与n互质的数的个数.

筛法代码:

#include <iostream>
using namespace std;
int p[40000];
int euler ( int num )
{
    memset ( p , 0, sizeof (p) );
    int cnt = 0;
    for ( int i = 2; i <= num / 2; ++ i )
    {
          if ( num % i == 0 && p[i] == 0 )
          {
               for ( int j = i; j < num; j += i )
               {
                     if ( p[j] == 0 )
                     cnt ++;
                     p[j] = 1 ;
               }
          }
    }
    return num - cnt - 1;
}
int main ()
{
    int T;
    scanf ( "%d",&T );
    while ( T -- )
    {
          int num;
          scanf ( "%d",&num );
          printf ( "%d\n",euler ( num ) );
    }
    return 0;
}

欧拉代码: ( AC_Quester 神牛代码 <----0rz )

#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cstring>

int eular(int n)
{
        int ret=1,i;
        for (i=2;i*i<=n;i++)
        {
                if (n%i==0)
                {
                        n/=i,ret*=i-1;
                        while (n%i==0)
                                n/=i,ret*=i;
                }
        }
        if (n>1)
                ret*=n-1;
        return ret;
}
int main()
{
        int n ,a ;
        scanf("%d",&n);
        while(n--)
        {
                scanf("%d",&a);
                int res = eular(a);
                printf("%d\n",res);
        }
        return 0;
}

MiYu 2010-08-13 22:58 发表评论

HDOJ HDU 1133 Buy the Ticket ACM 1133 IN HDU

MiYu — Sun, 08 Aug 2010 09:20:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址 :
http://acm.hdu.edu.cn/showproblem.php?pid=1133
题目描述:

Problem Description
The "Harry Potter and the Goblet of Fire" will be on show in the next few days. As a crazy fan of Harry Potter, you will go to the cinema and have the first sight, won’t you?

Suppose the cinema only has one ticket-office and the price for per-ticket is 50 dollars. The queue for buying the tickets is consisted of m + n persons (m persons each only has the 50-dollar bill and n persons each only has the 100-dollar bill).

Now the problem for you is to calculate the number of different ways of the queue that the buying process won't be stopped from the first person till the last person.
Note: initially the ticket-office has no money.

The buying process will be stopped on the occasion that the ticket-office has no 50-dollar bill but the first person of the queue only has the 100-dollar bill.

Input
The input file contains several test cases. Each test case is made up of two integer numbers: m and n. It is terminated by m = n = 0. Otherwise, m, n <=100.

Output
For each test case, first print the test number (counting from 1) in one line, then output the number of different ways in another line.

Sample Input
3 0
3 1
3 3
0 0

Sample Output
Test #1:
6
Test #2:
18
Test #3:
180

卡特兰数的应用~~~ ^_^
1133 公式推导如下 :

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

( C(m+n, n) - C(m+n, m+1) ) * m! * n! 化简即 (m+n)! * (m-n+1) / (m+1)

推导过程如下 :

m个人拿50，n个人拿100

1:    所以如果 n > m，那么排序方法数为 0 这一点很容易想清楚

2:    现在我们假设拿50的人用 ‘0’表示，拿100的人用 1 表示。

      如果有这么一个序列 0101101001001111.

      当第K个位置出现1的个数多余0的个数时就是一个不合法序列了

      假设m=4 n=3的一个序列是：0110100 显然，它不合法，现在我们把它稍微变化一下：

      把第二个1（这个1前面的都是合法的）后面的所有位0变成1，1变成0

      就得到 0111011 这个序列1的数量多于0的数量，显然不合法，但现在的关键不是看这个序列是不是合法的

      关键是：它和我们的不合法序列 0110100 成一一对应的关系

      也就是说任意一个不合法序列(m个0，n个1)，都可以由另外一个序列(n-1个0和m+1个1)得到

      另外我们知道，一个序列要么是合法的，要么是不合法的

      所以，合法序列数量 = 序列总数量 - 不合法序列的总量

      序列总数可以这样计算m+n 个位置中，选择 n 个位置出来填上 1，所以是 C(m+n, n)

      不合法序列的数量就是： m+n 个位置中，选择 m+1 个位置出来填上 1 所以是 C(m+n, m+1)

      然后每个人都是不一样的，所以需要全排列 m! * n!

     所以最后的公式为 : ( C(m+n, n) - C(m+n, m+1) ) * m! * n! 化简即 (m+n)! * (m-n+1) / (m+1)

推广:
      如果原来有p张50元的话,那么不合法的序列的数量应该是:任意一个不合法序列(m个0，n个1)，

      都可以由另外一个序列(n-1个0和m+1+p个1)得到,所以是m+n 个位置中，选择 m+1+p 个位置

      出来填上 1 所以是 C(m+n, m+1+p) 接下来的化简就不推了.

代码如下 :

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <iostream>
#include <string>
using namespace std;
#define MAX 100
#define BASE 10000
void multiply(int a[],int Max,int b)  //大数乘小数
{
    int i,array=0;
    for (i=Max-1; i>=0; i--)
    {
        array+=b*a[i];
        a[i] = array%BASE;
        array /= BASE;
    }
}

void divide(int a[], int Max, int b)  //大数除小数
{
    int i,div=0;
    for (i=0;i<Max; i++)
    {
        div = div*BASE + a[i];
        a[i] = div / b;
        div %= b;
    }
}
int fact[205][MAX];
void setFact ()
{
     fact[0][MAX-1] = fact[1][MAX-1] = 1;
     for ( int i = 2; i <= 200; ++ i )
     {
           memcpy ( fact[i] , fact[i-1] , MAX * sizeof ( int ) );
           multiply ( fact[i] , MAX , i );
     }
}
void outPut ( int ctl[MAX] )
{
     int i = 0;
     while ( i < MAX && ctl[i] == 0 )
     {
             i ++ ; //去前导0
     }
     printf ( "%d", ctl[i++] );
     while ( i < MAX )
     {
             printf ( "%04d", ctl[i++] );
     }
     putchar ( '\n' );
}
int res[MAX];
int main ()
{
     int M,N;
     int ca = 1;
     setFact();
     while ( cin >> M >> N , M + N )
     {
             printf ( "Test #%d:\n",ca++ );
             if ( N > M )
             {
                  puts ( "0" );
                  continue;
             }
             memcpy ( res , fact[M+N] , MAX * sizeof ( int ) );      阶乘 ( m + n )!
             multiply ( res, MAX, M - N + 1 );                               ( m + n )! * ( m-n+1 )
             divide ( res, MAX, M + 1 );                                        ( m + n )! * ( m-n+1 )  / ( m+ 1 )
             outPut ( res );
     }
     return 0;
}

MiYu 2010-08-08 17:20 发表评论

HDOJ HDU 1023 1130 1133 1134 2067 ACM 1023 1130 1133 1134 2067 IN HDU ( 卡特兰数专题 catalan )

MiYu — Sun, 08 Aug 2010 09:08:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

卡特兰数专题

更多卡特兰数资料请看 卡特兰数

HDU 1023 1130 1134 2067 都是标准的卡特兰数, 具体说明请见 卡特兰数 ,只是有一点需要注意, 在35以下的catalan数

可以直接使用 long long 或 __int64 提交的, 但是当 N 超过35 之后, 这就需要大数了.

下面是 2067 的 long long 代码 ,详细请见 ( 2067 小兔的棋盘解题报告 ) 没有使用递归式 , 直接用的catalan 的迭代式. :

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include<iostream>
using namespace std;
typedef long long int64;
int64 f[37][37];
int main()
{
    int ca=0;
    int N;
    while ( cin >> N , N + 1 )
    {
        ++ ca;
        for ( int i = 1;i <= N; ++ i )
        {
              f[0][i] = 1;
        }
        for ( int i = 1; i < N; ++ i )
        {
              for ( int j = i; j <= N; ++ j )
              {
                    if ( i == j )
                    {
                         f[i][j] = f[i-1][j];
                    }
                    else
                    {
                         f[i][j] = f[i-1][j] + f[i][j-1];
                    }
              }
        }
        printf("%d %d %I64d\n", ca, N, 2 * f[N-1][N] );
    }
    return 0;
}

除了 2067 外, 其他的题目均是大数的类型, 在这里, 各位 ACMer , 请出你们的大数模板吧 .

或者某些代码牛人可以自己手打 <-------0rz

写好代码后只需按题目要求格式做相应的改变, 便能直接AC. 1133 稍微有点不同. 会在

最后给出它的解题报告.

1023 1130 1134 直接使用 catalan数的递归式 ,代码如下, 使用的是高精度乘法 ( 需要在输入结束控制方面根据各题做相应变化 ) :

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include<iostream>
using namespace std;
#define MAX 105
#define BASE 10000
typedef int myType[MAX+10];
void multiply ( int a[], int Max, int b )  //大数乘小数
{
    int i,array=0;
    for (i=Max-1; i>=0; i--)
    {
        array+=b*a[i];
        a[i] = array%BASE;
        array /= BASE;
    }
}

void divide ( int a[], int Max, int b )  //大数除小数
{
    int i,div=0;
    for (i=0;i<Max; i++)
    {
        div = div*BASE + a[i];
        a[i] = div / b;
        div %= b;
    }
}
void outPut ( myType ctl[MAX] ,int N )
{
     int i = 0;
     while ( i < MAX && ctl[N][i] == 0 )
     {
             i ++ ; //去前导0
     }
     cout << ctl[N][i++];
     while ( i < MAX )
     {
             printf ( "%04d", ctl[N][i++] );
     }
     cout << endl;
}
void setNum ( myType ctl[MAX] )
{
     memset ( ctl[1], 0, MAX * sizeof ( int ) );
     ctl[1][MAX-1] = 1;
     for ( int i = 2; i < 101; i ++ )
     {
         memcpy ( ctl[i], ctl[i-1], MAX * sizeof ( int ) );
         multiply ( ctl[i], MAX, 4 * i - 2 );
         divide ( ctl[i], MAX, i + 1 );
     }
}
myType ctl[MAX];
int main()
{
    setNum ( ctl );
    int N;
    while ( cin >> N )     // 这里根据各题要求需要做相应变化
    {
           outPut ( ctl, N );
    }
    return 0;
}

1133 公式推导如下 :

代码如下 :

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <iostream>
#include <string>
using namespace std;
#define MAX 100
#define BASE 10000
void multiply(int a[],int Max,int b)  //大数乘小数
{
    int i,array=0;
    for (i=Max-1; i>=0; i--)
    {
        array+=b*a[i];
        a[i] = array%BASE;
        array /= BASE;
    }
}

void divide(int a[], int Max, int b)  //大数除小数
{
    int i,div=0;
    for (i=0;i<Max; i++)
    {
        div = div*BASE + a[i];
        a[i] = div / b;
        div %= b;
    }
}
int fact[205][MAX];
void setFact ()
{
     fact[0][MAX-1] = fact[1][MAX-1] = 1;
     for ( int i = 2; i <= 200; ++ i )
     {
           memcpy ( fact[i] , fact[i-1] , MAX * sizeof ( int ) );
           multiply ( fact[i] , MAX , i );
     }
}
void outPut ( int ctl[MAX] )
{
     int i = 0;
     while ( i < MAX && ctl[i] == 0 )
     {
             i ++ ; //去前导0
     }
     printf ( "%d", ctl[i++] );
     while ( i < MAX )
     {
             printf ( "%04d", ctl[i++] );
     }
     putchar ( '\n' );
}
int res[MAX];
int main ()
{
     int M,N;
     int ca = 1;
     setFact();
     while ( cin >> M >> N , M + N )
     {
             printf ( "Test #%d:\n",ca++ );
             if ( N > M )
             {
                  puts ( "0" );
                  continue;
             }
             memcpy ( res , fact[M+N] , MAX * sizeof ( int ) );      //阶乘 ( m + n )!
             multiply ( res, MAX, M - N + 1 );                               //( m + n )! * ( m-n+1 )
             divide ( res, MAX, M + 1 );                                        //( m + n )! * ( m-n+1 )  / ( m+ 1 )
             outPut ( res );
     }
     return 0;
}

MiYu 2010-08-08 17:08 发表评论

错排公式 ( ACM 数论组合 )

MiYu — Sun, 08 Aug 2010 00:58:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

错排公式:

错排公式

目录
错排公式的由来
递推的方法推导错排公式
容斥原理
简化公式

错排公式的由来

　　pala提出的问题: 十本不同的书放在书架上。现重新摆放，使每本书都不在原来放的位置。有几种摆法？
　　这个问题推广一下，就是错排问题: n个有序的元素应有n！种不同的排列。如若一个排列式的所有的元素都不在原来的位置上，则称这个排列为错排。
递推的方法推导错排公式

　　当n个编号元素放在n个编号位置,元素编号与位置编号各不对应的方法数用M(n)表示,那么M(n-1)就表示n-1个编号元素放在n-1个编号位置,各不对应的方法数,其它类推.
　　第一步,把第n个元素放在一个位置,比如位置k,一共有n-1种方法;
　　第二步,放编号为k的元素,这时有两种情况.1,把它放到位置n,那么,对于剩下的n-2个元素,就有M(n-2)种方法;2,不把它放到位置n,这时,对于这n-1个元素,有M(n-1)种方法;
　　综上得到
　　M(n)=(n-1)[M(n-2)+M(n-1)]
　　特殊地，M(1)=0,M(2)=1
　　下面通过这个递推关系推导通项公式:
　　为方便起见，设M(k)=k!N(k), (k=1,2,…,n)
　　则N(1)=0,N(2)=1/2
　　n>=3时,n!N(n)=(n-1)(n-1)!N(n-1)+(n-1)!N(n-2)
　　即 nN(n)=(n-1)N(n-1)+N(n-2)
　　于是有N(n)-N(n-1)=-[N(n-1)-N(n-2)]/n=(-1/n)[-1/(n-1)][-1/(n-2)]…(-1/3)[N(2)-N(1)]=(-1)^n/n!
　　因此
　　N(n-1)-N(n-2)=(-1)^(n-1)/(n-1)!
　　N(2)-N(1)=(-1)^2/2!
　　相加，可得
　　N(n)=(-1)^2/2!+…+(-1)^(n-1)/(n-1)!+(-1)^n/n!
　　因此
　　M(n)=n![(-1)^2/2!+…+(-1)^(n-1)/(n-1)!+(-1)^n/n!]
　　可以得到
　　错排公式为M(n)=n!(1/2!-1/3!+…..+(-1)^n/n!)
容斥原理

　　正整数1、2、3、……、n的全排列有n!种，其中第k位是k的排列有（n-1)!，当k取1、2、3、……、n时，共有n*（n-1)!种排列，由于是错排，这些排列应排除，但是此时把同时有两个数不错排的排列多排除了一次，应补上；在补上时，把同时有三个数不错排的排列多补上了一次，应排除；……；继续这一过程，得到错排的排列种数为
　　M(n)=n!-n!/1!+n!/2!-n!/3!+…+(-1)^n*n!/n!=sigma(k=2~n) (-1)^k*n!/k!
　　即M(n)=n![1/0!-1/1!+1/2!-1/3!+1/4!+..+(-1)^n/n!]
　　注:sigma表示连加符号,(k=2~n)是连加的范围
简化公式

　　另外：书上的错排公式为Dn=n!(1/0!-1/1!+1/2!-1/3!-..+(-1)^n/n!),此公式算n很大时就很不方便．后来发现它可以化简为１个优美的式子Dn=[n!/e+0.5],[x]为取整函数．
　　公式证明较简单．观察一般书上的公式，可以发现e-1的前项与之相同，然后作比较可得/Dn-n!e-1/<1/(n+1)<0.5,于是就得到这个简单而优美的公式（此仅供参考）

MiYu 2010-08-08 08:58 发表评论

卡特兰数 Catalan数 ( ACM 数论组合 )

MiYu — Sat, 07 Aug 2010 13:51:00 GMT

维基百科资料:

卡塔兰数

卡塔兰数是组合数学中一个常出现在各种计数问题中出现的数列。由以比利时的数学家欧仁·查理·卡塔兰 (1814–1894)命名。

卡塔兰数的一般项公式为另类递归式： h(n)=((4*n-2)/(n+1))*h(n-1);

前几项为（OEIS中的数列A000108）: 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190, 6564120420, 24466267020, 91482563640, 343059613650, 1289904147324, 4861946401452, ...

[编辑]性质

C_n的另一个表达形式为所以，C_n是一个自然数；这一点在先前的通项公式中并不显而易见。这个表达形式也是André对前一公式证明的基础。(见下文的第二个证明。)

卡塔兰数满足以下递推关系

它也满足

这提供了一个更快速的方法来计算卡塔兰数。

卡塔兰数的渐近增长为

它的含义是左式除以右式的商趋向于1当n → ∞。（这可以用n!的斯特灵公式来证明。）

所有的奇卡塔兰数C_n都满足 $n = 2 k - 1$ 。所有其他的卡塔兰数都是偶数。

[编辑]应用

组合数学中有非常多.的组合结构可以用卡塔兰数来计数。在Richard P. Stanley的Enumerative Combinatorics: Volume 2一书的习题中包括了66个相异的可由卡塔兰数表达的组合结构。以下用C_n=3和C_n=4举若干例：

C_n表示长度2n的dyck word的个数。Dyck word是一个有n个X和n个Y组成的字串，且所有的部分字串皆满足X的个数大于等于Y的个数。以下为长度为6的dyck words:

XXXYYY XYXXYY XYXYXY XXYYXY XXYXYY

将上例的X换成左括号，Y换成右括号，C_n表示所有包含n组括号的合法运算式的个数:

((())) ()(()) ()()() (())() (()())

C_n表示有n+1个叶子的二叉树的个数。

C_n表示所有不同构的含n个分枝结点的满二叉树的个数。（一个有根二叉树是满的当且仅当每个结点都有两个子树或没有子树。）

证明：

令1表示进栈，0表示出栈，则可转化为求一个2n位、含n个1、n个0的二进制数，满足从左往右扫描到任意一位时，经过的0数不多于1数。显然含n个1、n个0的2n位二进制数共有个，下面考虑不满足要求的数目.

考虑一个含n个1、n个0的2n位二进制数，扫描到第2m+1位上时有m+1个0和m个1（容易证明一定存在这样的情况），则后面的0-1排列中必有n-m个1和n-m-1个0。将2m+2及其以后的部分0变成1、1变成0，则对应一个n+1个0和n-1个1的二进制数。反之亦然（相似的思路证明两者一一对应）。

从而。证毕。

C_n表示所有在n × n格点中不越过对角线的单调路径的个数。一个单调路径从格点左下角出发，在格点右上角结束，每一步均为向上或向右。计算这种路径的个数等价于计算Dyck word的个数： X代表“向右”，Y代表“向上”。下图为n = 4的情况：

C_n表示通过连结顶点而将n + 2边的凸多边形分成三角形的方法个数。下图中为n = 4的情况：

C_n表示对{1, ..., n}依序进出栈的置换个数。一个置换w是依序进出栈的当S(w) = (1, ..., n), 其中S(w)递归定义如下：令w = unv，其中n为w的最大元素，u和v为更短的数列；再令S(w) =S(u)S(v)n，其中S为所有含一个元素的数列的单位元。

C_n表示集合{1, ..., n}的不交叉划分的个数. 那么, C_n 永远不大于第n项贝尔数. C_n也表示集合{1, ..., 2n}的不交叉划分的个数，其中每个段落的长度为2。综合这两个结论，可以用数学归纳法证明 that all of the free cumulants of degree more than 2 of the Wigner semicircle law are zero. This law is important in free probability theory and the theory of random matrices.

C_n表示用n个长方形填充一个高度为n的阶梯状图形的方法个数。下图为 n = 4的情况:

百度百科资料:
简介

　　中文:卡特兰数
　　Catalan数是组合数学中一个常出现在各种计数问题中出现的数列。由以比利时的数学家欧仁·查理·卡塔兰 (1814–1894)命名。
　　原理：
　　令h(0)=1,h(1)＝1,catalan数满足递归式：
　　h(n)= h(0)*h(n-1) + h(1)*h(n-2) +  + h(n-1)h(0) (其中n>=2)
　　该递推关系的解为：
　　h(n)=C(2n,n)/(n + 1) (n=1,2,3,)
       另类递归式： h(n)=((4*n-2)/(n+1))*h(n-1);
　　
　　前几项为（OEIS中的数列A000108）: 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190, 6564120420, 24466267020, 91482563640, 343059613650, 1289904147324, 4861946401452,
应用

　　我总结了一下，最典型的四类应用：（实质上却都一样，无非是递归等式的应用，就看你能不能分解问题写出递归式了）
1.括号化问题。

　　矩阵链乘： P=a1×a2×a3×……×an，依据乘法结合律，不改变其顺序，只用括号表示成对的乘积，试问有几种括号化的方案？(h(n)种)
2.出栈次序问题。

　　一个栈(无穷大)的进栈序列为1,2,3,..n,有多少个不同的出栈序列?
　　类似：
　　(1)有2n个人排成一行进入剧场。入场费5元。其中只有n个人有一张5元钞票，另外n人只有10元钞票，剧院无其它钞票，问有多少中方法使得只要有10元的人买票，售票处就有5元的钞票找零？(将持5元者到达视作将5元入栈，持10元者到达视作使栈中某5元出栈)
　　(2)在圆上选择2n个点,将这些点成对连接起来，使得所得到的n条线段不相交的方法数。
3.将多边行划分为三角形问题。

　　将一个凸多边形区域分成三角形区域的方法数?
　　类似：一位大城市的律师在她住所以北n个街区和以东n个街区处工作。每天她走2n个街区去上班。如果她
　　从不穿越（但可以碰到）从家到办公室的对角线，那么有多少条可能的道路？
　　类似：在圆上选择2n个点,将这些点成对连接起来使得所得到的n条线段不相交的方法数?
4.给顶节点组成二叉树的问题。

　　给定N个节点，能构成多少种形状不同的二叉树？
　　(一定是二叉树!
　　先去一个点作为顶点,然后左边依次可以取0至N-1个相对应的,右边是N-1到0个,两两配对相乘,就是h(0)*h(n-1) + h(2)*h(n-2) +  + h(n-1)h(0)=h(n))
　　（能构成h（N）个）

MiYu 2010-08-07 21:51 发表评论

HDOJ HDU 2067 小兔的棋盘 ACM 2067 IN HDU

MiYu — Sat, 07 Aug 2010 13:37:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=2067
题目描述:

Problem Description
小兔的叔叔从外面旅游回来给她带来了一个礼物，小兔高兴地跑回自己的房间，拆开一看是一个棋盘，小兔有所失望。不过没过几天发现了棋盘的好玩之处。从起点(0，0)走到终点(n,n)的最短路径数是C(2n,n),现在小兔又想如果不穿越对角线(但可接触对角线上的格点)，这样的路径数有多少?小兔想了很长时间都没想出来，现在想请你帮助小兔解决这个问题，对于你来说应该不难吧!

Input
每次输入一个数n(1<=n<=35)，当n等于－1时结束输入。

Output
对于每个输入数据输出路径数，具体格式看Sample。

Sample Input
1
3
12
-1

Sample Output
1 1 2
2 3 10
3 12 416024

题目分析:

假设小兔的棋盘是 8 × 8 的 ( 当然你也可以假设是其他 )。如下图:
箭头方向表示从该格子下一步能去的格子。因为不能穿越对角线，所有对角线上的格子只有进去的箭头，没有出来的箭头。

观察上图你就可以发现，其实这是一张关于对角线对称的图。所有我们只要求一个方向的值，然后乘以2即可。
我们就拿下三角来考虑。不难发现，所有在0列上的格子，路径数都是 1 (只能从上面过来)。
而其他格子则都是由上、左两个方向过来，即:f(i, j) = f(i - 1, j) + f(i, j - 1);
另外f(i, i) = f(i, j - 1) 或者 f(i, i) = f( i-1, j ) ;

代码如下:

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include<iostream>
using namespace std;
typedef long long int64;
int64 f[37][37];
int main()
{
    int ca=0;
    int N;
    while ( cin >> N , N + 1 )
    {
        ++ ca;
        for ( int i = 1;i <= N; ++ i )
        {
              f[0][i] = 1;
        }
        for ( int i = 1; i < N; ++ i )
        {
              for ( int j = i; j <= N; ++ j )
              {
                    if ( i == j )
                    {
                         f[i][j] = f[i-1][j];
                    }
                    else
                    {
                         f[i][j] = f[i-1][j] + f[i][j-1];
                    }
              }
        }
        printf("%d %d %I64d\n", ca, N, 2 * f[N-1][N] );
    }
    return 0;
}

另外看别人的解题报告说这个是卡特兰数 ( 详细请查看 <<卡特兰数>> ), 其实现在还不理解, 分析如下:

Catalan数。。
令h(1)＝1,h(0)=1，catalan数满足递归式：
　　h(n)= h(0)*h(n-1)+h(1)*h(n-2) + + h(n-1)h(0) (其中n>=2)
　　另类递归式：
　　h(n)=((4*n-2)/(n+1))*h(n-1);
　　该递推关系的解为：
　　h(n)=C(2n,n)/(n+1) (n=1,2,3,…)

附卡特兰代码:

#include<stdio.h>
int main()
{
    __int64 a[37][37]={0};
    int i,j,n,t=0;
    a[0][0]=0;
    a[0][1]=1;
    a[1][1]=2;
    for(i=2;i<37;i++)
    {
        a[i][0]=1;
        for(j=1;j<i-1;j++)
            a[i][j]=a[i][j-1]+a[i-1][j];
        a[i][i-1]=a[i][i-2]+a[i-1][i-1]/2;
        a[i][i]=2*a[i][i-2]+a[i-1][i-1];

    }
    while(scanf("%d",&n)&&n!=-1)
    {
        printf("%d %d %I64d\n",++t,n,a[n][n]);
    }
    return 0;
}

MiYu 2010-08-07 21:37 发表评论

求质数之筛法 ( 数论 C语言描述 zz )

MiYu — Sat, 07 Aug 2010 09:03:00 GMT

摘要: 【问题描述】：　　　试编写一个程序，找出2->N之间的所有质数。希望用尽可能快的方法实现。【问题分析】：　　　这个问题可以有两种解法：一种是用“筛子法”，另一种是“除余法”。　　　如果要了解“除余法”，请看另一篇文章《求质数之除余法(C语言描述)》。　　　这里我们来讨论一下用“筛法&#... 阅读全文

MiYu 2010-08-07 17:03 发表评论

求质数之除余法 ( 数论 C语言描述 zz )

MiYu — Sat, 07 Aug 2010 09:01:00 GMT

问题描述

试编写一个程序，找出 2→N 之间的所有质数（质数的概念请看这里），用尽可能快的方法实现。

问题分析

这个问题可以有两种解法：一种是用“筛子法”，另一种是从 2→N 逐一检测出质数。如果要了解“筛法”，请看另一篇文章《求质数之筛法》。

现在来介绍第二种方法。用这种方法，最先想到的就是让从2→N逐一检查。如果是就显示出来，如果不是，就继续检查下一个直到超出范围 N。这是正确的做法，但效率却不高。当然，2 是质数，那么 2 的倍数就不是质数，如果令 i 从 2→N，就很冤枉地测试了 4、6、8……这些数？所以第一点改建就是只测试 2 与所有的奇数就足够了。同理，3 是质数，但6、9、12……这些 3 的倍数却不是，因此，如果能够把 2 与 3 的倍数跳过去而不测试，任意连续的 6 个数中，就只会测试 2 个而已。以6n, 6n+1, 6n+2, 6n+3, 6n+4, 6n+5 为例，6n, 6n+2, 6n+4 是偶数，又 6n+3 是 3 的倍数，所以如果 2 与 3 的倍数都不理会，只要测试的数就只留下6n+1和6n+5而已了，因而工作量只是前面想法的 2/6 = 1/3，应该用这个方法编程。

还有个问题，就是如果判断一个数 i 是否为素数。按素数的定义，也就是只有 1 与本身可以整除，所以可以用 2→i-1 去除 i，如果都除不尽，i 就是素数。观点对，但却与上一点一样的笨拙。当 i>2 时，有哪一个数可以被 i-1 除尽的？没有！为什么？如果 i 不是质数，那么 i=a×b，此地 a 与 b 既不是 i 又不是 1；正因为 a>1，a 至少为 2，因此 b 最多也是 i/2 而已，去除 i 的数用不着是 2→i-1，而用 2→i/2 就可以了。不但如此，因为 i=a×b，a 与 b 不能大于 sqrt(i)，为什么呢？如果 a>sqrt(i)，b>sqrt(i)，于是 a×b > sqrt(i)*sqrt(i) = i，因此就都不能整除i了。如果i不是质数，它的因子最大就是 sqrt(i)；换言之，用 2→sqrt(i)去检验就行了。

但是，用 2→sqrt(i) 去检验也是浪费。就像前面一样，2 除不尽，2 的倍数也除不尽；同理，3 除不尽，3 的倍数也除不尽……最理想的方法就是用质数去除i。

但问题是这些素数从何而来？这比较简单，可以准备一个数组 prime[]，用来存放找到的素数，一开始它里面有 2、3、5。检查的时候，就用 prime[] 中小于 sqrt(i)的数去除 i 即可，如果都除不尽，i 就是素数，把它放如 prime[] 中，因此 prime[] 中的素数会越来越多，直到满足个数为止！

不妨用这段说明来编写这个程序，但是程序设计的时候会有两个小问题：

如果只检查 6n+1 和 6n+5 ？不难发现，它们的距离是4、2、4、2……所以，可以先定义一个变量 gab=4，然后 gab=6-gab;
比较是不能用 sqrt(i)，因为它不精确。举个例子，i=121，在数学上，sqrt(i) 自然是 11，但计算机里的结果可能是 10.9999999，于是去除的数就是 2、3、5、7，而不含 11，因此 121 就变成质数了。解决这个问题的方法很简单，不要用开方，用平方即可。例如，如果 p*p<=i，则就用 p 去除 i。而且它的效率比开方高。

程序清单

copy to clipboard?
#include   
    
#include   
    
int creat_prime ( int prime[], int n, int total )  
    
{  
    
    int i, *p, g = 2;  
    
    for ( i = 7; i <= n; i += g ) {  
    
        g = 6 - g;  
    
        p = prime;  
    
        while ( (*p) * (*p) <= i && i % (*p) ) {  
    
            p++;  
    
        }  
    
        if ( i % (*p) ) {  
    
            prime[total++] = i;  
    
        }  
    
    }  
    
    return total;  
    
}  
    
int main(void)  
    
{  
    
    int prime[30000] = { 2, 3, 5 };  
    
    int total = 3;     /* 找到素数的个数 */  
    
    int n = 200000;    /* 要查找的范围(>=6) */  
    
    int i;  
    
    total = creat_prime ( prime, n, total );  
    
    for ( i = 0; i < total; i++) {  
    
        printf ( "%d ", prime[i] );  
    
        if ( i && !(i % 10) )  
    
            putchar ( '\n' );  
    
    }  
    
    putchar ( '\n' );  
    
    return EXIT_SUCCESS;  
    
}

本文转载自 :

版权声明

本人的所有原创文章皆保留版权，请尊重原创作品。
转载必须包含本声明，保持本文完整，并以超链接形式注明原始作者“redraiment”和主站点上的本文原始地址。

联系方式

我的邮箱，欢迎来信（redraiment@gmail.com）
我的Blogger（子清行）
我的Google Sites（子清行）
我的CSDN博客（梦婷轩）
我的百度空间（梦婷轩）

MiYu 2010-08-07 17:01 发表评论

The Sieve of Eratosthees ( 爱拉托逊斯筛选法数论筛法 )

MiYu — Sat, 07 Aug 2010 08:37:00 GMT

转载文章：转载自Tanky Woo 的程序人生 , <------- 请大家多多支持奋斗哥哈

The Sieve of Eratosthees
爱拉托逊斯筛选法思想：对于不超过n的每个非负整数P，删除2*P, 3*P…，当处理

完所有数之后，还没有被删除的就是素数。

若用vis==1表示已被删除，则代码如下：
—————————————————–
代码一：

memset(vis, 0, sizeof(vis));
for(int i = 2; i <= 100; i++)
for(int j = i*2; j <= 100; j += i)
vis[j] = 1;

复制代码

上面的代码效率已经很高了。
但还可以继续优化。
看一个改进的代码：
——————————————————
代码二：

int m = sqrt(double(n+0.5));
for(int i = 2; i <= m; i++)
if(!vis[i])
{
prime[c++] = i;
for(int j = i*i; j <= n; j += i)
{
vis[j] = 1;
}
}

复制代码

——————————————————
先分析代码一：
这个代码就是简单的将Eratosthenes筛选法描述出来。不用多说。
分析代码二：
考虑几点：
1.为何从i=2~m?
因为下面的j是从i*i开始的。
2.为何j从i*i开始？
因为首先在i=2时，偶数都已经被删除了。
其次，“对于不超过n的每个非负整数P”， P可以限定为素数，
为什么？
因为，在 i 执行到P时，P之前所有的数的倍数都已经被删除，若P

没有被删除，则P一定是素数。
而P的倍数中，只需看：
(p-4)*p, (p-2)*p, p*p, p*(p+2), p*(p+4)
（因为P为素数，所以为奇数，而偶数已被删除，不需要考虑p*(p

-1)等）
又因为(p-4)*p 已在 (p-4)的p倍中被删去，故只考虑：
p*p, p*(p+2)….即可
这也是i只需要从2到m的原因。
当然，上面 p*p, p*(p+2)…的前提是偶数都已经被删去，而代码

二若改成 j += 2*i ,则没有除去所有偶数，所以要想直接加2*i

。只需在代码二中memset()后面加：
for(int i = 4; i <= n; i++)
if(i % 2 == 0)
vis = 1;
这样，i只需从3开始，而j每次可以直接加 2*i.
——————————————————
这里用代码二给大家一个完整的代码：

//版本二
//Author: Tanky Woo
//BBS:www.cppleyuan.com
#include
#include
#include
int vis[100];
int prime[100];
int c = 0;
int n;
int main()
{
scanf("%d", &n);
int cnt = 1;
memset(vis, 0, sizeof(vis));
int m = sqrt(double(n+0.5));
for(int i = 2; i <= m; i++)
if(!vis[i])
{
prime[c++] = i;
for(int j = i*i; j <= n; j += i)
{
vis[j] = 1;
//printf("%d\n", j);
}
}
for(int i = 2; i < n; i++)
{
if(vis[i] == 0)
{
printf("%d ", i);
cnt++;
if(cnt % 10 == 0)
printf("\n");
}
}
printf("\ncnt = %d\n", cnt);
return 0;
}

复制代码

完毕。

欢迎大家和我交流。

转载文章：转载自Tanky Woo 的程序人生

MiYu 2010-08-07 16:37 发表评论

HDOJ HDU 2080 夹角有多大II ACM 2080 IN HDU

MiYu — Sat, 07 Aug 2010 07:11:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=2080
题目描述:

Problem Description
这次xhd面临的问题是这样的：在一个平面内有两个点，求两个点分别和原点的连线的夹角的大小。

注：夹角的范围[0，180]，两个点不会在圆心出现。

Input
输入数据的第一行是一个数据T，表示有T组数据。
每组数据有四个实数x1,y1,x2,y2分别表示两个点的坐标,这些实数的范围是[-10000,10000]。

Output
对于每组输入数据，输出夹角的大小精确到小数点后两位。

Sample Input
2
1 1 2 2
1 1 1 0

Sample Output
0.00
45.00

题目分析:
         纯数学题.   有多边型面积公式, 我们可以得到三角型的面积 : S = ( x0 * y1 - x1 * y0 ) / 2.
而由三角型正弦定理我们知道 : S = 1 / 2 * A * B * sinV . 联立 2方程就可以得到夹角V 的解
的方程 :  sinV = ( x0 * y1 - x1 * y0 ) / A / B ;       最后利用 c 数学库函数 asin就可以求出V的弧
度值, 把弧度转换成角度就可以了.   ( 注意平角和钝角的判断 )

代码如下 :

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main ()
{
    int T;
    cin >> T;
    while ( T -- )
    {
            double x0,x1,y0,y1;
            cin >> x0 >> y0 >> x1 >> y1;
            double A = sqrt ( x0 * x0 * 1.0 + y0 * y0 * 1.0 );
            double B = sqrt ( x1 * x1 * 1.0 + y1 * y1 * 1.0 );
            double resin = ( fabs ( x0 * y1 - x1 * y0 ) ) / A / B ;
            double res = asin ( resin ) * 180.0 / acos( -1 );
            res = res < 1e-5 ? ( x0 * x1 < 0 ? 180.0 : 0.0 )                          //平角
                             : ( x0 * x1 <= 0 && y0 * y1 <= 0 ? 180.0 - res : res );  //是否钝角
            cout << setprecision (2) << setiosflags ( ios::fixed ) << res << endl;
    }
    return 0;
}

MiYu 2010-08-07 15:11 发表评论

HDOJ HDU 2078 复习时间 ACM 2078 IN HDU

MiYu — Sat, 07 Aug 2010 05:41:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=2078
题目描述:

Problem Description
为了能过个好年，xhd开始复习了，于是每天晚上背着书往教室跑。xhd复习有个习惯，在复习完一门课后，他总是挑一门更简单的课进行复习，而他复习这门课的效率为两门课的难度差的平方,而复习第一门课的效率为100和这门课的难度差的平方。xhd这学期选了n门课，但是一晚上他最多只能复习m门课，请问他一晚上复习的最高效率值是多少？

Input
输入数据的第一行是一个数据T，表示有T组数据。
每组数据的第一行是两个整数n(1 <= n <= 40)，m(1 <= m <= n)。
接着有n行，每行有一个正整数a(1 <= a <= 100)，表示这门课的难度值。

Output
对于每组输入数据，输出一个整数，表示最高效率值。

Sample Input
2
2 2
52
25
12 5
89
64
6
43
56
72
92
23
20
22
37
31

Sample Output
5625
8836

由题意我们很容易了解到 : 前一门课为 N, 后一门课为 M , 则学习 M 课的效率为 ( N - M )^2 , 那么学习第一节的效率为

( 100 - N )² , 有题目我们知道: 下一门需要学习的课比上一次更简单, 所以 N > M, 那么此时学习的效率为 :

F1 = ( 100 - N )² + ( N - M )² = 100² - 2*100*N + N² + N² - 2*N*M + M² = 100² + M² - 2*N*( 100+M-N );

而直接学习最简单的课程的效率为:

F2 = ( 100 - M )² = 100² +M² - 2*100*M

因为 2*N*( 100+M-N ) - 2*100*M = ( N - M ) * ( 200 - 2*N ) ,有上面的分析我们知道 N > M , N < 100 , 于是就有

( N - M ) * ( 200 - 2*N ) > 0 ; 也就是说 F2 > F1 ;

有分析可以看出 , 要想效率最高, 只需要找出简单的课程直接学习就可以了.

代码如下 :

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <iostream>
using namespace std;
int main ()
{
    int T;
    cin >> T;
    while ( T -- )
    {
            int n,m;
            cin >> n >> m;
            int min = 100;
            for ( int i = 1; i <= n; ++ i )
            {
                  cin >> m;
                  if ( min > m )
                  {
                       min = m;
                  }
            }
            cout << ( 100 - min ) * ( 100 - min ) << endl;
    }
    return 0;
}

MiYu 2010-08-07 13:41 发表评论

HDOJ HDU 2086 A1 = ? ACM 2086 IN HDU

MiYu — Fri, 06 Aug 2010 08:52:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=2086
题目描述:

Problem Description
有如下方程：Ai = (Ai-1 + Ai+1)/2 - Ci (i = 1, 2, 3, . n).
若给出A0, An+1, 和 C1, C2, ..Cn.
请编程计算A1 = ?

Input
输入包括多个测试实例。
对于每个实例，首先是一个正整数n,(n <= 3000); 然后是2个数a0, an+1.接下来的n行每行有一个数ci(i = 1, .n);输入以文件结束符结束。

Output
对于每个测试实例，用一行输出所求得的a1(保留2位小数).

Sample Input
1
50.00
25.00
10.00
2
50.00
25.00
10.00
20.00

Sample Output
27.50
15.00

这道题的关键在于公式的推导, 公式推出来问题就解决了:

Ai = (Ai-1 + Ai+1)/2 - Ci (i = 1, 2, 3, . n). 用A5做示范，就能猜测出公式来。证明方法可以采用数学归纳法。这里证明从略。
A5 = (A4 + A6) / 2 - C5
A4 = (A3 + A5) / 2 - C4 = A3 / 2 + A4 / 4 + A6 / 4 - C5 / 2 - C4
=>A4 = 2A3/3 + A6/3 - 2C5/3 - 4C4/3

A3 = (A2 + A4) / 2 - C3 = A2 / 2 + A3 / 3 + A6 / 6 - C5 / 3 - 2C4 / 3 - C3
=>A3 = 3A2/4 + A6/4 - C5/2 - C4 - 3C3/2

A2 = (A1 + A3) / 2 - C2 = A1 / 2 + 3A2 / 8 + A6 / 8 - C5 / 4 - C4 / 2 - 3C3 / 4 - C2
=>A2 = 4A1/5 + A6/5 - 2C5/5 - 4C4/5 - 6C3/5 - 8C2/5

A1 = (A0 + A2) / 2 - C1 = A0 / 2 + 2A1 / 5 + A6 / 10 - C5 / 5 - 2C4 / 5 - 3C3 / 5 - 4C2 / 5 - C1
=>A1 = 5A0/6 + A6/6 - C5/3 - 2C4/3 - C3 - 4C2/3 - 5C1/3

算到这里，我想你已经总结出公式了:
A1 = (n * A0 + An+1 - 2 * Cn - 4 * Cn-1 - - 2 * i * Cn-i+1 - 2 * n * C1) / (n + 1)

代码如下 :

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <stdio.h>
int main ()
{
    int n, i;
    double a0, an1, a1;
    double c[3000];
    while ( scanf ( "%d", &n) != EOF )
    {
        scanf ( "%lf%lf", &a0, &an1 );
        for ( i = 0; i < n; i++ )
        {
             scanf("%lf", c + i);
        }
        a1 = n * a0 + an1;
        for ( i = 1; i <= n; i++ )
        {
              a1 -= 2 * i * c[n - i];
        }
        printf ( "%.2f\n", a1 / ( n + 1 ) );
    }
    return 0;
}

MiYu 2010-08-06 16:52 发表评论

HDOJ HDU 2068 RPG的错排 ACM 2068 IN HDU

MiYu — Fri, 06 Aug 2010 08:00:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=2068
题目描述:

Problem Description
今年暑假杭电ACM集训队第一次组成女生队,其中有一队叫RPG,但做为集训队成员之一的野骆驼竟然不知道RPG三个人具体是谁谁。RPG给他机会让他猜猜，第一次猜：R是公主，P是草儿，G是月野兔；第二次猜：R是草儿，P是月野兔，G是公主；第三次猜：R是草儿，P是公主，G是月野兔；可怜的野骆驼第六次终于把RPG分清楚了。由于RPG的带动，做ACM的女生越来越多，我们的野骆驼想都知道她们，可现在有N多人，他要猜的次数可就多了，为了不为难野骆驼，女生们只要求他答对一半或以上就算过关，请问有多少组答案能使他顺利过关。

Input
输入的数据里有多个case,每个case包括一个n，代表有几个女生，（n<=25）, n = 0输入结束。

Sample Input
1
2
0

Sample Output
1
1

很明显的错排 + 排列组合的题目. 更多错排资料请点击 --> << 错排公式 >>

要猜对一半或一半以上, 那么就是从给出的 n 个人中取出小于或等于 n / 2 的人进行错排 ,

因为题目问的是顺利通关的所有解, 所以最后需要累加 0 -> n / 2 的错排方法.

错排公式 : F ( n ) = ( n - 1 ) * ( F(n-1) + F ( n - 2 ) )

代码如下 :

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <stdio.h>
typedef long long int64;
int64 Com ( int n, int m ) // 取 C_n^{m 的组合数}
{
      if ( m == 0 )
      {
           return 1;
      }
      int64 up = 1,down = 1;
      for ( int i = 0; i < m; ++ i )
      {
            up *= n - i;
            down *= i + 1;
      }
      return up / down;
}
int64 F[14] = { 0, 0, 1, 2 };
void setNum ()
{
     for ( int i = 4; i < 14; ++ i )
     {
           F[i] = ( i - 1 ) * ( F[ i - 1 ] + F[ i - 2 ] );
     }
}
int main ()
{
    int N;
    int64 sum;
    setNum ();
    while ( scanf("%d", &N), N )
    {
          sum = 1;
          for ( int i = N / 2; i >= 0; -- i )
          {
               sum += Com ( N , i ) * F[i];    // 从N中取i 个人的错排数
          }
          printf("%I64d\n", sum );
    }
}

MiYu 2010-08-06 16:00 发表评论

HDOJ HDU 2077 汉诺塔IV ACM 2077 IN HDU

MiYu — Fri, 06 Aug 2010 07:21:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=2077
题目描述:

Problem Description
还记得汉诺塔III吗？他的规则是这样的：不允许直接从最左(右)边移到最右(左)边(每次移动一定是移到中间杆或从中间移出)，也不允许大盘放到小盘的上面。xhd在想如果我们允许最大的盘子放到最上面会怎么样呢？（只允许最大的放在最上面）当然最后需要的结果是盘子从小到大排在最右边。

Input
输入数据的第一行是一个数据T，表示有T组数据。
每组数据有一个正整数n(1 <= n <= 20)，表示有n个盘子。

Output
对于每组输入数据，最少需要的摆放次数。

Sample Input
2
1
10

Sample Output
2
19684

因为最大的可以放在最上面, 所以就不能像汉诺塔III那样把前n-1个盘全部从1->3了.

只要把前n-1个盘从1->2,然后把第n个盘1->2->3,然后把前n-1个盘2->3, 这样就完成了.

所以,问题现在转换成 n 个盘移动一步需要多少次. 我们可以看到, 除了最后一个最

大的盘n以外, 前n-1个盘的移动方式是和汉诺塔III的规则是一样的.所以我们先把前

n-2 个盘 1->3, 然后把第n-1个盘 1->2, 再把前n-2个盘 3->2, 这样就把前 n-1个盘

1->2 移动了一步.
因为把 n 个盘按找汉诺塔III的方法 1->3 需要 3ⁿ -1 推导见 :

HDOJ HDU 2064 汉诺塔III ACM 2064 IN HDU

所以由上面描述的步骤知道把 n 个盘移动一步需要 : f(n) = f(n-1) + ( 3^n-1- 1 ) + 1 = f (n-1) + 3^n-1 而 f(1) = 1
由递推式化简得: f(n) = 3^n-1 + 3^n-2 + ...+ 3 + 1 = ( 3ⁿ -1 ) / 2
所以按汉诺塔IV的规则, 移动 n 个盘需要 : m(n) = 2 * f (n-1) + 2 = 3^n-1 + 1

代码如下:

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <iostream>
#include <cmath>
using namespace std;
long long myPow ( int n , int e )
{
     long long mlt = 1;
     for ( int i = 1; i <= e ; ++ i )
     {
           mlt *= n;
     }
     return mlt;
}
int main ()
{
    int N;
    while ( cin >> N )
    {
          cout << myPow ( 3, N - 1 ) + 1 << endl;
    }
    return 0;
}

MiYu 2010-08-06 15:21 发表评论

HDOJ HDU 1060 Leftmost Digit ACM 1060 IN HDU

MiYu — Fri, 06 Aug 2010 06:51:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=1060
题目描述:

Problem Description
Given a positive integer N, you should output the leftmost digit of N^N.

Input
The input contains several test cases. The first line of the input is a single integer T which is the number of test cases. T test cases follow.
Each test case contains a single positive integer N(1<=N<=1,000,000,000).

Output
For each test case, you should output the leftmost digit of N^N.

Sample Input
2
3
4

Sample Output
2
2

解题思路:
m=n^n,两遍分别对10取对数得 log10(m)=n*log10(n),得m=10^(n*log10(n)),由于10的任何整数次幂首位一定为1,所以m的首位只和n*log10(n)的小数部分有关
代码如下 :

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <iostream>
#include <cmath>
using namespace std;
typedef long long int64;
int main()
{
    int64 N,i,a,sum;
    double s,num,x;
    cin >> N;
    while ( N -- )
    {
       cin >> num;
       s = num * log10 ( num );
       a = ( int64 ) s;
       x = s - a;
       sum = ( int64 ) pow ( ( double ) 10, ( x ) );
       cout << sum << endl;
    }
    return 0;
}

MiYu 2010-08-06 14:51 发表评论

HDOJ HDU 1164 Eddy's research I ACM 1164 IN HDU

MiYu — Fri, 06 Aug 2010 01:18:00 GMT

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=1164
题目描述:
把一个数拆分成素数的乘积.

素数的水题 , 只要把素数提取出来, 暴力就可以了.
代码如下 :

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <iostream>
using namespace std;
int num[70001];
int main ()
{
    for ( int i = 2; i <= 70000; ++ i )
    {
          if ( !num[i] )
          for ( int j = 2; i * j <= 70000; ++ j )
          {
                num[i*j] = 1;
          }
    }
    int N;
    while ( cin >> N )
    {
           int n = N;
           int f = 1;
           while ( n != 1 )
           {
                  int i = 2;
                  for ( ; i <= 65535; ++ i )
                  {
                        if ( !num[i] && n % i == 0 )
                        {
                              if ( f )
                              {
                                   cout << i;
                                   f = 0;
                              }
                              else
                              {
                                   cout << "*" << i;
                              }
                              break;
                        }
                  }
                  n /= i;
           }
           cout << endl;
    }
//    getchar();
    return 0;
}

MiYu 2010-08-06 09:18 发表评论

HDOJ HDU 2058 The sum problem ACM 2058 IN HDU

MiYu — Wed, 04 Aug 2010 14:18:00 GMT

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址 :
http://acm.hdu.edu.cn/showproblem.php?pid=2058

观察a+1,a+2…a+d
全部相加等于M
即(a+1+a+d)*d/2 = M,
这里d是平方，我们可以从长度d入手，这样就能把范围由M转换成M^1/2 ;

这里把代码中的①和②解释下：
①：当a+1,a+2…a+3相加等于M时，即
(a+1+a+d)*d/2 = M
而a最小是0，所以(d+1)*d/2=M时d去最大值，就是这步把时间复杂度减小的。
d就是sqrt(2*M)

②：(a+1+a+d)*d/2 = M
所以a*d + (d+1)/2 = M
所以要使等式成立，M-(d+1)/2必须是d的倍数。
此为奋斗哥的代码 : 0rz........下

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
int N, M;
int main()
{
    int flag = 0;
    while(scanf("%d %d", &N, &M) && (M||N))
    {
        int i;
        int len = int(sqrt(M*2.0));  // ①
        for(i=len; i>=1; --i)
        {
            int temp = M-(i*i+i)/2;   // ②
            if(temp%i == 0)
                printf("[%d,%d]\n", temp/i+1, temp/i+i);
        }
        printf("\n");
    }
    return 0;
}

MiYu 2010-08-04 22:18 发表评论

HDOJ HDU 2672 god is a girl ACM 2672 IN HDU

MiYu — Wed, 04 Aug 2010 04:47:00 GMT

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址 :
http://acm.hdu.edu.cn/showproblem.php?pid=2672

好吧..............我承认, 当我看这题的解题报告时, 我被征服了................
代码如下:

//MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include <iostream>
#include <string>
#include <cctype>
using namespace std;
int a[1001] = { 0, 1, 1 };
int main ()
{
    // 第N个字母对应第N个FIBONACI数列的第N项 ,当然,这是字母,要取模
    for ( int i = 2; i < 1001; ++ i )
    {
          a[i] = ( a[i - 1] + a[i - 2] ) % 26;
    }
    string str;
    while ( getline ( cin , str ) )
    {
            int num = 0;
            for ( int i = 0; str[i]; ++i )
            {
                  //对每个A-Z字符进行处理
                  if ( isupper ( str[i] ) )
                  {
                       num ++;
                       printf ( "%c", isupper ( str[i] + a[num] ) ? str[i] + a[num] : str[i] + a[num] - 26 );
                  }
                  else
                  {
                       printf ( "%c", str[i] );
                  }
            }
            printf("\n");
    }
    return 0;
}

MiYu 2010-08-04 12:47 发表评论

C++博客-ACM___________________________-随笔分类-ACM ( 数论 )

HDOJ 1999 HDU 1999 不可摸数 ACM 1999 IN HDU

HDOJ 1286 HDU 1286 找新朋友 ACM 1286 IN HDU

HDOJ HDU 1133 Buy the Ticket ACM 1133 IN HDU

HDOJ HDU 1023 1130 1133 1134 2067 ACM 1023 1130 1133 1134 2067 IN HDU ( 卡特兰数 专题 catalan )

错排公式 ( ACM 数论 组合 )

卡特兰数 Catalan数 ( ACM 数论 组合 )

维基百科资料:

卡塔兰数

[编辑]性质

[编辑]应用

HDOJ HDU 2067 小兔的棋盘 ACM 2067 IN HDU

求质数 之 筛法 ( 数论 C语言描述 zz )

求质数 之 除余法 ( 数论 C语言描述 zz )

问题描述

问题分析

程序清单

版权声明

联系方式

The Sieve of Eratosthees ( 爱拉托逊斯筛选法 数论 筛法 )

HDOJ HDU 2080 夹角有多大II ACM 2080 IN HDU

HDOJ HDU 2078 复习时间 ACM 2078 IN HDU

HDOJ HDU 2086 A1 = ? ACM 2086 IN HDU

HDOJ HDU 2068 RPG的错排 ACM 2068 IN HDU

HDOJ HDU 2077 汉诺塔IV ACM 2077 IN HDU

HDOJ HDU 1060 Leftmost Digit ACM 1060 IN HDU

HDOJ HDU 1164 Eddy's research I ACM 1164 IN HDU

HDOJ HDU 2058 The sum problem ACM 2058 IN HDU

HDOJ HDU 2672 god is a girl ACM 2672 IN HDU

HDOJ HDU 1023 1130 1133 1134 2067 ACM 1023 1130 1133 1134 2067 IN HDU ( 卡特兰数专题 catalan )

错排公式 ( ACM 数论组合 )

卡特兰数 Catalan数 ( ACM 数论组合 )

求质数之筛法 ( 数论 C语言描述 zz )

求质数之除余法 ( 数论 C语言描述 zz )

The Sieve of Eratosthees ( 爱拉托逊斯筛选法数论筛法 )