C++博客-ArcTan-文章分类-ACM-数学

hdu 2971 (线性变换-矩阵乘法)

wangs — Wed, 08 Aug 2012 01:41:00 GMT

http://acm.hdu.edu.cn/showproblem.php?pid=2971

对于：f[n]=a*f[n-1]+b*f[n-2]....这类线性变换，构造变换矩阵，用矩阵乘法来做。

一般数会很大，结果mod一个整数。这里要注意变换矩阵中可能存在负数，需要求出关于mod的逆元来运算。

总结：线性变换矩阵乘法 TLE处理

using namespace std;

long long c,n;
long long mod;
long long mtx[5][5];
long long e[5][5];
long long tmp[5][5];
long long r[5];
long long temp[5];

void init()
{
    mtx[1][1]=1;mtx[1][3]=1;
    mtx[2][1]=0;mtx[2][3]=1;
    mtx[3][1]=0;mtx[3][2]=1;
    mtx[3][3]=0;mtx[3][4]=0;
    mtx[4][1]=0;mtx[4][3]=0;
    mtx[2][2]=mtx[1][2]=4*c*c % mod;
    mtx[2][4]=mtx[1][4]=(mod-4*c % mod) % mod;
    mtx[4][4]=mod-1;mtx[4][2]=2*c % mod;
    return ;
}
void matrix_mul()
{
    for (int i=1;i<=4;i++)
        for (int j=1;j<=4;j++)
            tmp[i][j]=mtx[i][j];
    for (int i=1;i<=4;i++)
        for (int j=1;j<=4;j++)
        {
            mtx[i][j]=0;
            for (int k=1;k<=4;k++)
            {
                mtx[i][j]=(mtx[i][j]+tmp[i][k]*tmp[k][j]) % mod;

            }
        }
    return ;
}

int main()
{

    int t;
    scanf("%d",&t);
    while (t--)
    {
        scanf("%lld%lld%lld",&c,&n,&mod);
        init();

        r[1]=(c*c+1) % mod;r[2]=c*c % mod;
        r[3]=1;r[4]=c % mod;
        if (n==1)
        {
            printf("%lld\n",1 % mod);
            continue;
        }
        if (n==2)
        {
            printf("%lld\n",r[1] % mod);
            continue;
        }
        n-=2;
        while (n)
        {
            if (n&1)
            {
                for (int i=1;i<=4;i++)
                    temp[i]=r[i];
                for (int i=1;i<=4;i++)
                {
                    r[i]=0;
                    for (int j=1;j<=4;j++)
                    {
                        r[i]=(r[i]+temp[j]*mtx[i][j]) % mod;
                    }
                }
            }
            matrix_mul();
            n>>=1;
        }
        printf("%lld\n",r[1] % mod);
    }
    return 0;
}

wangs 2012-08-08 09:41 发表评论

SGU_449 数论_最大公因数

wangs — Wed, 01 Aug 2012 12:22:00 GMT

http://acm.sgu.ru/problem.php?contest=0&problem=499

给定N（<10W）个数，在100W以内，求每两个数最大共因数中最大的。
直接枚举N^2超时，想到都在100W内，则可以以借助筛法来做。从上往下筛，最坏情况下是对于N*ln N

#define maxn 100010
#define maxm 1000100

using namespace std;
int times[maxm];

int main()
{
    int n;
    scanf("%d",&n);
    clr(times);
    for (int i=0;i<n;i++)
    {
        int x;
        scanf("%d",&x);
        times[x]++;
    }
    int i=1000000;
    while (i>1)
    {
        if (times[i]>1)
            break;

        int j=i+i;
        int cnt=times[i];
        while (j<=1000000 && cnt<2)
        {
            cnt+=times[j]; //这里刚刚开始用的是times[i]+=times[j];这样不对，因为像 8这样的情况，会错的！
            j+=i;
        }
        if (cnt>1)
            break;
        i--;
    }
    printf("%d\n",i);
    return 0;
}

wangs 2012-08-01 20:22 发表评论

SGU_497 Coins

wangs — Wed, 01 Aug 2012 12:16:00 GMT

http://acm.sgu.ru/problem.php?contest=0&problem=498

概率题目，还不知道怎么做！

wangs 2012-08-01 20:16 发表评论

SPOJ_A Famous Game_概率分析

wangs — Tue, 31 Jul 2012 12:47:00 GMT

http://www.spoj.pl/problems/PRLGAME2/

很有意思的概率题目，具体怎么证明不明白，再多学学数学去吧。

另外发现了SPOJ这个优秀的OJ，多刷刷题了！

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <iostream>
#include <sstream>
#include <fstream>
#include <map>
#include <set>
#include <vector>
#include <queue>
#include <algorithm>
#define min(x,y) (x
#define max(x,y) (x>y?x:y)
#define swap(t,x,y) (t=x,x=y,y=t)
#define distance(x1,x2,y1,y2,z1,z2) (sqrt(pow(x2-x1,2)+pow(y2-y1,2)+pow(z2-z1,2)))
#define myabs(x) (x<0?-x:x)
#define sgn(x) (x<0?-1:(x>0?1:0))
#define clr(list) memset(list,0,sizeof(list))

using namespace std;

int main()
{
    int n,p,q;
    int t=0;
    while (scanf("%d%d%d",&n,&p,&q)==3)
    {
        printf("Case %d: %.4lf\n",++t,(double)(q+1)/(double)(p+2));
    }
    return 0;
}

wangs 2012-07-31 20:47 发表评论

卡特兰树-Catalan数

wangs — Thu, 26 Jul 2012 05:19:00 GMT

Catalan数的应用：
http://www.cppblog.com/abilitytao/archive/2010/04/12/112371.html

卡特兰数真是一个神奇的数字，很多组合问题的数量都和它有关系，例如：

一.Cn= 长度为 2n的 Dyck words的数量。 Dyck words是由 n个 X和 n个 Y组成的字符串，并且从左往右数， Y的数量不超过 X，例如长度为 6的 Dyck words为：

XXXYYY XYXXYY XYXYXY XXYYXY XXYXYY

二.Cn= n对括号正确匹配组成的字符串数，例如 3对括号能够组成：

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

三.Cn= n+1个数相乘，所有的括号方案数。例如， 4个数相乘的括号方案为：

