久久国产成人,久久久久亚洲AV无码专区体验,99久久超碰中文字幕伊人

poj 1006 Biorhythms 中国剩余定理

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

此题本来模拟卛_��Q�但是注意有�Ҏ��出错的地斏V�?br /> �q�题主要是可以用中国剩余定理来做�?br /> �Ҏ��题意可以抽象��L��模型。给��Z��个数A,B,C分别是模23,28,33后的余数�Q�求最��的数字
使得其模23,28,33分别为A,B,C�Q��ƈ且要大于�l�定的数字D�?br /> 中国剩余定理很好的解决了�q�种余数问题。��o模数为Ni,余数为Ai,设Mi = N1*N2*...*Ni-1*Ni+1*...*Nn�Q?br />那么�{�案一定满��_Ş式ans = ΣAi*Mi*(Mi对Ni的乘法�? % N�?N为所有Ni的乘�U?�?br /> 很明显，�׃��ans的第i��Ҏ��Mi因子�Q�所以模N1-Ni-1和Ni+1-Nn肯定�?�Q�而Ai*Mi*(Mi对Ni的乘法�? %Ni
��是Ai。这样就满��了要求�?br /> 代码如下�Q?br />

#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

代码如下�Q?div style="background-color: #eeeeee; border: 1px solid #cccccc; padding: 4px 5px 4px 4px; width: 98%; word-break: break-all; ">

#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是不是合�?/div>

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的因�?/div>

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的最��因�?/div>

if (p < nN)

{

LL q = nN / p;

q = FindMin(q, c);//扑ֈ�q的最��因�?/div>

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

�q�是前天成都�|�赛的题�Q�比赛时候确实一�Ҏ��\也没有。比完之后看了�h家的解题报告�Q�还是不会怎么搜出�{�案�Q�太�׃��?br /> 题意是给出N,K�Q�求M�Q��得M是N的正倍数�Q�而且M用K�q�制表示后所需要的不同数字(0,1,2,3,...,k-1)最��，如果有多�l?br />�q�样的情况，求出最��的M�?br /> 很数学的题意。用��C��一个结论，��是��L��数字的正倍数均可以用不超�q?个不同数字的数得到�?br /> 证明如下�Q?br /> ��L��数M % N ��d��有N�U�结果，假如有N+1个不同的M�Q�那么肯定有2个M对N取模后的�l�果是相同，�q�个是所谓鸽巢原理�?br />那么�Q�我取a,aa,aaa,...,aaaaaaaaaa....�Q��d��N+1个，同样满��上面的结论。那么我取那2个对N取模相同的数字相减得�?br />数字aaaaa...000....�Q�这个数字肯定是N的倍数�?br /> �l�合上面的证明，只能得到2个数字肯定能表示N的倍数。但是不能说形式��是aaaaa...000....�?br />
��C��q�里我还是一�Ҏ��\都没有，一炚w��不知道怎么搜烦。。�?br /> 想了1个多��时�Q�无头��A�Q�问�q�了�q�题的同学，�q�是无头�l�。看解题报告�Q�他们的代码写得太牛了，完全看不懂，无头�l��?br />也许也是我对bfs理解太浅�Q�才看不懂他们的搜烦代码。而且�Q�我�q�可以搜索的地方都没有找刎ͼ�都不知道搜什么了�?br /> 想了好久�Q�昨天吃饭的时候，�l�于发现可以对余数进行搜索�?br /> 对于��L��的N�Q�其余数��是范围是[0, N -1]。这个其实就可以代表状态了�Q�或者代表bfs中的点了。从当前余数转移到其�?br />余数的是MOD * K + A 或�?MOD * K + B�Q�如果要转移到得余数以前没被搜过�Q�那��可以�{�U�过厅R��这个刚好就是一�?br />优化了。也可以看成是子问题了。但是，dfs完全不行。刚开始用dfs�Q�绝对的��时�?br /> 用dfs也是我对思�\理解不深�Q��o�q�认��q�。。。后面发玎ͼ��q�题完全和bfs��d��。[0, N -1]刚好代表N个点�Q�我要通过
从外面的一个点�Q�最短的遍历到点0�Q�可以bfs或者最短�\��法。这题我觉得�q�有个难点就是保存答案，因�ؓ�{�案最长的长度
可能是N(N<=10000)�Q�所以把�{�案直接攑ֈ�节点里面肯定不行的。但是，我还仔细看过��法��D��。因此想��C��可以利用bfs
搜烦出来的那颗树或者最短�\��法跑出来的那颗树，从目标节炚w��序��L��{�案�Q�找到出发节点之后，再把�{�案reverse一下就行了�?br /> �q�题�q�得注意0不能是N的倍数�Q�所以注意bfs(0,i)�q�种情况的处理�?br />
代码如下�Q?br />

#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

�q�个是求扩展��L��Ҏ��问题�?em style="font-family: 'Times New Roman', Times, serif; font-size: 16px; line-height: normal; text-align: center; ">X^Y mod Z = K�Q�给出X�Q�Z�Q�K�Q�求Y�?br /> 当Z是素数的时候直接用baby-step��法卛_��了。但是，模数不是素数的情冉|��么办了�?br /> 方程a^X = b % c�Q�可以进行一�p�d��的�{化。假设d = gcd(a,c)�Q�由a^(x-1)*a = b % c�Q�知道a^(x-1)要存在必��L��?br />gcd(a,c)|b�Q�如果满��个条�Ӟ��那么我们可以在方�E?边同旉��以d�Q�方�E�是不变的。因为a^x = b + k * c�Q�再除以公约�?br />d�Q�得到方�E�a^(x-1)*a/d = b / d + k * c / d。根据以上推论，我们可以不断的除以d�Q�直到gcd(a,c)=1�?br /> 假设我们除了k�ơ，那么方程转化为a^(x-k) * a^k/d^k = b / d^k + k * c / d^k。��od = a^k/d^k�Q�b' = b / d^k�Q?br />c' = c / d^k�Q�x' = x - k�Q�方�E��{化�ؓa^x' * d = b' % c'�Q�得到a^x' = b' * d^-1 % c'�?br /> 现在直接用baby-step解方�E�a^x' = b' * (d^-1) % c'卛_��。注意到x=x'+k�Q�如果存在x��于k的解�Q�那么x'��于0�Q�但�?br />由baby-step是不会求负的�ơ数的，所以需要先枚�D一下是否存在小于k的解�Q�由于输入的数据不会��过10^9的，假设k不超�q?0
�q�行枚�D卛_��了�?br />
代码如下�Q?br />

#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;
    //先枚�?-50,扩展baby-step的过�E�可能会漏掉�q�些�?/span>
    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不成�?方程无解�Q?br />    //�q�个由a*x=b%c有解必须满��gcd(a,c)|b一�?/span>
    INT d;
    INT nD = 1;//nD最后是A^k��?k是nC中因子d的次�?/span>
    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�ơ而已,�q�样的做法与原方�E�是�{��h�?br />    //令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;//�q�句话是必须�?y很可能就是负�?/span>
        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

�q�个题很奇葩了。题意是�l�出个数字L�Q�假如存在一个数K使得L*K = 888...�Q�求888...的最��长度，如果不存在这��L��K�Q�那么输�?�?br />我是什么思�\也没有了�Q�拖了几天了�Q�数论搞��L��了，只能扄��案了�?br /> 我看��C��比较靠谱的推法。首先，888...=111...*8=(10^0+10^1+...+10^m-1)*8=(10^m - 1)/9*8�Q�PS�Q�m代表888...的长度�?br />好吧�Q�终于化成指��C��Q�现在有8*(10^m-1)/9=K*L�Q�最��的m��是我们要求的答案啦�?br />
方式1�Q?br />   => 8 * (10^m-1) = 9 * k * L
   => 8/d*(10^m-1)=9*k*L/d�Q�d=gcd(8,9L)
=> 10^m-1 = 0 % 9 * L / gcd(8, 9L) = 0 % 9*L/gcd(8,L)�Q?�׃��gcd(8/d,9L/d)=1�Q�那�?0^m-1必然�?*L/d的倍数�?�?br />   => 10^m = 1 % 9 * L / gcd(8,L)
方式2�Q?br />   => 8*(10^m-1)/9 = 0 % L
   => 8*(10^m-1) = 0 % 9*L(�q�步的推出，比如x/9 = k*n�Q�那么x=9*k*n了，昄��成立)
   => 10^m-1 = 0 % 9*L/gcd(9*L,8)�Q�假如，d = gcd(9*L,8)�Q�那么有8/d*(10^m-1)=k*9*L/d�Q�因�?/d不可能是9 *L / d
的倍数�Q�所�?strong>10^m-1必定�?*L/d的倍数�Q�所�?0^m-1 = 0 % 9*L/gcd(9*L,8))�Q?>�Q?0^m - 1 = 0 % 9 * L / gcd(L, 8),
(因�ؓgcd(9,8)=1)�?br />   => 10^m = 1 % 9*L/gcd(8,L)

��x��Q?�U�方式都推出了，10^m = 1 % 9*L/gcd(8,L) �?br />   那么怎么解答�q�个问题了，�q�个��q��C��Ƨ拉定理了。��op = 9 * L / gcd(8,L)�Q�那么有10^m = 1 % p。由�Ƨ拉定理�?Z*p中所有的
数字a均满��a^euler(p) = 1 % p。那么，10只要是p的乘法群中就肯定有解了。如果，10不在Z*p中了�Q�肯定是无解的。证明如下：
由a^x = 1%p�Q�可以得到a^(x-1)*a=1%p�Q�要a^(x-1)存在�Q�那么gcd(a,p)|1�Q�那么gcd(a,p)必须�?�?br /> �l�g��所�q�ͼ�要满��_��?strong>a^m=1%p�Q�必��gcd(p,a)=1�Q�即a必须是p的乘法群中的数字�?br /> 现在的问题是求最��的m�Q�由�Ƨ拉定理知道a^euler(p)=1%p�Q�m再大��开始��@环了。但是m可能会更��。比如，我们现在知道最��的m
是min�Q�那么有a^min=1%p�Q�因��满��a^euler(p)=1%p�Q�那么a^euler(p)肯定能变换成(a^min)^k,至于k是多��就不知道了�Q�当�?br />也可以求出来。那么min��是euler(p)的一个因子，而且是最��的一个满��a^min=1%p的因子了�?br /> 现在��可以通过枚�Deuler(p)的因子，扑ֈ�最��的因子min满��式子a^min = 1 % p��p��解决本问题了�?br />   注意求a^m%p肯定是通过��法��D��上面那种�Ҏ��?O(32)或者O(64)的复杂度�Q�还有a*b%m也需要自己模拟，因�ؓ可能a*b��溢��Z��?br /> 代码如下�Q�貌��g��码还可以通过其它的改�q�加快速度�?br />

#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^m=1%p或�?br />//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

题意��是�l�出个数n�Q�求Σgcd(i,n)(1<=i<=n)。感觉好奇葩的题目，数论的题��实比较难想�Q�没看出跟欧拉函数有什么关�p�R�?br />很纠�l�，没心情没旉��l�箋想了。看了discussion�Q�然后又��L��了下�{�案�Q�发现有个哥们也得非�怸�错，��q��了下思�\了�?br /> �q�个题的解法是枚举i(1<=i<=n)�Q�如果i|n�Q�那么答案加上euler(n/i)*i。其实ans = Σi*euler(n/i)(i<=i<=n而且i|n)�?br />意思是�?到n的所有数字i�Q�如果i是n的因子，那么计算i*euler(n/i)�Q�加入答案中�Q�euler是欧拉函数的意思�?br /> ��Z��么是�q�样的了。比如，1到n中有m个数字和n拥有公共的最大因子i�Q�那么就需要把m*i加入�{�案中。问题是如何计算m的个数�?br />因�ؓgcd(m,n) = i�Q�可以得到gcd(m/i,n/i)=1�Q�那么m/i��是n/i的乘法群中的数字了，那么一共存在euler(n/i)个m/i了，那么��?br />可以推出m的个数就是euler(n/i)�?br />
代码如下:

#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

�q�个题是求原根的个数。所谓原根，意思是�l�定一个数n�Q�存在数g�Q�g^j能够产生乘法��Zn*中所有的数字。即g^j = {x|x与n互质,
1<=x �q�个题目要求求原根的个数。由贚w��定理�?对�Q�?<=x再往下计��就开始��@环了。那么有,x^i%p(1<=i �Ҏ��上面的那个式子可以得刎ͼ�x^i%(p-1)(1<=i使得x^i*x = (p-1)%p�?br /> 因此可以得到�Q�原根的个数是p-1的乘法群中元素的个数�Q�也��是�Ƨ拉函数(p-1)�?br />
代码如下�Q?br />

#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

�q�是个求��L��Ҏ��的问题。以前学密码学基��的时候也接触�q�，但是没想到acm里面�q�会有这��L��习题�?br /> 问题的意思是�l�定素数P�Q�给出方�E�a^x = b % p�Q�注意有模的方程�{�式2辚w��是取模数的意思。解�q�样的方�E�有一个固定的��法�Q?br />叫做baby-step��法。但是，注意限定条�g是p必须是素数�?br /> 下面的图描述了这个算法：

意思很清楚�Q�就是假设x = i * m + j�Q�那么方�E�可以�{化�ؓb*(a^-m)^i = a^j % p。先计算出右边的��|��存储在一张表里面�Q?br />然后从小到大枚�D左边的i�Q?<=i poj上面�q�个题用map存储(a^j,j)对的时候会��时�Q�改成hash表存储才能过�Q�额�Q�毕竟理论复杂度不是一个数量��的。我的hash表是
开�?个数�l�，一个键�Q�一个��|��用来�怺�验证�Q�槽冲突的话�Q�一直往后找位置。感觉这��L��做法没有铑ּ�hash复杂度��^均的样子�?br /> 代码如下�Q?br />

#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的乘法�?/span>
    y = (y + nP) % nP;
    long long nTemp = 1;
    long long c = 1;//c是nA�?#8212;m��?/span>
    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

�q�是今天想通的一个数论题�Q�还是挺有意思的�Q�想出来的那一瞬间yeah了一下，可是我悲剧的�_�心习惯�Q�还是交�?�ơ才�q�，nm��C��间空
格都错了�Q�又忘记打空行，明明字符串从25列开始，中间�?个空格的�Q�我nc的打�?个空��|��pe了，�q�有不仔�l�看输出要求�Q�没有输出空
行，最�q�真没状态啊�?br /> 其实�Q�这个题想通了��很��单了�Q�还是数论里面的��的概念�Q�就是加法群的生成群啊，打着随机数的�q�子而已。由于又没有限定�U�子�Q�限�?br />对答案也没有影响�Q�假讄��子是0�Q�那么数列可以表�C�Zؓa*step�Q�数列要能够生成0 - mod-1中所有的数字�Q�那么就有a*step = b % mod
(0<=b 哈哈�Q�上面那个式子就是a*x=b%n�q�个�U�性同余方�E�了�Q�只是有很多b了。要方程有解�Q�不是需要满��x��件gcd(a,n)|b么，意思b�?br />gcd(a,n)的整数倍了。但�?<=b 关于�U�性同余方�E�a*x=b%n�Q�要有解的条件gcd(a,n)|b的解释，�q�是参看��法��D��或者其它资料吧。。�?br />
代码��非常简单了�Q�如下：

#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

�q�个题目��是解线性同余方�E�，(a + n*c) % 2的k��?= b % 2的k�ơ。既然以前是学信安的�Q�对数论本来��׃��排斥�Q�最�q�还好好看了下算
法导论。这个方�E��{换�ؓn*c = (b-a) % 2的k�ơ。根据数论的知识�Q? ax = b%n�Q�需要保证gcd(a,n)|b�Q�意思b是gcd(a,n)的倍数�Q�这�?br />一下子也很难解释清楚啊�Q�不满��q�个条�g�Q�就是没解了。还有，如果有解的话�Q�解的个数就是d = gcd(a,n)。而且其中一个解是x0 = x'(b
/ d)�Q�其中x'是用扩展�Ƨ几里�d��法求出来的�Q�满��_��p�d��a*x'+n*y'=d�?br /> 但是�q�个题不仅仅用到数论的这些知识，因�ؓ必须求满��x��件的最��解�Q�而如果有解的话是d个，而且满��解x = x0 + i(b/d)�Q?br />�Q?<=i<=d)。既然要求最��的解，那么对解mod(n/d)卛_��了，因�ؓ它们之间的差都是n/d的倍数�?br />
代码如下�Q?br />

#include

#include
#include
using namespace std;

//扩展�Ƨ几里�d��法
//d = a * x + b * y�Q�d是a和b的最大公�U�数
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��p�|
        {
            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

�q�个题一看就知道是求�Ƨ拉函数。欧拉函数描�q�的正式题意。欧拉函数的理解可以按照��法��D��上面的说法，�?-N-1�q�行�{�选素数�?br />那么公式n∏(1-1/p)�Q�其中p是n的素数因子，��可以得到直观的理解了。但是计��的时候，会将�q�个式子变�Ş下，得到另外一个�Ş式�?br /> 如图所�C�：

但是�q�个题，需要考虑下，有可能n是个大素敎ͼ�直接�q�行因子分解的话会超时的。怎么办了�Q�只能在分解的时候判断n是不是已�l�成�?br />素数了，如果是素敎ͼ��{�案再乘以n-1��p��了。�ؓ了加快判断，我用5mb的空间搞了个素数表，大于5000000的数字只能��@环判断了�?br />
代码如下�Q�注意求�Ƨ拉函数的代码部分：

#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

�W�一个题用到了同余的性质�Q�这是数论里面最基本的性质�Q�但是做题时候不一定能够自己发现。题意是n*m = 11111...�Q�给出n�Q?br />用一个m乘以n得到的答案全�?�l�成的数字，�?最��的个数是多��。可以�{换�ؓn*m=(k*10+1)�Q�那么可以得�?k*10+1)%n==0�?br />当然最开始的k�?�Q�那么我们不断的增长k = �Q?0*k+1�Q�。看增长多少�ơ，��是有多��个1了。因��避免溢出�Q�所以需要不�?n�?br />因�ؓ同余的性质�Q�所以可以保�?n之后�{�案不变�?br /> �W�二个用到素数筛选法。素数筛选法的原理是�{�去素数的倍数�Q�由于是从小循环到大的，所以当前的值没被筛掉的话，则一定是素数�Q?br />�q�个判断��D��复杂度不是n的��^斏V�?br />
poj 2551 代码�Q?br />

#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 代码�Q?br />

#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 发表评论

久久国产成人,久久久久亚洲AV无码专区体验,99久久超碰中文字幕伊人

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 数论素数��试