给你一个素数P(P<=30000)和一串长为n的字符串str[]。字母'*'代表0，字母a-z分别代表1-26，这n个字符所代表的数字分别代表
f(1)、f(2)....f(n)。定义: f (k) = ∑_0<=i<=n-1a_ikⁱ (mod p) (1<=k<=n,0<=ai<P)，求a0、a1.....an-1。题目保证肯定有唯一解。
   解题思路：高斯消元。根据上面的公式显然可以列出有n个未知数的n个方程式：

yx 2012-08-06 16:01 发表评论

#include <stdio.h>
#include <math.h>
typedef long long LL;
#define MAX (6000000)
bool bPrime[MAX];
int nPrime[MAX];
int nNum;

void InitPrime()
{
    LL nMax = sqrt(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;
            }
        }
    }
    for (int i = 2; i < MAX; ++i)
    {
        if (!bPrime[i])
            nPrime[nNum++] = i;
    }

}

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

int main()
{
    LL nN;

    InitPrime();
    while (scanf("%lld", &nN), nN >= 0)
    {
        if (nN <= 2)
        {
            printf("%-lld\n\n", nN);
            continue;
        }

        int nMax = sqrt((double)nN)+ 1;
        for (LL i = 2; i <= 1000000 && i <= nMax; ++i)
        {
            while (nN % i == 0)
            {
                printf("    %-lld\n", i);
                nN /= i;
            }
            if (nN < 6000000 && IsPrime(nN))
            {
                break;
            }
        }
        if (nN != 1)
            printf("    %-lld\n", nN);
        printf("\n");
    }

    return 0;
}

yx 2012-08-01 15:51 发表评论

#include <algorithm>
#include <math.h>
using namespace std;

int GetAns(int nN)
{
    int nAns = 0;
    while (nN)
    {
        nAns += nN / 5;
        nN /= 5;
    }
    return nAns;
}

int main()
{
    int nT;

    scanf("%d", &nT);
    while (nT--)
    {
        int nN;
        scanf("%d", &nN);
        printf("%d\n", GetAns(nN));
    }
    
    return 0;
}

yx 2012-07-27 15:05 发表评论

#include <stdio.h>
#include <math.h>

int main()
{
    double fN;//用double就不会溢出了,负数就可以直接转换为正数了
    
    while (scanf("%lf", &fN), fN)
    {
        bool bFlag = false;
        double fP = 31.0;
        if (fN < 0){fP = 32.0; fN = -fN; bFlag = true;};
        
        while (fP > 0)
        {
            //必须加上一个精度,防止往下误差
            double fA = pow(fN, 1.0 / fP) + 1e-8;
            //fA必须转换为int,因为一点点误差,pow之后就会放大很多
            double fTemp = pow((int)fA, fP);
            
            //必须对负数特殊判断,不可能出现偶数的p
            if (fabs(fN - fTemp) < 1e-8 && (!bFlag || ((int)fP) % 2))
            {
                printf("%.f\n", fP);
                break;
            }
            fP -= 1.0;
        }
    }
    
    return 0;
}

yx 2012-07-26 20:59 发表评论

#include <stdio.h>

int nBase;
int nTwo;
int nOneLow;

int GetMin(int nLow, int nCarry, int nNum)
{
    //printf("nLow:%d, nCarry:%d, nNum:%d\n", nLow, nCarry, nNum);
    int nTemp = nCarry + nLow * nTwo;
    if (nTemp == nOneLow)
    {
        return nNum;
    }

    return GetMin(nTemp % nBase, nTemp / nBase, nNum + 1);
}

int main()
{
    //freopen("out.txt", "w", stdout);
    while (scanf("%d%d%d", &nBase, &nOneLow, &nTwo) == 3)
    {
        printf("%d\n", GetMin(nOneLow, 0, 0) + 1);
    }

    return 0;
}

yx 2012-05-08 16:24 发表评论

#include <stdio.h>
#include <math.h>

int main()
{
    int nInitH, nOnes;
    int nN, n;

    while (scanf("%d%d", &nInitH, &nOnes), nInitH + nOnes)
    {
        int nBeg = 1;
        int nEnd = nOnes;
        int nMid;
    
        while (nBeg <= nEnd)
        {
            nMid = (nBeg + nEnd) / 2;
            
            double fRes = log10(nInitH) * log10(nMid);
            double fTemp = log10(nMid + 1) * log10(nOnes);
            if (fabs(fRes - fTemp) < 1e-10)
            {
                //printf("Find nN:%d\n", nMid);
                nN = nMid;
                break;
            }
            else if (fTemp > fRes)
            {
                nBeg = nMid + 1;
            }
            else
            {
                nEnd = nMid - 1;
            }
        }
        
        n = floor(log10(nInitH) / log10(nN + 1) + 1e-9);
        //printf("nN:%d, n:%d\n", nN, n);

        int nSum = 0;
        int nLazy = 0;
        int nNum = 1;
        for (int i = 0; i <= n; ++i)
        {
            nSum += nNum * nInitH;
            nLazy += nNum;
            nNum *= nN;
            nInitH /= (nN + 1);
        }
        
        printf("%d %d\n", nLazy - nOnes, nSum);
    }

    return 0;
}