((ab)c)d (a(bc))d (ab)(cd) a((bc)d) a(b(cd))

\四.Cn= 拥有 n+1 个叶子节点的二叉树的数量。例如 4个叶子节点的所有二叉树形态：

五.Cn=n*n的方格地图中，从一个角到另外一个角，不跨越对角线的路径数，例如， 4×4方格地图中的路径有：

六.Cn= n+2条边的多边形，能被分割成三角形的方案数，例如 6边型的分割方案有：

七.Cn= 圆桌周围有 2n个人，他们两两握手，但没有交叉的方案数。

在《Enumerative Combinatorics》一书中，竟然提到了多达 66种组合问题和卡特兰数有关。

算法分析中Catalan数的应用研究

一、catalan计数序列及其递推公式
（一）catalan数
catalan数即序列c0,c1,c2,…,cn,…。其中cn= (n=0,1,2,…)。前几个catalan数为c0=1,c1=1,c2=2,c3=5,c4=14,c5=42,c6=132,c7=429,c8=1430,c9=4862。
（二）递推公式
公式1：cn=c0cn-1+c1cn-2+…+cn-1c0= (1)
此公式为catalan数最常见递推公式。由公式可得出cn= (n=0,1,2,…),其证明过程主要是求此非线性递推公式的生成函数, 具体证明可参见参考文献中的组合数学。
公式2：cn= cn-1 (n≥1) c0=1,c1=1 (2)
此公式也为catalan数常见递推公式之一。由公式也可得出cn= (n=0,1,2,…),其证明过程较为简单。只要不断地递归到c0=1即可。
定理1：n个+1和n个-1构成的2n项a1,a2,…,a2n,其部分和满足a1+a2+…+ak≥0 (k=1,2,…,2n)的数列个数等于第n个catalan数，即cn= 。
证明：此定理的可以直接利用排列组合来证明，具体的证明可参见参考文献中的组合数学。这里给出另一种证明方式。
设满足部分和非负的数列个数为cn，此数列中的每一个都可看成是由i个+1和i个-1以及n-i个+1和n-i个-1这样两个数列构成。由i个+1和i个-1构成的数列个数为ci, 由n-i个+1和n-i个-1构成的数列个数为cn-i，由乘法和加法原理可知cn= 且c0=1即满足公式1,所以cn= 。

wangs 2012-07-26 13:19 发表评论

2008 Hangzhou 网络赛-D hdu2421 （数论）

wangs — Thu, 19 Jul 2012 07:09:00 GMT

摘要: Problem Description：Xiaoming has just come up with a new way for encryption, by calculating the key from a publicly viewable number in the following way:Let the public key N = AB, where 1 <= A, B ... 阅读全文

wangs 2012-07-19 15:09 发表评论

SRM 150 DIV 2 500pt（thinking && 数论）

wangs — Sun, 15 Jul 2012 13:54:00 GMT

Problem Statement

The digits 3 and 9 share an interesting property. If you take any multiple of 3 and sum its digits, you get another multiple of 3. For example, 118*3 = 354 and 3+5+4 = 12, which is a multiple of 3. Similarly, if you take any multiple of 9 and sum its digits, you get another multiple of 9. For example, 75*9 = 675 and 6+7+5 = 18, which is a multiple of 9. Call any digit for which this property holds interesting, except for 0 and 1, for which the property holds trivially.

A digit that is interesting in one base is not necessarily interesting in another base. For example, 3 is interesting in base 10 but uninteresting in base 5. Given an int base, your task is to return all the interesting digits for that base in increasing order. To determine whether a particular digit is interesting or not, you need not consider all multiples of the digit. You can be certain that, if the property holds for all multiples of the digit with fewer than four digits, then it also holds for multiples with more digits. For example, in base 10, you would not need to consider any multiples greater than 999.

Definition

Class:	InterestingDigits
Method:	digits
Parameters:	int
Returns:	vector
Method signature:	vector digits(int base)
(be sure your method is public)

Notes

When base is greater than 10, digits may have a numeric value greater than 9. Because integers are displayed in base 10 by default, do not be alarmed when such digits appear on your screen as more than one decimal digit. For example, one of the interesting digits in base 16 is 15.

Constraints

base is between 3 and 30, inclusive.

Examples

Returns: { 3,  9 }

All other candidate digits fail for base=10. For example, 2 and 5 both fail on 100, for which 1+0+0=1. Similarly, 4 and 8 both fail on 216, for which 2+1+6=9, and 6 and 7 both fail for 126, for which 1+2+6=9.

Returns: { 2 }

Returns: { 2,  4,  8 }

Returns: { 5,  25 }

Returns: { 29 }

This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2003, TopCoder, Inc. All rights reserved.

题意给定base进制数里，找出里面所有的特别的数x,对于x的倍数kx，它的每一位的和还是x的倍数。
比如base=10，则x=3和9。

这个应该是小学时候就记得的结论了，专门算3和9的，哈哈。

结论：base %x==1是充要条件。
证明：
               a=a1*base^0+a2*base^1+a3*base^2,对于任何a都可以这样分解
      因为 base % x=1，则base^k %x==1。则上式化简为
               a==a1+a2+a3+.. (mod x)
         反之，也可得base %x==1

440PT啊，小小犹豫了下哦。直接枚举了x验证啊。

其实就是求base-1的因子，如果base很大地话，是不能这样去枚举的。因子分解哦，又是经典问题啊。

#include<stdio.h>
#include<string.h>
#include<vector>
#include<algorithm>
using namespace std;

class InterestingDigits{
public:
    vector <int> digits(int base){
        int a[31];
        int n=0;
        int i=2;
        while (i<base){
            if (base % i==1)
                a[n++]=i;
            i++;
        }
        vector <int> ans(n);
        for (i=0;i<n;i++)
            ans[i]=a[i];
        return ans;
    }
};

wangs 2012-07-15 21:54 发表评论

fzu_1759(大数模除)

wangs — Thu, 12 Jul 2012 04:36:00 GMT

http://acm.fzu.edu.cn/problem.php?pid=1759

Given A,B,C, You should quickly calculate the result of A^B mod C. (1<=A,C<=1000000000,1<=B<=10^1000000).

