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

poj 1006 Biorhythms 中国剩余定理

yx — Wed, 03 Oct 2012 15:11:00 GMT

此题本来模拟即可，但是注意有容易出错的地方。
这题主要是可以用中国剩余定理来做。
根据题意可以抽象出这样的模型。给出三个数A,B,C分别是模23,28,33后的余数，求最小的数字
使得其模23,28,33分别为A,B,C，并且要大于给定的数字D。
中国剩余定理很好的解决了这种余数问题。令模数为Ni,余数为Ai,设Mi = N1*N2*...*Ni-1*Ni+1*...*Nn，
那么答案一定满足形式ans = ΣAi*Mi*(Mi对Ni的乘法逆) % N。(N为所有Ni的乘积)。
很明显，由于ans的第i项有Mi因子，所以模N1-Ni-1和Ni+1-Nn肯定是0，而Ai*Mi*(Mi对Ni的乘法逆) %Ni
就是Ai。这样就满足了要求。
代码如下：

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

int Egcd(int nN, int nM, int& nX, int& nY)
{
    if (nM == 0)
    {
        nX = 1, nY = 0;
        return nN;
    }
    int nRet = Egcd(nM, nN % nM, nX, nY);
    int nT = nX;
    nX = nY;
    nY = nT - (nN / nM) * nY;
    return nRet;
}

int main()
{
    int nA, nB, nC, nD;
    int nDays = 21252;
    int nCase = 1;

    while (scanf("%d%d%d%d", &nA, &nB, &nC, &nD),
           nA != -1 || nB != -1 || nC != -1 || nD != -1)
    {
        int nFirst = 0;
        nA %= 23;
        nB %= 28;
        nC %= 33;
        int nM1= 28 * 33, nM2 = 23 * 33, nM3 = 23 * 28;
        int nN1, nN2, nN3, nTemp;
        Egcd(23, nM1, nTemp, nN1);
        Egcd(28, nM2, nTemp, nN2);
        Egcd(33, nM3, nTemp, nN3);
        nFirst = (nA * nM1 * nN1 + nB * nM2 * nN2 + nC * nM3 * nN3) % nDays;
        while (nFirst <= nD)nFirst += nDays;
        printf("Case %d: the next triple peak occurs in %d days.\n",
               nCase++, nFirst - nD);
    }

    return 0;
}

yx 2012-10-03 23:11 发表评论

poj 1811 Prime Test 数论素数测试

yx — Mon, 24 Sep 2012 04:56:00 GMT

代码如下：

#include

using namespace std;

typedef unsigned long long LL;

#define MAX (5000000)

bool bPrime[MAX];

void InitPrime()