yx 2012-05-07 16:54 发表评论

#include <stdio.h>
#include <math.h>

#define MAX (20)
int nN;
struct Point
{
    char szLabel[5];
    int x;
    int y;
};
Point points[MAX];

//三点是否共线
bool IsOneLine(int nOne, int nTwo, int nThree)
{
    int nA = points[nTwo].x - points[nOne].x;
    int nB = points[nTwo].y - points[nOne].y;
    int nC = points[nThree].x - points[nOne].x;
    int nD = points[nThree].y - points[nOne].y;
    
    return (nA * nD == nB * nC);
}

//点nOne和点nTwo是否在直线(nBeg,nEnd)的同一侧(不能在直线上)
bool IsSameSide(int nBeg, int nEnd, int nOne, int nTwo)
{
    //求直线的向量
    int nA = points[nBeg].x - points[nEnd].x;
    int nB = points[nBeg].y - points[nEnd].y;
    
    //直线方程为nB(x - points[nBeg].x) - nA(y - points[nBeg].y) = 0
    //分别用nOne和nTwo的坐标代入直线方程计算结果，然后将结果相乘
    //乘积必须大于0
    int nRes = (nB * (points[nOne].x - points[nBeg].x) - nA * (points[nOne].y - points[nBeg].y))
    * (nB * (points[nTwo].x - points[nBeg].x) - nA * (points[nTwo].y - points[nBeg].y));
    
    if (nRes > 0)
    {
        //printf("点:%d,点:%d,在直线nBeg:%d, nEnd:%d的同一侧\n", nOne, nTwo, nBeg, nEnd);
    }
    return nRes > 0;
}

//点是否在三角形(nOne, nTwo, nThree)外部
bool PointOutTriangle(int nOne, int nTwo, int nThree, int nPoint)
{
    //前面3个ifelse是判断点是否在边上
    if (IsOneLine(nOne, nTwo, nPoint))
    {
        if ((points[nOne].x - points[nPoint].x) * (points[nTwo].x - points[nPoint].x) <= 0)
        {
            return false;
        }
    }
    else if (IsOneLine(nOne, nThree, nPoint))
    {
        if ((points[nOne].x - points[nPoint].x) * (points[nThree].x - points[nPoint].x) <= 0)
        {
            return false;
        }
    }
    else if (IsOneLine(nTwo, nThree, nPoint))
    {
        if ((points[nTwo].x - points[nPoint].x) * (points[nThree].x - points[nPoint].x) <= 0)
        {
            return false;
        }
    }
    
    //下面的IsSameSide如果nPoint在直线的(nOne,nTwo)的外侧也会判断为假
    //所以需要先在上面判断点是否在边的内侧
    return !(IsSameSide(nOne, nTwo, nThree, nPoint)
    && IsSameSide(nOne, nThree, nTwo, nPoint)
    && IsSameSide(nTwo, nThree, nOne, nPoint));
}

bool IsValid(int nOne, int nTwo, int nThree)
{
    if (IsOneLine(nOne, nTwo, nThree))
    {
        //printf("点:%d,%d,%d共线\n", nOne, nTwo, nThree);
        return false;
    }
    
    for (int i = 0; i < nN; ++i)
    {
        if (i == nOne || i == nTwo || i == nThree)
        {
            continue;
        }

        if (!PointOutTriangle(nOne, nTwo, nThree, i))
        {
            //printf("点:%d, 在三角形:%d,%d,%d内部\n", i, nOne, nTwo, nThree);
            return false;
        }
    }
    
    return true;
}

//计算三角形(nOne, nTwo, nThree)的面积
double GetArea(int nOne, int nTwo, int nThree)
{
    return 0.5 * fabs((points[nThree].y - points[nOne].y) * (points[nTwo].x - points[nOne].x)
    - (points[nTwo].y - points[nOne].y) * (points[nThree].x - points[nOne].x));
}