思路一：
        十进制做法，把B分解，一步一步求A^B mod C,这样最多是1000W。TLE。测试数据组肯定很多》=10

思路二：
      求A^x=1 mod C，直接求x=phi(C)就行。然后求A^B=A^(B mod C) mod (C)。
         尼玛，我是傻逼啊，居然用x=C-1(C是质数)x=C(C是合数)！！！！！！！！！简单的数论啊，这个就给跪了！！

诡异的地方了我一直TLE啊，后的都优化了嘛，100W啊，怎么还是TLE啊？WA我都能接受，然后就去x=phi(C)啊。我擦擦擦！！！！

取x=phi(C);啊啊啊啊

#include<stdio.h>
#include<string.h>
#include<math.h>
#define maxn 1000000
char B[maxn+5];
long long phi(long long  n)
{
    long long ans=1,i;
    for(i=2;i*i<=n;i++)
    {
        if(n%i==0)
        {
            n/=i;
            ans*=i-1;
            while(n%i==0)
            {
                n/=i;
                ans*=i;
            }
        }
    }
    if(n>1)
    ans*=n-1;
    return ans;
}
long long strmod(long long t)
{
    int i,len;
    long long r=0;
    len=strlen(B);
    for (i=0;i<len;i++)
    {
        r=(r*10+B[i]-'0') % t;
    }
    return r;
}
long long power(long long a,long long b,long long c)
{
    long long r;
    r=1;a=a%c;
    while (b)
    {
        if (b&1)
            r=(r*a) % c;
        a=(a*a)%c;
        b>>=1;
    }
    return r % c;
}
int main()
{
    long long A,b,C;
    while (scanf("%I64d%s%I64d",&A,&B,&C)==3)
    {
        long long t;
        A=A%C;
        t=phi(C);
        b=strmod(t);
        printf("%I64d\n",power(A,b,C));
    }
    return 0;
}

尼玛，我真心是傻逼啊！！！

wangs 2012-07-12 12:36 发表评论

poj 3922(2008 Beijing 组合博弈构造数列)

wangs — Tue, 12 Jun 2012 03:36:00 GMT

http://poj.org/problem?id=3922

这个题解比较详细：

http://hi.baidu.com/huicpc0207/item/f11a06f36ecfe91484d278fd

disscus里说有比O(n)还低的DP方法，之前我也构造出来了，不过是不正确的。比O(n)低的DP方法？？？

问了问院长老师，希望她能给个比较好的算法哦哦哦

归纳、构造数列：根据k=1,k=2找到思路，找出必败态即可。
总结：
         1、多研究思考些有难度的数学问题，自己找到办法。
         2、复杂问题总是有简单办法的。
         3、难题代码实现一般很容易！

#include<stdio.h>
#include<string.h>
#include<math.h>
int a[1000005],r[1000005];
int solve(int n,int k)
{
    int i,j,ans;
    a[0]=0;r[0]=0;
    for (i=1,j=0;i<=1000000;i++)
    {
        a[i]=r[i-1]+1;
        while (j+1<i && a[j+1]*k <a[i])
            j++;
        r[i]=a[i]+r[j];
        if (r[i]>=n)
            break;
    }
    if (a[i]==n)
        return 0;
    while (i>=1)
    {
        if (n==a[i])
            return a[i];
        else
            if (n>a[i])
                n-=a[i];
        i--;
    }
    return ans;
}
int main()
{
    int t,cas=0,n,k,ans;
    scanf("%d",&t);
    while (t--)
    {
        scanf("%d%d",&n,&k);
        ans=solve(n,k);
        printf("Case %d: ",++cas);
        if (!ans)
            printf("lose\n");
        else
            printf("%d\n",ans);
    }
    return 0;
}

wangs 2012-06-12 11:36 发表评论

ural 1133 (fibonacci数列)

wangs — Mon, 07 May 2012 08:47:00 GMT

http://acm.timus.ru/problem.aspx?space=1&num=1133

题目大意：给定i Fi,j,Fj,n.求Fn。
满足：Fi+2=Fi+1+Fi;

应该说是水题一个哇：
Fi+k = gk * Fi + gk-1 * Fi-1。其中g是1 1 开头的fibonacci数。

C/C++的long long double都过不了。pascal的extended过了。怎么回事呢？？

Pascal代码：

Var
        i,j,k,p,n,tmp:longint;
        F:array[-1001..1001] of extended;
        g:array[0..2002] of extended;
        temp,ti,tj:extended;

begin
        readln(i,ti,j,tj,n);
        F[i]:=ti;F[j]:=tj;
        if (i>j) then
        begin
                tmp:=i;i:=j;j:=tmp;
                F[i]:=tj;F[j]:=ti;
        end;
        k:=j-i;
        g[0]:=1;g[1]:=1;
        for p:=2 to k do
                g[p]:=g[p-1]+g[p-2];

        F[i-1]:=trunc((F[j]-F[i]*g[k])/g[k-1]);

        if n>i then
        begin
                k:=i+1;
                while k<=n do
                begin
                        F[k]:=F[k-1]+F[k-2];
                        inc(k);
                end;
        end;
        if n1 then
        begin
                k:=i-2;
                while k>=n do
                begin
                        F[k]:=F[k+2]-F[k+1];
                        dec(k);
                end;
        end;
        writeln(F[n]:0:0);
        readln;
end.

昨天真是被这个题目虐惨了啊！！！！！！
尼玛，我们真是弱爆了！

wangs 2012-05-07 16:47 发表评论

poj2034----质数判断+bfs

wangs — Fri, 04 May 2012 09:00:00 GMT

http://poj.org/problem?id=2034

题目大意：
给定0 使得连续的大于2小于等于d的长度的数字之和是合数。

#include<stdio.h>
#include<string.h>
#include<math.h>
int p[500005];
int ans,a[1005],b[1005],sum[10005];
int m,n,d;

int GetPri()
{
    int i,j;
    memset(p,0,sizeof(p));
    p[1]=1;
    i=2;
    while (i<=500000)
    {
        while (p[i])    i++;
        j=i+i;
        while (j<=500000)
        {
            p[j]=1;
            j+=i;
        }
        i++;
    }
}