{

int nMax = sqrt((double)MAX) + 1;

bPrime[0] = bPrime[1] = true;

for (int i = 2; i <= nMax; ++i)

{

if (!bPrime[i])

{

for (int j = 2 * i; j < MAX; j += i)

{

bPrime[j] = true;

}

LL multAndMod(LL a, LL b, LL n)

{

LL tmp = 0;

while (b)

{

if(b & 1)

{

tmp = (tmp + a) % n;

}

a = (a << 1) % n;

b >>= 1;

}

return tmp;

}

//计算a^u%n

LL ModExp(LL a, LL u, LL n)

{

LL d = 1;

a %= n;

while (u)

{

if (u & 1)

{

d = multAndMod(d, a, n);

}

a = multAndMod(a, a, n);

u >>= 1;

}

return d % n;

}

//判断nN是不是合数

bool Witness(LL a, LL nN)

{

LL u = nN - 1, t = 0;//将nN-1表示为u*2^t

while (u % 2 == 0)

{

t++;

u >>= 1;

}

LL x0 = ModExp(a, u, nN);//x是a^u

LL x1;

for (int i = 1; i <= t; ++i)

{

x1 = multAndMod(x0, x0, nN);

if (x1 == 1 && x0 != nN - 1 && x0 != 1)

{

return true;

}

x0 = x1;

}

if (x1 != 1)

{

return true;

}

return false;

}

//素数测试

bool MillerRabin(LL nN)

{

//if (nN < MAX)return !bPrime[nN];

const int TIME = 10;

for (int i = 0; i < TIME; ++i)

{

LL a = rand() % (nN - 1) + 1;

if (Witness(a, nN))

{

return false;

}

return true;

}

LL gcd(LL a, LL b)

{

if (a < b)swap(a, b);

while (b)

{

LL t = a;

a = b;

b = t % b;

}

return a;

}

//启发式寻找nN的因子

LL PollardRho(LL n, LL c)

{

LL i = 1, t = 2;

LL x, y;

LL ans;

srand(time(NULL));

y = x = rand() % n;

while(1)

{

i++;

x = (multAndMod(x, x, n) + c) % n;

ans = gcd(y - x, n);

if(ans > 1 && ans < n)

return ans;

if(x == y)

return n;

if(t == i)

{

y = x;

t <<= 1;

}

LL FindMin(LL nN, LL c)

{

//printf("nN:%I64u\n", nN);

if (MillerRabin(nN) || nN <= 1)

{

return nN;

}

LL p = nN;

while (p >= nN) p = PollardRho(p, c--);

if (p > 1)

p = FindMin(p, c);//分解p的最小因子

if (p < nN)

{

LL q = nN / p;

q = FindMin(q, c);//找到q的最小因子

p = min(p, q);

}

return p;

}

int main()

{

int nTest;

srand(time(NULL));

//InitPrime();

scanf("%d", &nTest);

while (nTest--)

{

LL nN;

scanf("%I64u", &nN);

if (nN > 2 && nN % 2 == 0)

{

printf("2\n");

}

else if (nN == 2 || MillerRabin(nN))

{

printf("Prime\n");

}

else

{

printf("%I64u\n", FindMin(nN, 181));

}

return 0;

}

yx 2012-09-24 12:56 发表评论

hdu 4294 Multiple 数论 + bfs

yx — Tue, 18 Sep 2012 05:27:00 GMT

这是前天成都网赛的题，比赛时候确实一点思路也没有。比完之后看了人家的解题报告，还是不会怎么搜出答案，太弱了。
题意是给出N,K，求M，使得M是N的正倍数，而且M用K进制表示后所需要的不同数字(0,1,2,3,...,k-1)最少，如果有多组
这样的情况，求出最小的M。
很数学的题意。用到了一个结论，就是任意数字的正倍数均可以用不超过2个不同数字的数得到。
证明如下：
任意数M % N 总共有N种结果，假如有N+1个不同的M，那么肯定有2个M对N取模后的结果是相同，这个是所谓鸽巢原理。
那么，我取a,aa,aaa,...,aaaaaaaaaa....，总共N+1个，同样满足上面的结论。那么我取那2个对N取模相同的数字相减得到
数字aaaaa...000....，这个数字肯定是N的倍数。
综合上面的证明，只能得到2个数字肯定能表示N的倍数。但是不能说形式就是aaaaa...000....。

到了这里我还是一点思路都没有，一点都不知道怎么搜索。。。
想了1个多小时，无头绪，问过了这题的同学，还是无头绪。看解题报告，他们的代码写得太牛了，完全看不懂，无头绪。
也许也是我对bfs理解太浅，才看不懂他们的搜索代码。而且，我连可以搜索的地方都没有找到，都不知道搜什么了。
想了好久，昨天吃饭的时候，终于发现可以对余数进行搜索。
对于任意的N，其余数就是范围是[0, N -1]。这个其实就可以代表状态了，或者代表bfs中的点了。从当前余数转移到其它
余数的是MOD * K + A 或者 MOD * K + B，如果要转移到得余数以前没被搜过，那就可以转移过去。这个刚好就是一个
优化了。也可以看成是子问题了。但是，dfs完全不行。刚开始用dfs，绝对的超时。
用dfs也是我对思路理解不深，侥幸认为能过。。。后面发现，这题完全和bfs吻合。[0, N -1]刚好代表N个点，我要通过
从外面的一个点，最短的遍历到点0，可以bfs或者最短路算法。这题我觉得还有个难点就是保存答案，因为答案最长的长度
可能是N(N<=10000)，所以把答案直接放到节点里面肯定不行的。但是，我还仔细看过算法导论。因此想到了可以利用bfs
搜索出来的那颗树或者最短路算法跑出来的那颗树，从目标节点逆序寻找答案，找到出发节点之后，再把答案reverse一下就行了。
这题还得注意0不能是N的倍数，所以注意bfs(0,i)这种情况的处理。

代码如下：

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

const int MAX_N = 10010;
int nOut[MAX_N];
int nOLen;
int nAns[MAX_N];
int nALen;
bool bMod[MAX_N];
int nFather[MAX_N];
int nChoose[MAX_N];
int nN;
int nK;
bool bFind;

int Cmp(int* A, int nLA, int* B, int nLB)
{
    if (nLA != nLB)
    {
        return nLA - nLB;
    }
    for (int i = 0; i < nLA; ++i)
    {
        if (A[i] != B[i])
        {
            return A[i] - B[i];
        }
    }
    return 0;
}

void Bfs(int nA, int nB)
{
    memset(bMod, false, sizeof(bMod));
    queue<int> que;
    que.push(0);
    int nTemp;
    bool bFirst = true;
    bFind = false;

    if (nA > nB)swap(nA, nB);
    //printf("nA:%d, nB:%d\n", nA, nB);
    while (!que.empty())
    {
        //printf("nMod:%d\n", que.front());
        int nMod = que.front();
        que.pop();
        if (nMod == 0)
        {
            if (bFirst)bFirst = false;
            else
            {
                bFind = true;
                break;
            }
        }

        nTemp = (nMod * nK + nA) % nN;
        if (!(nMod == 0 && nA == 0) && !bMod[nTemp])
        {
            nFather[nTemp] = nMod;
            nChoose[nTemp] = nA;
            que.push(nTemp);
            bMod[nTemp] = true;
            //printf("nTemp:%d\n", nTemp);
        }
        if (nA == nB)continue;
        nTemp = (nMod * nK + nB) % nN;
        if (!bMod[nTemp])
        {
            nFather[nTemp] = nMod;
            nChoose[nTemp] = nB;
            que.push(nTemp);
            bMod[nTemp] = true;
            //printf("nTemp:%d\n", nTemp);
        }
    }

    if (bFind)
    {
        int nF = 0;
        nALen = 0;
        do
        {
            nAns[nALen++] = nChoose[nF];
            nF = nFather[nF];
        } while (nF);
        reverse(nAns, nAns + nALen);
    }
}

int main()
{
    while (scanf("%d%d", &nN, &nK) == 2)
    {
        bool bOk = false;
        nOLen = 0;
        for (int i = 1; i < nK; ++i)
        {
            Bfs(i, i);
            if (bFind)
            {
                if (nOLen == 0 || Cmp(nOut, nOLen, nAns, nALen) > 0)
                {
                    nOLen = nALen;
                    memcpy(nOut, nAns, sizeof(int) * nALen);
                }
                bOk = true;
            }
        }
        if (!bOk)
            for (int i = 0; i < nK; ++i)
            {
                for (int j = i + 1; j < nK; ++j)
                {
                    Bfs(i, j);
                    if (bFind)
                    {
                        if (nOLen == 0 || Cmp(nOut, nOLen, nAns, nALen) > 0)
                        {
                            nOLen = nALen;
                            memcpy(nOut, nAns, sizeof(int) * nALen);
                        }
                    }
                }
            }
        for (int k = 0; k < nOLen; ++k)
        {
            printf("%d", nOut[k]);
        }
        printf("\n");
    }

    return 0;
}

yx 2012-09-18 13:27 发表评论

poj 3243 Clever Y

yx — Sun, 05 Aug 2012 07:09:00 GMT

这个是求扩展离散对数问题。X^Y mod Z = K，给出X，Z，K，求Y。
当Z是素数的时候直接用baby-step算法即可了。但是，模数不是素数的情况怎么办了。
方程a^X = b % c，可以进行一系列的转化。假设d = gcd(a,c)，由a^(x-1)*a = b % c，知道a^(x-1)要存在必须满足
gcd(a,c)|b，如果满足这个条件，那么我们可以在方程2边同时除以d，方程是不变的。因为a^x = b + k * c，再除以公约数
d，得到方程a^(x-1)*a/d = b / d + k * c / d。根据以上推论，我们可以不断的除以d，直到gcd(a,c)=1。
假设我们除了k次，那么方程转化为a^(x-k) * a^k/d^k = b / d^k + k * c / d^k。令d = a^k/d^k，b' = b / d^k，
c' = c / d^k，x' = x - k，方程转化为a^x' * d = b' % c'，得到a^x' = b' * d^-1 % c'。
现在直接用baby-step解方程a^x' = b' * (d^-1) % c'即可。注意到x=x'+k，如果存在x小于k的解，那么x'小于0，但是
由baby-step是不会求负的次数的，所以需要先枚举一下是否存在小于k的解，由于输入的数据不会超过10^9的，假设k不超过50
进行枚举即可了。

代码如下：

#include
#include
#include
using namespace std;
typedef long long INT;
#define MAX (1000000)
INT nData[MAX];
INT nKey[MAX];

INT HashPos(INT key)
{
    return ((unsigned)(key ^ 0xA5A5A5A5)) % MAX;
}

void HashAdd(INT key, INT data)
{
    INT nPos = HashPos(key);
    while (nData[nPos] != -1)
    {
        nPos = (nPos + 1) % MAX;
    }
    nData[nPos] = data;
    nKey[nPos] = key;
}

INT HashQuery(INT key)
{
    INT nPos = HashPos(key);
    while (nData[nPos] != -1)
    {
        if (nKey[nPos] == key)
        {
            return nData[nPos];
        }
        nPos = (nPos + 1) % MAX;
    }

    return -1;
}

INT MultMod(INT nA, INT nB, INT nC)
{
    INT nAns = 0;
    while (nB)
    {
        if (nB & 1)
        {
            nAns = (nAns + nA) % nC;
        }
        nA = (2 * nA) % nC;
        nB >>= 1;
    }
    return nAns;
}

INT PowerMod(INT nA, INT nX, INT nC)
{
    INT nAns = 1;
    nA %= nC;
    while (nX)
    {
        if (nX & 1)
        {
            nAns = MultMod(nAns, nA, nC);
        }
        nA = MultMod(nA, nA, nC);
        nX >>= 1;
    }
    return nAns;
}

INT gcd(INT nA, INT nB)
{
    if (nA < nB)swap(nA, nB);
    while (nB)
    {
        INT nT = nA;
        nA = nB;
        nB = nT % nB;
    }
    return nA;
}
//d = nA * nX + nB * nY(nA > nB, nA是模数)
INT egcd(INT nA, INT nB, INT& nX, INT& nY)
{
    if (nA < nB)swap(nA, nB);
    if (nB == 0)
    {
        nX = 1;
        nY = 0;
        return nA;
    }
    INT nRet = egcd(nB, nA % nB, nX, nY);
    INT nT = nX;
    nX = nY;
    nY = nT - (nA / nB) * nY;
    return nRet;
}

INT GetAns(INT nA, INT nB, INT nC)
{
    if (nC == 0)return -1;
    //先枚举0-50,扩展baby-step的过程可能会漏掉这些解
    INT nTemp = 1;
    nB %= nC;
    for (INT i = 0; i <= 50; ++i)
    {
        if (nTemp == nB)
        {
            return i;
        }
        nTemp = MultMod(nTemp, nA, nC);
    }

    //如果nC不是素数,那么方程nA^x = nB + k*nC
    //可以不到除以gcd(nC,nA)
    //如果gcd(nC,nA)|nB不成立,方程无解，
    //这个由a*x=b%c有解必须满足gcd(a,c)|b一样
    INT d;
    INT nD = 1;//nD最后是A^k次,k是nC中因子d的次数
    INT k = 0;
    while ((d = gcd(nC, nA)) != 1)
    {
        k++;
        nC /= d;
        if (nB % d)return -1;
        nB /= d;
        nD = MultMod(nD, nA / d, nC);
    }
    //现在方程转化为nA^(x-k) * nA^k/d^k = nB/d^k % nC/d^k
    //其实就是方程2侧除以d^k次而已,这样的做法与原方程是等价的
    //令nD = nA^k/d^k,则nA^x'*nD = nB' % nC',
    //解该方程,那么x=x'+k
    //注意,如果x
    memset(nKey, -1, sizeof(nKey));
    memset(nData, -1, sizeof(nData));
    INT nM = ceil(sqrt(1.0 * nC));
    nTemp = 1;
    for (INT j = 0; j <= nM; ++j)
    {
        HashAdd(nTemp, j);
        nTemp = MultMod(nTemp, nA, nC);
    }
    INT nK = PowerMod(nA, nM, nC);
    for (int i = 0; i <= nM; ++i)
    {
        INT x, y;
        egcd(nC, nD, x, y);//y = nD^-1,nD = nD*(nA^m)^i
        y = (y + nC) % nC;//这句话是必须的,y很可能就是负数
        INT nR = MultMod(y, nB, nC);//nR=nB*nD^-1
        int j = HashQuery(nR);
        if (j != -1)
        {
            return nM * i + j + k;
        }

        nD = MultMod(nD, nK, nC);
    }
    return -1;
}

int main()
{
    INT nA, nB, nC;

    while (scanf("%I64d%I64d%I64d", &nA, &nC, &nB), nA + nB + nC)
    {
        INT nAns = GetAns(nA, nB, nC);
        if (nAns == -1)
        {
            printf("No Solution\n");
        }
        else
        {
            printf("%I64d\n", nAns);
        }
    }

    return 0;
}

yx 2012-08-05 15:09 发表评论

poj 3696 The Luckiest number

yx — Thu, 02 Aug 2012 05:06:00 GMT

这个题很奇葩了。题意是给出个数字L，假如存在一个数K使得L*K = 888...，求888...的最小长度，如果不存在这样的K，那么输出0。
我是什么思路也没有了，拖了几天了，数论搞死我了，只能找答案了。
我看到个比较靠谱的推法。首先，888...=111...*8=(10^0+10^1+...+10^m-1)*8=(10^m - 1)/9*8，PS：m代表888...的长度。
好吧，终于化成指数了，现在有8*(10^m-1)/9=K*L，最小的m就是我们要求的答案啦。

方式1：
   => 8 * (10^m-1) = 9 * k * L
   => 8/d*(10^m-1)=9*k*L/d，d=gcd(8,9L)
=> 10^m-1 = 0 % 9 * L / gcd(8, 9L) = 0 % 9*L/gcd(8,L)，(由于gcd(8/d,9L/d)=1，那么10^m-1必然是9*L/d的倍数了)。
   => 10^m = 1 % 9 * L / gcd(8,L)
方式2：
   => 8*(10^m-1)/9 = 0 % L
   => 8*(10^m-1) = 0 % 9*L(这步的推出，比如x/9 = k*n，那么x=9*k*n了，显然成立)
   => 10^m-1 = 0 % 9*L/gcd(9*L,8)，假如，d = gcd(9*L,8)，那么有8/d*(10^m-1)=k*9*L/d，因为8/d不可能是9 *L / d
的倍数，所以10^m-1必定是9*L/d的倍数，所以10^m-1 = 0 % 9*L/gcd(9*L,8))，=>，10^m - 1 = 0 % 9 * L / gcd(L, 8),
(因为gcd(9,8)=1)。
   => 10^m = 1 % 9*L/gcd(8,L)

至此，2种方式都推出了，10^m = 1 % 9*L/gcd(8,L) 。
   那么怎么解答这个问题了，这个就用到了欧拉定理了。令p = 9 * L / gcd(8,L)，那么有10^m = 1 % p。由欧拉定理知,Z*p中所有的
数字a均满足a^euler(p) = 1 % p。那么，10只要是p的乘法群中就肯定有解了。如果，10不在Z*p中了，肯定是无解的。证明如下：
由a^x = 1%p，可以得到a^(x-1)*a=1%p，要a^(x-1)存在，那么gcd(a,p)|1，那么gcd(a,p)必须是1。
综上所述，要满足式子a^m=1%p，必须gcd(p,a)=1，即a必须是p的乘法群中的数字。
现在的问题是求最小的m，由欧拉定理知道a^euler(p)=1%p，m再大就开始循环了。但是m可能会更小。比如，我们现在知道最小的m
是min，那么有a^min=1%p，因为要满足a^euler(p)=1%p，那么a^euler(p)肯定能变换成(a^min)^k,至于k是多少就不知道了，当然
也可以求出来。那么min就是euler(p)的一个因子，而且是最小的一个满足a^min=1%p的因子了。
现在就可以通过枚举euler(p)的因子，找到最小的因子min满足式子a^min = 1 % p就能解决本问题了。
   注意求a^m%p肯定是通过算法导论上面那种方法的,O(32)或者O(64)的复杂度，还有a*b%m也需要自己模拟，因为可能a*b就溢出了。
代码如下，貌似代码还可以通过其它的改进加快速度。

#include
#include
#include
#include <string.h>
using namespace std;
typedef long long INT;

//10^m = 1 % (9*L / gcd(8, L)),求最小m
//p = 9 * L / gcd(8,L)
//gcd(p,10) != 1则p有2或者5的因子,2^m=1%p或者
//5^m=1%p无解,原式无解
//if(p)素数,m=euler(p) = p - 1
//否则,m一定是euler(p)的最小满足等式的因子
//因为(10^m)^n = 10^euler(p) = 1%p
INT gcd(INT a, INT b)
{
    if (a < b)swap(a, b);
    while (b)
    {
        INT t = a;
        a = b;
        b = t % b;
    }
    return a;
}

INT Euler(INT nN)
{
    INT nAns = 1;
    INT nMax = sqrt((double)nN) + 1;
    for (INT i = 2; i <= nMax; ++i)
    {
        if (nN % i == 0)
        {
            nAns *= i - 1;
            nN /= i;
            while (nN % i == 0)
            {
                nAns *= i;
                nN /= i;
            }
        }
    }
    if (nN != 1)nAns *= nN - 1;
    return nAns;
}

INT MultMod(INT a, INT b, INT mod)
{
    INT ans = 0;
    while (b)
    {
        if (b & 1)
        {
            ans = (ans + a) % mod;
        }
        a = (2 * a) % mod;
        b >>= 1;
    }
    return ans;
}

INT ExpMod(INT base, INT exp, INT mod)
{
    INT ans = 1;
    base %= mod;
    while (exp)
    {
        if (exp & 1)
        {
            ans = MultMod(ans, base, mod);
        }
        base = MultMod(base, base, mod);
        exp >>= 1;
    }
    return ans % mod;
}

INT GetAns(INT p)
{
    INT u = Euler(p);
    INT nMax = sqrt((double)u) + 1;
    INT nAns = u;
    for (INT i = 1; i <= nMax; ++i)
    {
        if (u % i == 0)
        {
            if (ExpMod(10, i, p) == 1)
            {
                nAns = i;
                break;
            }
            if (ExpMod(10, u / i, p) == 1)
            {
                nAns = min(nAns, u / i);
            }
        }
    }
    return nAns;
}

int main()
{
    INT nL;
    INT nCase = 1;

    while (scanf("%I64d", &nL), nL)
    {
        INT p = 9 * nL / gcd(nL, 8);
        if (gcd(p, 10) != 1)
        {
            printf("Case %I64d: 0\n", nCase++);
            continue;
        }
        printf("Case %I64d: %I64d\n", nCase++, GetAns(p));
    }

    return 0;
}

yx 2012-08-02 13:06 发表评论

poj 2480 Longge's problem

yx — Tue, 31 Jul 2012 03:47:00 GMT

题意就是给出个数n，求Σgcd(i,n)(1<=i<=n)。感觉好奇葩的题目，数论的题确实比较难想，没看出跟欧拉函数有什么关系。
很纠结，没心情没时间继续想了。看了discussion，然后又去搜了下答案，发现有个哥们也得非常不错，就看了下思路了。
这个题的解法是枚举i(1<=i<=n)，如果i|n，那么答案加上euler(n/i)*i。其实ans = Σi*euler(n/i)(i<=i<=n而且i|n)。
意思是从1到n的所有数字i，如果i是n的因子，那么计算i*euler(n/i)，加入答案中，euler是欧拉函数的意思。
为什么是这样的了。比如，1到n中有m个数字和n拥有公共的最大因子i，那么就需要把m*i加入答案中。问题是如何计算m的个数。
因为gcd(m,n) = i，可以得到gcd(m/i,n/i)=1，那么m/i就是n/i的乘法群中的数字了，那么一共存在euler(n/i)个m/i了，那么就
可以推出m的个数就是euler(n/i)。

代码如下:

#include
#include
#define MAX (6000000)
bool bPrime[MAX];

void InitPrime()
{
    int nMax = sqrt((double)MAX) + 1;
    bPrime[0] = bPrime[1] = true;
    for (int i = 2; i <= nMax; ++i)
    {
        if (!bPrime[i])
        {
            for (int j = 2 * i; j < MAX; j += i)
            {
                bPrime[j] = true;
            }
        }
    }
}

bool IsPrime(long long nN)
{
    if (nN < MAX)return !bPrime[nN];
    long long nMax = sqrt((double)nN) + 1;
    for (int i = 2; i <= nMax; ++i)
    {
        if (nN % i == 0)
        return false;
    }
    return true;
}

long long Euler(long long nN)
{
    long long nAns = 1;

    //printf("nN:%I64d,", nN);
    if (IsPrime(nN))nAns = nN - 1;
    else
    for (int i = 2; i <= nN; ++i)
    {
        if (nN % i == 0)
        {
            nAns *= i - 1;
            nN /= i;
            while (nN % i == 0)
            {
                nAns *= i;
                nN /= i;
            }
            if (IsPrime(nN))
            {
                nAns *= nN - 1;
                break;
            }
        }
    }

    //printf("nAns:%I64d\n", nAns);
    return nAns;
}

int main()
{
    long long nN;

    InitPrime();
    while (scanf("%I64d", &nN) == 1)
    {
        long long nAns = 0;
        long long nMax = sqrt((double)nN) + 1e-8;
        for (long long i = 1; i <= nMax; ++i)
        {
            if (nN % i == 0)
            {
                //printf("i:%I64d\n", i);
                nAns += i * Euler(nN / i);
                if (i * i != nN)
                nAns += (nN / i) * Euler(i);
            }
        }
        printf("%I64d\n", nAns);
    }

    return 0;
}

yx 2012-07-31 11:47 发表评论

poj 1284 Primitive Roots

yx — Mon, 30 Jul 2012 14:36:00 GMT

这个题是求原根的个数。所谓原根，意思是给定一个数n，存在数g，g^j能够产生乘法群Zn*中所有的数字。即g^j = {x|x与n互质,
1<=x 这个题目要求求原根的个数。由费马定理由,对任意1<=x再往下计算就开始循环了。那么有,x^i%p(1<=i 根据上面的那个式子可以得到，x^i%(p-1)(1<=i使得x^i*x = (p-1)%p。
因此可以得到，原根的个数是p-1的乘法群中元素的个数，也就是欧拉函数(p-1)。

代码如下：

#include

#define MAX (5000000)

bool bPrime[MAX];

void InitPrime()

{

int nMax = sqrt((double)MAX) + 1;

bPrime[0] = bPrime[1] = true;

for (int i = 2; i <= nMax; ++i)

{

if (!bPrime[i])

{

for (int j = 2 * i; j < MAX; j += i)

{

bPrime[j] = true;

}

bool IsPrime(int nN)

{

if (nN < MAX)return !bPrime[nN];

int nMax = sqrt((double)nN) + 1;

for (int i = 2; i <= nMax; ++i)

{

if (nN % i == 0)

return false;

}

return true;

}

int main()

{

int nN;

InitPrime();

while (scanf("%d", &nN) == 1)

{

nN--;

int nAns = 1;

if (IsPrime(nN))

{

nAns = nN - 1;

}

else

{

for (int i = 2; i <= nN; ++i)

{

if (nN % i == 0)

{

nAns *= i - 1;

nN /= i;

while (nN % i == 0)

{

nAns *= i;

nN /= i;

}

if (IsPrime(nN))

{

nAns *= nN - 1;

break;

}

printf("%d\n", nAns);

}

return 0;

}

yx 2012-07-30 22:36 发表评论

poj 2417 Discrete Logging

yx — Sun, 29 Jul 2012 11:38:00 GMT

这是个求离散对数的问题。以前学密码学基础的时候也接触过，但是没想到acm里面还会有这样的习题。
问题的意思是给定素数P，给出方程a^x = b % p，注意有模的方程等式2边都是取模数的意思。解这样的方程有一个固定的算法，
叫做baby-step算法。但是，注意限定条件是p必须是素数。
下面的图描述了这个算法：

意思很清楚，就是假设x = i * m + j，那么方程可以转化为b*(a^-m)^i = a^j % p。先计算出右边的值，存储在一张表里面，
然后从小到大枚举左边的i（0<=i poj上面这个题用map存储(a^j,j)对的时候会超时，改成hash表存储才能过，额，毕竟理论复杂度不是一个数量级的。我的hash表是
开了2个数组，一个键，一个值，用来相互验证，槽冲突的话，一直往后找位置。感觉这样的做法没有链式hash复杂度平均的样子。
代码如下：

#include
#include
#include
using namespace std;

#define MAX (1000000)
long long nData[MAX];
long long nKey[MAX];
long long egcd(long long a, long long b, long long& x, long long& y)
{
    if (b == 0)
    {
        x = 1;
        y = 0;
        return a;
    }
    long long ret = egcd(b, a % b, x, y);
    long long t = x;
    x = y;
    y = t - (a / b) * y;
    return ret;
}

long long GetPos(long long key)
{
     return (key ^ 0xA5A5A5A5) % MAX;
}

void Add(long long key, long long data)
{
    long long nPos = GetPos(key);
    while (nData[nPos] != -1)
    {
        nPos = (nPos + 1) % MAX;
    }
    nData[nPos] = data;
    nKey[nPos] = key;
}

int Query(int key)
{
    int nPos = GetPos(key);

    while (nData[nPos] != -1)
    {
        if (nKey[nPos] == key)
        {
            return nData[nPos];
        }
        nPos = (nPos + 1) % MAX;
    }
    return -1;
}

long long BabyStep(long long nA, long long nB, long long nP)
{
    long long nM = ceil(sqrt((double)(nP - 1)));
    long long x, y;
    egcd(nP, nA, x, y);//y是nA%p的乘法逆
    y = (y + nP) % nP;
    long long nTemp = 1;
    long long c = 1;//c是nA的—m次
    memset(nData, -1, sizeof(nData));
    memset(nKey, -1, sizeof(nKey));
    for (long long j = 0; j < nM; ++j)
    {
        Add(nTemp, j);
        nTemp = (nTemp * nA) % nP;
        c = (c * y) % nP;
    }

    long long r = nB;
    for (int i = 0; i < nM; ++i)
    {
        long long j = Query(r);
        if (j != -1)
        {
            return i * nM + j;
        }
        r = (r * c) % nP;
    }
    return -1;
}

int main()
{
    long long nP, nB, nN;

    while (scanf("%I64d%I64d%I64d", &nP, &nB, &nN) == 3)
    {
        long long nAns = BabyStep(nB, nN, nP);
        if (nAns == -1)printf("no solution\n");
        else printf("%I64d\n", nAns);
    }

    return 0;
}

yx 2012-07-29 19:38 发表评论

uva 408 - Uniform Generator

yx — Sat, 28 Jul 2012 14:12:00 GMT

这是今天想通的一个数论题，还是挺有意思的，想出来的那一瞬间yeah了一下，可是我悲剧的粗心习惯，还是交了3次才过，nm数中间空
格都错了，又忘记打空行，明明字符串从25列开始，中间是4个空格的，我nc的打了5个空格，就pe了，还有不仔细看输出要求，没有输出空
行，最近真没状态啊。
其实，这个题想通了就很简单了，还是数论里面的群的概念，就是加法群的生成群啊，打着随机数的幌子而已。由于又没有限定种子，限定
对答案也没有影响，假设种子是0，那么数列可以表示为a*step，数列要能够生成0 - mod-1中所有的数字，那么就有a*step = b % mod
(0<=b 哈哈，上面那个式子就是a*x=b%n这个线性同余方程了，只是有很多b了。要方程有解，不是需要满足条件gcd(a,n)|b么，意思b是
gcd(a,n)的整数倍了。但是0<=b 关于线性同余方程a*x=b%n，要有解的条件gcd(a,n)|b的解释，还是参看算法导论或者其它资料吧。。。

代码就非常简单了，如下：

#include
#include
using namespace std;

int gcd(int a, int b)
{
    if (a < b)swap(a, b);
    while (b)
    {
        int t = a;
        a = b;
        b = t % b;
    }
    return a;
}

int main()
{
    int nStep, nMod;

    while (scanf("%d%d", &nStep, &nMod) == 2)
    {
        printf("%10d%10d    %s\n\n", nStep, nMod,
               gcd(nStep, nMod) == 1 ? "Good Choice" : "Bad Choice");
    }

    return 0;
}

yx 2012-07-28 22:12 发表评论

poj 2115 C Looooops

yx — Fri, 27 Jul 2012 09:08:00 GMT

这个题目就是解线性同余方程，(a + n*c) % 2的k次 = b % 2的k次。既然以前是学信安的，对数论本来就不排斥，最近还好好看了下算
法导论。这个方程转换为n*c = (b-a) % 2的k次。根据数论的知识， ax = b%n，需要保证gcd(a,n)|b，意思b是gcd(a,n)的倍数，这个
一下子也很难解释清楚啊，不满足这个条件，就是没解了。还有，如果有解的话，解的个数就是d = gcd(a,n)。而且其中一个解是x0 = x'(b
/ d)，其中x'是用扩展欧几里德算法求出来的，满足关系式a*x'+n*y'=d。
但是这个题不仅仅用到数论的这些知识，因为必须求满足条件的最小解，而如果有解的话是d个，而且满足解x = x0 + i(b/d)，
（1<=i<=d)。既然要求最小的解，那么对解mod(n/d)即可了，因为它们之间的差都是n/d的倍数。

代码如下：

#include

#include
#include
using namespace std;

//扩展欧几里德算法
//d = a * x + b * y，d是a和b的最大公约数
long long egcd(long long a, long long b, long long& x, long long& y)
{
    if (b == 0)
    {
        x = 1;
        y = 0;
        return a;
    }
    else
    {
        long long nRet = egcd(b, a % b, x, y);
        long long t = x;
        x = y;
        y = t - (a / b) * y;
        return nRet;
    }
}

int main()
{
    long long nA, nB, nC, nK;

    while (scanf("%I64d%I64d%I64d%I64d", &nA, &nB, &nC, &nK),
            nA || nB || nC || nK)
    {
        long long x, y;
        long long n = pow((double)2, (double)nK) + 1e-8;
        long long d = egcd(n, nC, x, y);
        long long b = (nB - nA + n) % n;
        if (b % d)//如果d | b失败
        {
            printf("FOREVER\n");
        }
        else
        {
            //printf("y:%I64d, b:%I64d, d:%I64d n:%I64d\n", y, b, d, n);
            y = (y + n) % n;
            long long ans = (y * (b / d)) % (n / d);
            printf("%I64d\n", ans);
        }
    }

    return 0;
}

yx 2012-07-27 17:08 发表评论

poj 2407 Relatives

yx — Thu, 26 Jul 2012 13:36:00 GMT

这个题一看就知道是求欧拉函数。欧拉函数描述的正式题意。欧拉函数的理解可以按照算法导论上面的说法，对0-N-1进行筛选素数。
那么公式n∏(1-1/p)，其中p是n的素数因子，就可以得到直观的理解了。但是计算的时候，会将这个式子变形下，得到另外一个形式。
如图所示：

但是这个题，需要考虑下，有可能n是个大素数，直接进行因子分解的话会超时的。怎么办了，只能在分解的时候判断n是不是已经成为
素数了，如果是素数，答案再乘以n-1就行了。为了加快判断，我用5mb的空间搞了个素数表，大于5000000的数字只能循环判断了。

代码如下，注意求欧拉函数的代码部分：

#include
#include
#define MAX (5000000)
bool bPrime[MAX];//false表示素数

void InitPrime()
{
    bPrime[0] = bPrime[1] = true;
    int nMax = sqrt((double)MAX) + 1;
    for (int i = 2; i <= nMax; ++i)
    {
        if (!bPrime[i])
        for (int j = i * 2; j < MAX; j += i)
        {
            bPrime[j] = true;
        }
    }
}

bool IsPrime(int nN)
{
    if (nN < MAX)
    {
        return !bPrime[nN];
    }
    else
    {
        int nMax = sqrt((double)nN) + 1;
        for (int i = 2; i <= nMax; ++i)
        {
            if (nN % i == 0)
            {
                return false;
            }
        }
        return true;
    }
}

int main()
{
    int nN;

    InitPrime();
    while (scanf("%d", &nN), nN)
    {
        if (nN == 1){printf("0\n");continue;}
        int nAns = 1;
        for (int i = 2; i <= nN; ++i)
        {
            if (IsPrime(nN))
            {
                nAns *= nN - 1;
                break;
            }
            if (nN % i == 0)
            {
                nAns *= i - 1;
                nN /= i;
                while (nN % i == 0)
                {
                    nAns *= i;
                    nN /= i;
                }
            }
        }
        printf("%d\n", nAns);
    }

    return 0;
}

yx 2012-07-26 21:36 发表评论

poj 2551 Ones and poj 2262 Goldbach's Conjecture

yx — Wed, 25 Jul 2012 14:35:00 GMT

第一个题用到了同余的性质，这是数论里面最基本的性质，但是做题时候不一定能够自己发现。题意是n*m = 11111...，给出n，
用一个m乘以n得到的答案全是1组成的数字，问1最小的个数是多少。可以转换为n*m=(k*10+1)，那么可以得到(k*10+1)%n==0。
当然最开始的k是1，那么我们不断的增长k = （10*k+1）。看增长多少次，就是有多少个1了。因为要避免溢出，所以需要不断%n。
因为同余的性质，所以可以保证%n之后答案不变。
第二个用到素数筛选法。素数筛选法的原理是筛去素数的倍数，由于是从小循环到大的，所以当前的值没被筛掉的话，则一定是素数，
这个判断导致复杂度不是n的平方。

poj 2551 代码：

#include

int main()
{
    int nN;

    while (scanf("%d", &nN) == 1)
    {
        int nCnt = 1;
        int nTemp = 1;
        while (1)
        {
            if (nTemp % nN == 0)break;
            else nTemp = (nTemp * 10 + 1) % nN;
            ++nCnt;
        }
        printf("%d\n", nCnt);
    }

    return 0;
}

poj 2262 代码：

#include
#include <string.h>
#include

#define MAX (1000000 + 10)
bool bPrime[MAX];
void InitPrime()
{
    memset(bPrime, true, sizeof(bPrime));
    bPrime[0] = bPrime[1] = false;
    for (int i = 2; i <= MAX; ++i)
    {
        if (bPrime[i])
        for (int j = 2 * i; j <= MAX; j += i)
        {
            bPrime[j] = false;
        }
    }
}

int main()
{
    int nN;

    InitPrime();
    while (scanf("%d", &nN), nN)
    {
        int i;
        for (i = 2; i < nN; ++i)
        {
            if (i % 2 && (nN - i) % 2 && bPrime[i] && bPrime[nN - i])
            {
                printf("%d = %d + %d\n", nN, i, nN - i);
                break;
            }
        }
        if (i == nN)
        {
            printf("Goldbach's conjecture is wrong.\n");
        }
    }

    return 0;
}

yx 2012-07-25 22:35 发表评论

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

poj 1006 Biorhythms 中国剩余定理

poj 1811 Prime Test 数论 素数测试

hdu 4294 Multiple 数论 + bfs

poj 3243 Clever Y

poj 3696 The Luckiest number

poj 2480 Longge's problem

poj 1284 Primitive Roots

poj 2417 Discrete Logging

uva 408 - Uniform Generator

poj 2115 C Looooops

poj 2407 Relatives

poj 2551 Ones and poj 2262 Goldbach's Conjecture

poj 1811 Prime Test 数论素数测试