int main()
{
    while (scanf("%d", &nN), nN)
    {
        for (int i = 0; i < nN; ++i)
        {
            scanf("%s%d%d", points[i].szLabel, &points[i].x, &points[i].y);
        }
        
        double fMaxArea = 0.0;
        int nI = -1, nJ = -1, nK = -1;
        for (int i = 0; i < nN - 2; ++i)
        {
            for (int j = i + 1; j < nN - 1; ++j)
            {
                for (int k = j + 1; k < nN; ++k)
                {
                    if (IsValid(i, j, k))
                    {
                        //printf("i:%d,j:%d,k:%d valid\n", i, j, k);
                        double fArea = GetArea(i, j, k);
                        //printf("Area:%f\n", fArea);
                        if (fArea > fMaxArea)
                        {
                            nI = i;
                            nJ = j;
                            nK = k;
                            fMaxArea = fArea;
                        }
                    }
                }
            }
        }
        printf("%s%s%s\n", points[nI].szLabel, points[nJ].szLabel, points[nK].szLabel);
    }
    
    return 0;
}

yx 2012-05-07 14:07 发表评论

#include <stdio.h> 
#include <math.h>

int GetN(int nK)
{
    int nBeg = 1;
    int nEnd = sqrt(nK * 2) + 2;
    
    while (nBeg <= nEnd)
    {
        int nMid = (nBeg + nEnd) / 2;
        int nTemp = (nMid * nMid + nMid) / 2;
        if (nTemp >= nK)
        {
            nEnd = nMid - 1;
        }
        else
        {
            nBeg = nMid + 1;
        }
    }
    
    return nEnd + 1;
}

int main()
{
    int nK;
    int nTest;
    
    scanf("%d", &nTest);
    while (nTest--)
    {
        scanf("%d", &nK);
        if (nK < 0)
        {
            nK *= -1;
        }
        //int nN = ceil(sqrt(2 * fabs(1.0 * nK) + 0.25) - 0.5 + 1e-9);
        //上面那种方法存在浮点误差,wa了三次
        int nN = GetN(nK);
        
        while (1)
        {
            if (((nN * nN + nN) / 2 - nK) % 2 == 0)
            {
                printf("%d\n", nN);
                break;
            }
            ++nN;
        }
        if (nTest)
        {
            printf("\n");
        }
    }
    
    return 0;
}

yx 2012-05-04 16:53 发表评论

#include <stdio.h>
#include <string.h>

int main()
{
    int nCases;
    int nN;
    double a0, an1;
    double a1;
    double ci[3000 + 10];
    double c;
    double sum;
    
    scanf("%d", &nCases);

    while (nCases--)
    {
        scanf("%d", &nN);
        scanf("%lf%lf", &a0, &an1);
        
        sum = 0.0;
        memset(ci, 0, sizeof(ci));
        for (int j = 1; j <= nN; ++j)
        {
            scanf("%lf", &c);
            ci[j] = ci[j - 1] + c;//ci[j]代表数列ci中第1-j项的和
            sum += ci[j];
        }

        a1 = (nN * a0 + an1 - 2 * sum) / (nN + 1);
        printf("%.2f", a1);
        putchar('\n');
        
        if (nCases)
        {
            putchar('\n');
        }
    }
    
    return 0;
}

yx 2012-05-03 18:55 发表评论

#include <stdio.h>
#include <string.h>
#include <math.h>

int nN, nB;

int nDivisor[1000];

int GetDigit(int nN, int nB)
{
    double fSum = 0.0;
    for (int i = 2; i <= nN; ++i)
    {
        fSum += log10(i);
    }
    
    fSum /= log10(nB);
   
    return floor(fSum + 1e-9) + 1;
}

int GetZero(int nN, int nB)
{
    memset(nDivisor, 0, sizeof(nDivisor));

    for (int i = 2; i <= nN; ++i)
    {
        int nTemp = i;
        
        for (int j = 2; j <= nTemp && j <= nB; ++j)//这样循环就可以进行素数因子分解了
        {
            while (nTemp % j == 0)
            {
                nDivisor[j]++;
                nTemp /= j;
            }
        }
    }
    
    int nAns = 0;
    
    while (1)
    {
        int nTemp = nB;
        
        for (int j = 2; j <= nTemp; ++j)//分解nB
        {
            while (nTemp % j == 0)
            {
                if (nDivisor[j] > 0)//如果还可以继续分解
                {
                    --nDivisor[j];
                }
                else //直接可以goto跳出多重循环了
                {
                    goto out;
                }
                nTemp /= j;
            }
        }
        ++nAns;
    }
    
out:
    return nAns;
}

int main()
{
    while (scanf("%d%d", &nN, &nB) == 2)
    {
        int nDigit = GetDigit(nN, nB);
        int nZero = GetZero(nN, nB);
        printf("%d %d\n", nZero, nDigit);
    }

    return 0;
}

yx 2012-05-02 20:05 发表评论

#include <iostream> 
using namespace std;

int main()
{
    long long m, n;
    int nCases = 0;
    
    while (cin >> m >> n, m + n != 0)
    {
        long long a = m * m;
        long long b = n * n;
        cout << "Case " << ++nCases << ": "
        << (a * b - a * n - b * m + m * n) / 4 << endl;
    }
    
    return 0;
}

yx 2012-04-12 20:44 发表评论