int dfs(int dep)
{
    int i,k,flag;
    if (ans)
        return 0;
    if (dep==n-m+2)
    {
        ans=1;
        for (i=1;i<n-m+1 ;i++ )
            printf("%d,",a[i]);
        printf("%d\n",a[i]);
        return 0;
    }
    for (i=m;i<=n ;i++ )
    {
        if (!b[i])
        {
            flag=1;
            for (k=2;k<=d ;k++ )
            {
                if (k<=dep&&!p[sum[dep-1]-sum[dep-k]+i])
                    flag=0;
                if (!flag||k>dep)
                    break;
            }
            if (!flag)
                continue;

            a[dep]=i;
            sum[dep]=sum[dep-1]+i;
            b[i]=1;
            dfs(dep+1);
            b[i]=0;
        }
    }
}

int main()
{
    GetPri();
    while (scanf("%d%d%d",&m,&n,&d)==3)
    {
        if (!m&&!n&&!d)
            break;
        ans=0;
        memset(sum,0,sizeof(sum));
        memset(b,0,sizeof(b));
        dfs(1);
        if (!ans)
            printf("No anti-prime sequence exists.\n");
    }
    return 0;
}

水过一题。dfs还是很好写的哈

wangs 2012-05-04 17:00 发表评论

因数分解-模板-poj1365

wangs — Fri, 04 May 2012 08:04:00 GMT

http://poj.org/problem?id=1365

傻×，这个题看了很久都没有看懂是什么意思。英语不行呀，到底应该怎么办呢？
题意，就是给一些a1 b1,a2 b2，……，ak bk
n=a1^b1*a2^b2*……*ak^bk.
然后需要对n-1因数分解。

赤裸裸的整数因子分解，数据也弱爆了！
不过数据读入还是个问题，字符读入的换行符ascii是10！
sscanf()和scanf()不同的呀。

#include<stdio.h>
#include<string.h>
#include<math.h>
int pri[5500];
int p[100005],tot;
int GetPrime()
{
    int i,j;
    memset(p,0,sizeof(p));
    tot=0;i=2;
    while (i<=50000)
    {
        while (p[i])    i++;
        pri[++tot]=i;
        j=i;
        while (j<=50000)
        {
            p[j]=1;
            j+=i;
        }
    }
    tot--;
    return 0;
}
int Pow(int a,int b)
{
    int n;
    n=1;
    while (b)
    {
        if (b%2==1)
            n=n*a;
        a=a*a;
        b=b/2;
    }
    return n;
}
int Solve(int n)
{
    int i,j;
    i=tot;
    while (n>1&&i>=1)
    {
        j=0;
        while (n%pri[i]==0)
        {
            j++;
            n/=pri[i];
        }
        if (j>0)
            printf("%d %d ",pri[i],j);
        i--;
    }
    if (n>1)
        printf("%d %d",n,1);
    printf("\n");
}
int main()
{
    int n,a,b;
    char ch;
    GetPrime();
    while (scanf("%d",&a)==1&&a>0)
    {
        scanf("%d",&b);
        n=Pow(a,b);
        while (scanf("%c",&ch)==1&&ch!=10)
        {
            scanf("%d %d",&a,&b);
            n=n*Pow(a,b);
        }
        Solve(n-1);
    }

    return 0;
}

wangs 2012-05-04 16:04 发表评论

中国剩余定理

wangs — Mon, 30 Apr 2012 08:34:00 GMT

设m1,m2,...,mk是两两互素的正整数，对于任意的正整数a1,a2,a3,..,ak 同余方程组：
 x≡a1 （mod m1）
 x≡a2 （mod m2）
 ...
 x≡ak （mod mk)
 必有解， 且解可写为
 x≡M1N1a1+MkNkak+....MkNkak  (mod m)
 其中 m=m1m2m3....mk
 Mi=m/mi,(1<=i<=k)
 Nj满足MjNj≡1(mod mj),1<=j<=k
即：
      Ni,Mi是对模mi的互为逆元。
http://www.cnblogs.com/walker01/archive/2010/01/23/1654880.html
     这篇写得不错哇。
      
中国剩余定理O(nlogn),还算高效率的。

#include<stdio.h>
#include<string.h>
#include<math.h>
int a[25],m[25],M[25],N[25];
int gcd_ext(int a,int b,int *x,int *y)
{
    int d,tmp;
    if (b==0)
    {
        *x=1;*y=0;
        return a;
    }
    d=gcd_ext(b,a%b,x,y);
    tmp=*x;*x=*y;*y=tmp-(a/b)**y;
    return d;
}
long long ChReTheorim(int n)
{
    int i,x,y;
    long long ans,mul;
    mul=1;
    for (i=1;i<=n ;i++ )
        mul*=m[i];
    ans=0;
    for (i=1;i<=n ;i++ )
    {
        M[i]=mul/m[i];
        gcd_ext(M[i],m[i],&x,&y);
        N[i]=(x+m[i])%m[i];
        ans=(ans+a[i]*M[i]*N[i]) % mul;
    }
    return ans;
}

int main()
{
    int i,n;
    long long ans;
    while (scanf("%d",&n)==1)
    {
        mul=1;
        for (i=1;i<=n ;i++ )
            scanf("%d%d",&a[i],&m[i]);
        ans=ChReTheorim(n);
        printf("%lld\n",ans);
    }
    return 0;
}

尼玛，看算法上的乘法逆元给看成加法逆元了。我还以为我找到O（n）的算法呢。气死：
   a=a1(mod n1)
   a=a2(mod n2)
则
   a=(a1*n2*N2+a2*n1*N1) % (n1*n2)
其中
   N1是n1模n2的逆元，N2是n2模n1的逆元。
如此反复迭代，可求解。

long long TongYu(int a1,int n1,int a2,int n2)
{
    int N1,N2,x,y,ans;
    gcd_ext(n1,n2,&x,&y);
    N1=(n2+x) % n2;
    gcd_ext(n2,n1,&x,&y);
    N2=(n1+x) % n1;
    printf("%d %d\n",N1,N2);
    ans=(a1*n2*N2+a2*n1*N1) % (n1*n2);
    return ans;
}

哦，

wangs 2012-04-30 16:34 发表评论

poj_1006(同余方程组求解)

wangs — Mon, 30 Apr 2012 05:35:00 GMT

http://poj.org/problem?id=1006

题目大意：
         给定三个数，a,b,c.求满足
         x=a (mod 23)
         x=b (mod 28)
         x=c (mod 33)
的大于d的最小x。 //这里理解很重要！！！！
同于方程组问题，我暴力了一下。

#include
#include
#include

int main()
{
    int a,b,c,d,i,t;
    t=0;
    while (scanf("%d%d%d%d",&a,&b,&c,&d)==4&&a>=0)
    {
        a%=23;b%=28;c%=33;
        i=c;
        while (1)
        {
            if (i%23==a&&i%28==b&&i%33==c)
                break;
            i+=33;
        }
        if (i<=d)
            i+=21252;
        printf("Case %d: the next triple peak occurs in %d days.\n",++t,i-d);
    }
    return 0;
}

同余方程组解法：

还不会哦。

wangs 2012-04-30 13:35 发表评论

ACM-数学知识练习

wangs — Mon, 30 Apr 2012 02:58:00 GMT

POJ【数论/组合/博弈论】题目列表
博弈论
POJ 2234 Matches Game
POJ 2975 Nim
POJ 2505 A multiplication game
POJ 1067 取石子游戏
POJ 2484 A Funny Game
POJ 2425 A Chess Game
POJ 2960 S-Nim
POJ 1704 Georgia and Bob
POJ 1740 A New Stone Game
POJ 2068 Nim
POJ 3480 John
POJ 2348 Euclid's Game
POJ 3710 Christmas Game
POJ 3533 Light Switching Game
POJ 3537 Crosses and Crosses

数论/组合

1.burnside定理，polya计数法
    这个大家可以看brudildi的《组合数学》，那本书的这一章写的很详细也很容易理解。最好能完全看懂了，理解了再去做题，不要只记个公式。
    *简单题：（直接用套公式就可以了）
    pku2409 Let it Bead
    pku2154 Color
    pku1286 Necklace of Beads
    *强烈推荐：（这题很不错哦，很巧妙）
    pku2888 Magic Bracelet
2.置换，置换的运算

    置换的概念还是比较好理解的，《组合数学》里面有讲。对于置换的幂运算大家可以参考一下潘震皓的那篇《置换群快速幂运算研究与探讨》，写的很好。
    *简单题：（应该理解概念就可以了）
    pku3270 Cow Sorting
    pku1026 Cipher
    *置换幂运算：
    pku1721 CARDS
    pku3128 Leonardo's Notebook
    *推荐：（不错的应用）
    pku3590 The shuffle Problem
3.素数，整数分解，欧拉函数

    素数是可能数论里最永恒，最经典的问题了（我们的队名就叫PrimeMusic^-^）。素数的判断，筛法求素数，大素数的判断···还有很多其他问题都会用到素数。
    *最水最水的：（心情不爽时用来解闷吧）
    pku1365 Prime Land0+0

    pku2034 Anti-prime Sequences
    pku2739 Sum of Consecutive Prime Numbers
    pku3518 Prime Gap
    pku3126 Prime Path
    pku1595 Prime Cuts
    pku3641 Pseudoprime numbers
    pku2191 Mersenne Composite Numbers
    pku1730 Perfect Pth Powers
    pku2262 Goldbach's Conjecture
    pku2909 Goldbach's Conjecture
    *筛法：
    pku2689 Prime Distance（很好的一个应用）
    *反素数：
    zoj2562 More Divisors
    *素数判断，整数分解：
    这两题都要用到miller_rabin的素数判断和pollard_rho的整数分解，算法书上都会有，应该是属于模板题吧，不过最好看懂自己敲一遍。
    pku1811 Prime Test
    pku2429 GCD & LCM Inverse

    *欧拉函数：
    数论里很多地方都能用到欧拉函数，很重要的。
    pku1284 Primitive Roots （关于原根的定理：p的原根为euler(euler(p))，本题中当p为奇素数时euler(p)=p-1，故答案为euler(p-1)）
    pku2407 Relatives （很水）
    pku2773 Happy 2006
    pku2478 Farey Sequence （快速求欧拉函数）
   pku3090 Visible Lattice Points （法雷级数）
    *推荐：（欧拉函数，费马小定理）
    pku3358 Period of an Infinite Binary Expansion
    *整数分解
    这个也很重要的耶，包括大数的表示方法。
    pku2992 Divisors
    pku3101 Astronomy （分数的最小公倍数）
4.扩展欧几里得，线性同余，中国剩余定理

    这应该是数论里比较重要的一个部分吧，这类的题目也挺多，具体的内容最好先看看数论书，我也整理过一些，可以参考参考：
    *简单题：
    pku1006 Biorhythms
    pku1061 青蛙的约会
    pku2891 Strange Way to Express Integers
    pku2115 C Looooops
    pku2142 The Balance
    *强烈推荐：
    sgu106 The equation
    pku3708 Recurrent Function （经典）
5.约瑟夫环问题

    这个问题还是比较有意思的，不是很难。
    *简单题：
    pku3517 And Then There Was One
    pku1781 In Danger
    pku1012 Joseph
    pku2244 Eeny Meeny Moo
    *推荐：
   pku2886 Who Gets the Most Candies?
6.高斯消元法解方程

    其实解方程并不是很难，就是按线性代数中学的那种方法，把系数矩阵化成上三角矩阵或数量矩阵，不过有些题目要判断是否有解，或枚举所有解。不过这类题目我认为比较难的还是怎么去建立这个方程组，这个理解了，就没什么大问题了。
    *简单题：
    pku1222 EXTENDED LIGHTS OUT
    pku1681 Painter's Problem
    pku1830 开关问题
    *推荐：
    pku2947 Widget Factory
    pku2065 SETI
    *强烈推荐：
    pku1753 Flip Game
    pku3185 The Water Bowls
    *变态题：
    pku1487 Single-Player Games

7.矩阵
    用矩阵来解决问题确实很常见，但我现在用到还不是很好，很多难题我还不会做。建议大家可以去看Matrix67的那篇关于矩阵的十个问题，确实很经典，但不太好看懂。
    *简单：
    pku3070 Fibonacci
    pku3233 Matrix Power Series
    pku3735 Training little cats
8.高次同余方程

    有关这个问题我应该是没什么发言权了，A^B%C=D，我现在只会求D和B，唉，很想知道A该怎么求。就先推荐几道题目吧，这里涉及到了一个baby-step，giant-step算法。
    pku3243 Clever Y
    pku2417 Discrete Logging
9.容斥原理，鸽巢原理

    很有用的两个定理，但好像单独考这两个定理的不是很多。
    *鸽巢原理：
    pku2356 Find a multiple
    pku3370 Halloween treats
    *容斥原理：
    hdu1695 GCD
    hdu2461 Rectangles
10.找规律，推公式

    这类题目的设计一般都非常巧妙，真的是很难想出来，但只要找到规律或推出公式，就不是很难了。我很多都是在参考别人思路的情况下做的，能自己想出来真的很不容易。
    *个人感觉都挺不错的：
    pku3372 Candy Distribution
    pku3244 Difference between Triplets
    pku1809 Regetni
    pku1831 不定方程组
    pku1737 Connected Graph
    pku2480 Longge's problem
    pku1792 Hexagonal Routes
11.排列组合，区间计数，计数序列

    这些题目可能需要一些组合数学知识，基本上高中的知识就够了。区间计数问题一般不难，但写的时候需要仔细一些，各种情况要考虑到位。至于像卡特兰数，差分序列，斯特灵数···都还挺有意思，可以去看看《组合数学》。
    *简单题：
    pku1850 Code
    pku1150 The Last Non-zero Digit
    pku1715 Hexadecimal Numbers
    pku2282 The Counting Problem
    pku3286 How many 0's?
    *推荐：
    pku3252 Round Numbers
    *计数序列：
    pku1430 Binary Stirling Numbers
    pku2515 Birthday Cake
    pku1707 Sum of powers
12.二分法

    二分的思想还是很重要的，这里就简单推荐几个纯粹的二分题。
    *简单：
    pku3273 Monthly Expense
    pku3258 River Hopscotch
    pku1905 Expanding Rods
    pku3122 Pie
    *推荐：
    pku1845 Sumdiv
13.稳定婚姻问题

    无意中接触到这个算法，还蛮有意思的，《组合数学》中有详细的介绍。
    pku3487 The Stable Marriage Problem
    zoj1576 Marriage is Stable
14.数位类统计问题

    在航点月赛中第一次接触到这类问题，scau大牛little龙推荐我看了一篇论文，09年刘聪的《浅谈数位类统计问题》，这篇论文相当精彩，也相当详细，每道题都有详细的分析和作者的参考代码。所以我也没什么可说的了，这些题的代码我博客里也就不贴了，大家直接去看论文吧。
    简单：
    ural1057 Amount of degrees
    spoj1182 Sorted bit squence
    hdu3271 SNIBB
    较难：
    spoj2319 Sequence
    sgu390 Tickets

wangs 2012-04-30 10:58 发表评论

ACdream 1159(组合-递推-优化)

wangs — Sun, 29 Apr 2012 09:15:00 GMT

1159: One Theorem, One Year

Time Limit: 1 Sec Memory Limit: 128 MB
Submit: 21 Solved: 12
[Submit][Status][Web Board]

Description

A number is Almost-K-Prime if it has exactly K prime numbers (not necessarily distinct) in its prime factorization. For example, 12 = 2 * 2 * 3 is an Almost-3-Prime and 32 = 2 * 2 * 2 * 2 * 2 is an Almost-5-Prime number. A number X is called Almost-K-First-P-Prime if it satisfies the following criterions:

1. X is an Almost-K-Prime and

2. X has all and only the first P (P ≤ K) primes in its prime factorization.

For example, if K=3 and P=2, the numbers 18 = 2 * 3 * 3 and 12 = 2 * 2 * 3 satisfy the above criterions. And 630 = 2 * 3 * 3 * 5 * 7 is an example of Almost-5-First-4-Pime.

For a given K and P, your task is to calculate the summation of Φ(X) for all integers X such that X is an Almost-K-First-P-Prime.

Input

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

Each case starts with a line containing two integers K (1 ≤ K ≤ 500) and P (1 ≤ P ≤ K).

Output

For each case, print the case number and the result modulo

1000000007

Sample Input

3 3 2 5 4 99 45

Sample Output

Case 1: 10 Case 2: 816 Case 3: 49939643

求出素数后然后，然后然后就是排列组合的问题了。
dp[i][j]表示在前i个素数里选j个数相乘的和
dp[i][j]= dp[i-1][j-k]*exp[i][k] 0<=k<=j求和
这里边算边模
a[i][j]表示在前i个素数里j个数组成结果，则
a[i][j]=mul[i]*dp[i][j-1]
这里也边算模。

#include
#include
#include
int pri[550],b[3705]; //这里之前是3500要错哦
long long dp[505][505],a[505][505];
long long mod=1000000007;
int GetPri()
{
    int i,j,tot;
    memset(b,0,sizeof(b));
    i=2;
    tot=0;    //写了那么素数筛法了，居然会在这里载！！！！
    while (i<=3700)
    {
        while (b[i])    i++;
        pri[++tot]=i;
        j=i;
        while (j<=3700)
        {
            b[j]=1;
            j+=i;
        }
    }
    return 0;
}

int Cal()
{
    int i,j;
    long long sum,mul;
    dp[0][0]=1;
    for (i=1; i<=500 ; i++ )
    {
        dp[i][0]=1;
        sum=0;
        for (j=1; j<=500 ; j++ )
        {
            sum=(sum*pri[i]+dp[i-1][j-1]*pri[i]) % mod;   //哎，方程的优化，还是没有经验啊！！这里之前我是写了个三重的循环呢。可以迭代的啊。
            dp[i][j]=(dp[i-1][j]+sum) % mod;
        }
    }
    mul=1;
    for (i=1; i<=500 ; i++ )
    {
        mul=mul*(pri[i]-1) % mod;    //方程优化！！！
        for (j=i; j<=500 ; j++ )
            a[i][j]=mul*dp[i][j-i] % mod;
    }
}

int main()
{
    int p,cas,n,m;
    GetPri();
    Cal();
    scanf("%d",&p);
    cas=0;
    while (p--)
    {
        scanf("%d%d",&n,&m);
        printf("Case %d: %lld\n",++cas,a[m][n]);
    }
    return 0;
}

总结：方程的优化，降低维数！！！！！！！！！！！！！！！！！！！！
真的是弱爆了啊。。。。。。。。

wangs 2012-04-29 17:15 发表评论

poj1284(欧拉函数原根）

wangs — Sat, 28 Apr 2012 08:26:00 GMT

原根Primitive Root

　　设m是正整数，a是整数，若a模m的阶等于φ(m)，则称a为模m的一个原根。（其中φ(m)表示m的欧拉函数）

　　假设一个数g对于P来说是原根，那么g^i mod P的结果两两不同,且有 1

(mod P)当且当指数为P-1的时候成立.(这里P是素数).

　　简单来说，g^i mod p ≠ g^j mod p （p为素数）

　　其中i≠j且i, j介於1至(p-1)之间

　　则g为p的原根。

【算法】定理1：如果p有原根，则它恰有φ(φ(p))个不同的原根（无论p是否为素数都适用）     {x^i%p | 1 <= i <= p - 1} = {1,2,...,p-1} 等价于
      {x^i%(p-1) | 1 <= i <= p - 1} = {0,1,2,...,p-2},    即为(p-1)的完全剩余系若x,x2...x(p-1)是(p-1)的完全剩余系,根据定理,可以推出若
       gcd(x, p-1) = 1时, (1,x,...,x(p-2))也是(p-1)的完全剩余系    因为若x^i != x^j (mod p-1),那么x*x^i != x*x^j (mod p-1),    与条件m矛盾,
      所以 x^i = x^j (mod p-1),    由此可以确定答案为Euler(p-1)

p的原根为euler(euler(p))，筛法求出欧拉函数。

#include
#include
#include
int p[70007];
int GetEula()
{
    int i,j;
    for (i=1;i<=70000 ;i++ )
        p[i]=i;
    i=2;
    while (i<70000)
    {
        while (p[i];
        j=i;
        while (j<=70000)
        {
            p[j]=p[j]*(i-1)/i;
            j+=i;
        }
    }
}
int main()
{
    int n;
    GetEula();
    while (scanf("%d",&n)==1)
        printf("%d\n",p[n-1]);
    return 0;
}

wangs 2012-04-28 16:26 发表评论

poj2478(欧拉函数)--模板

wangs — Fri, 27 Apr 2012 10:14:00 GMT

首先是昨天一直wa的fzu 1769代码:

有运行68ms的，膜拜膜拜，不知道怎么写的，得去学学那个算法。

#include
#include
#include
long long p[3000005];
int GetEula()
{
    int i,j;
    for (i=1;i<=3000000 ;i++ )
        p[i]=i;
    p[1]=0;
    i=2;
    while (i<3000000)
    {
        while (p[i];
        j=i;
        while (j<=3000000)
        {
            p[j]=p[j]*(i-1)/i;
            j+=i;
        }
    }
}
int main()
{
    int i,a,b;
    long long s;
    GetEula();
    while (scanf("%d%d",&a,&b)==2)
    {
        s=0;
        while (a<=b)
            s+=p[a++];
        printf("%I64d\n",s);
    }
    return 0;
}

呵呵，用筛法来请欧拉函数还是我一下子冒出来的想法，嗯，这个直觉不错。
不过一直WA一直WA,原来是数据类型的问题。
poj2478也是这个问题，哎哎，以后要多注意数据类型这个东西了！！！

#include
#include
#include
long long p[3000005];
int GetEula()
{
    int i,j;
    for (i=1;i<=3000000 ;i++ )
        p[i]=i;
    p[1]=0;
    i=2;
    while (i<3000000)
    {
        while (p[i];
        j=i;
        while (j<=3000000)
        {
            p[j]=p[j]*(i-1)/i;
            j+=i;
        }
    }
}
int main()
{
    int i,n;
    long long s;
    GetEula();
    while (scanf("%d",&n)==1&&n)
    {
        s=0;
        while (n)
            s+=p[n--];
        printf("%I64d\n",s);
    }
    return 0;
}

数论刷水题ing……

wangs 2012-04-27 18:14 发表评论

poj 2689（筛法求素数的应用）

wangs — Sun, 22 Apr 2012 12:41:00 GMT

http://poj.org/problem?id=2689

筛法筛去区间内的合数。
开哥说是水题一个！不过，我WA了一天。二分查找的错！！！

141MS AC

#include<stdio.h>
#include<string.h>
#include<math.h>
#define inf 500000
unsigned prime[50005],b[5000005],a[500005],tot;
unsigned L,U;
int b_search(int l,int r,int x)
{
    int mid;
    while (l<=r)
    {
        mid=(l+r)/2;
        if (prime[mid]==x)
            return mid;
        else
            if (prime[mid]<x)
                l=mid+1;
            else
                r=mid-1;
    }
    return l;
}
int Getprime()
{
    int i,j;
    memset(b,0,sizeof(b));
    tot=0;
    i=2;
    while (i<inf)
    {
        while (b[i])    i++;
        prime[++tot]=i;
        j=i;
        while (j<=inf)
        {
            b[j]=1;
            j+=i;
        }
    }
    tot--;
}
int main()
{
    unsigned int i,j,k,total;
    unsigned int max,min,maxi,mini;
    Getprime();

    while (scanf("%d%d",&L,&U)==2)
    {
        memset(b,0,sizeof(b));
        k=b_search(1,tot,(int)sqrt(U*1.0)+1.0);

        i=1;
        while (i<=k+1)     //这里改为k+1就AC了！！！呜呜呜啎
        {
            j=L%prime[i];
            if (j>0)
                j=prime[i]-j;
            while (j<=U-L)
            {
                if (j+L!=prime[i])
                    b[j]=1;
                j+=prime[i];
            }
            i++;
        }

        total=0;
        for (i=0;i<=U-L ;i++ )
            if (!b[i]&&L+i>=2)
                a[++total]=L+i;

        if (total<2)
            printf("There are no adjacent primes.\n");
        else
        {
            max=min=a[2]-a[1];maxi=1;mini=1;
            for (i=3;i<=total ;i++ )
            {
                if (a[i]-a[i-1]>max)
                {
                    max=a[i]-a[i-1];
                    maxi=i-1;
                }
                if (a[i]-a[i-1]<min)
                {
                    min=a[i]-a[i-1];
                    mini=i-1;
                }
            }
            printf("%d,%d are closest, %d,%d are most distant.\n",a[mini],a[mini+1],a[maxi],a[maxi+1]);
        }
    }
    return 0;
}

wangs 2012-04-22 20:41 发表评论

欧拉函数（资料+模板）

wangs — Sat, 21 Apr 2012 09:28:00 GMT

http://zh.wikipedia.org/wiki/%E6%AC%A7%E6%8B%89%E5%87%BD%E6%95%B0
欧拉函数：
欧拉函数是数论中很重要的一个函数，欧拉函数是指：对于一个正整数 n ，小于 n 且和 n 互质的正整数（包括 1）的个数，记作 φ(n) 。

完全余数集合：
定义小于 n 且和 n 互质的数构成的集合为 Zn ，称呼这个集合为 n 的完全余数集合。显然 |Zn| ＝φ(n) 。

有关性质：
对于素数 p ，φ(p) = p -1 。
对于两个不同素数 p， q ，它们的乘积 n = p * q 满足 φ(n) = (p -1) * (q -1) 。
这是因为 Zn = {1, 2, 3, ... , n - 1} - {p, 2p, ... , (q - 1) * p} - {q, 2q, ... , (p - 1) * q} ，则 φ(n) = (n - 1) - (q - 1) - (p - 1) = (p -1) * (q -1) ＝φ(p) * φ(q) 。

欧拉定理：
对于互质的正整数 a 和 n ，有 a^φ(n) ≡ 1 mod n 。
证明：
( 1 ) 令 Zn = {x₁, x₂, ..., x_φ(n)} ， S = {a * x₁ mod n, a * x₂ mod n, ... , a * x_φ(n) mod n} ，
        则 Zn = S 。
        ① 因为 a 与 n 互质， x_i (1 ≤ i ≤ φ(n)) 与 n 互质，所以 a * x_i 与 n 互质，所以 a * x_i mod n ∈ Zn 。
        ② 若 i ≠ j ，那么 x_i ≠ x_j，且由 a, n互质可得 a * x_i mod n ≠ a * x_j mod n （消去律）。

( 2 )     a^φ(n)* x₁* x₂ *... * x_φ(n) mod n
      ≡ (a * x₁) * (a * x₂) * ... * (a * x_φ(n)) mod n
      ≡ (a * x₁ mod n) * (a * x₂mod n) * ... * (a * x_φ(n) mod n) mod n
      ≡ x₁* x₂* ... * x_φ(n)mod n
      对比等式的左右两端，因为 x_i (1 ≤ i ≤ φ(n)) 与 n 互质，所以 a^φ(n) ≡ 1 mod n （消去律）。
注：
消去律：如果 gcd(c,p) = 1 ，则 ac ≡ bc mod p ⇒ a ≡ b mod p 。

费马定理：
若正整数 a 与素数 p 互质，则有 a^{p - 1} ≡ 1 mod p 。

这个是欧拉定理的特殊情况，p是素数，则p的欧拉函数就是p-1.

补充：欧拉函数公式

( 1 ) p^k 的欧拉函数

对于给定的一个素数 p ， φ(p) = p -1。则对于正整数 n = p^k ，

 φ(n) = p^k - p^{k -1}
  
证明：
 小于 p^k 的正整数个数为 p^k - 1个，其中
 和 p^k 不互质的正整数有{p * 1,p * 2,...,p * (p^{k - 1}-1)} 共计 p^{k - 1} - 1 个
 所以 φ(n) = p^k - 1 - (p^{k - 1} - 1) = p^k - p^{k - 1} 。

( 2 ) p * q 的欧拉函数

假设 p, q是两个互质的正整数，则 p * q 的欧拉函数为

φ(p * q) = φ(p) * φ(q) ， gcd(p, q) = 1 。

证明：
 令 n = p * q ， gcd(p,q) = 1
 根据中国余数定理，有
 Zn 和 Zp × Zq 之间存在一一映射
（我的想法是： a ∈ Zp ， b ∈ Zq ⇔ b * p + a * q ∈ Zn 。）
 所以 n 的完全余数集合的元素个数等于集合 Zp × Zq 的元素个数。
 而后者的元素个数为 φ(p) * φ(q) ，所以有
 φ(p * q) = φ(p) * φ(q) 。

( 3 ) 任意正整数的欧拉函数

任意一个整数 n 都可以表示为其素因子的乘积为：

      I
 n = ∏  p_i^k_i (I 为 n 的素因子的个数)
     i=1

根据前面两个结论，很容易得出它的欧拉函数为：


         I                      I
 Φ(n) = ∏  p_i^k_i-1(p_i-1) = n ∏ (1 - 1 / pi)
        i=1                    i=1

对于任意 n > 2，2 | Φ(n) ,因为必存在 p_i-1 是偶数。

转自：http://blog.csdn.net/hillgong/article/details/4214327

以下程序在http://acm.hrbeu.edu.cn/index.php?act=problem&id=1001&cid=25测试通过：

Compile E rror 一次 WA两次 AC：3Ms
总结：代码要写得快，熟练。一定要注意注意越界溢出啊啊啊啊！！！

#include<stdio.h>
#include<string.h>
#include<math.h>
#define inf 50000
int prime[10005],b[51005],tot;
int get_prime()
{
    int i,j;
    memset(b,0,sizeof(b));
    tot=0;
    i=2;
    while (i<inf)
    {
        while (b[i])    i++;
        prime[++tot]=i;
        j=i;
        while (j<inf)
        {
            b[j]=1;
            j+=i;
        }
    }
    tot--;
}

int main()
{
    int i,j,k,p,n,m;
    long long ans;    //这里之前溢出 wa 2次！
    get_prime();
    while (scanf("%d",&n)==1&&n)
    {
        ans=m=n;
        i=1;
        while (i<=tot)
        {
            if (n%prime[i]==0)
            {
                ans=ans*(prime[i]-1)/prime[i];
                while (n%prime[i]==0)
                    n=n/prime[i];
            }
            i++;
        }
        if (n>prime[tot])
            ans=ans*(n-1)/n;
        printf("%lld\n",ans);
    }
    return 0;
}

做了好几天数论了，好不容易AC一个题目！！啊啊啊啊

wangs 2012-04-21 17:28 发表评论