经典算法C++版（参考一线码农博文）

鉴于一线码农的算法博文基本通过C#完成，此处用C++再实现一遍，具体解法可参考其博文。

地址：http://www.cnblogs.com/huangxincheng/category/401959.html。

1.百钱买百鸡（降低时间复杂度）

void NumofHen_1()
{
    int x, y, z;
    for ( x = ; x < ; x++)
    {
        for ( y = ; y < ; y++)
        {
            z =  - x - y;

            if ((z %  == ) && (( * x +  * y + z / ) == ))
            {
                cout << "公鸡：" << x << " 母鸡：" << y << " 小鸡：" << z << endl;
            }
        }
    }
}

void NumofHen_2()
{
    int x, y, z;
    for (size_t k = ; k < ; k++)
    {
        x =  * k;
        y =  -  * k;
        z =  +  * k;
        cout << "公鸡：" << x << " 母鸡：" << y << " 小鸡：" << z << endl;
    }
}

2.五家五井（不定方程组，运用数据为整数特性）

代码省略，详情见一线码农相应博客。

3.猴子吃桃（尾递归）

题目：猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾就多吃了一个。第二天早上又将剩下的桃子吃了一半，还是不过瘾又多吃了一个。

以后每天都吃前一天剩下的一半再加一个。到第10天刚好剩一个。问猴子第一天摘了多少个桃子？

int SumPeach1(int day)
{
    if (day == )
        return ;
    else return  * SumPeach1(day + ) + ;
}

void NumofPeach_1()
{
    int sum = SumPeach1();
    cout << "桃子数目：" << sum << endl;
}

//尾递归（剑指offer上有类似题目，判定二叉树是否平衡）
int SumPeach_2(int day, int sum)
{
    if (day == )
        return sum;
    else return SumPeach_2(day + ,  * sum + );
}

void NumofPeach_2()
{
    int sum = SumPeach_2(, );
    cout << "桃子数目：" << sum << endl;
}

尾递归将每次计算结果进行传递，但是具体效果得看编译器是否进行了相应优化。

此题还有更为简单的做法，具体为参考每次计算数值的规律性，与2的次方存在对应关系。

4.寻找最长公共子序列（顺序，可以非连续）

void sub_str(unsigned char** mat, const int i, const int j, const string& s,string& substr)
{
    if (i ==  || j == )
        return;

    if ( == mat[i][j])
    {
        substr += s[j - ];
        sub_str(mat, i - , j - , s, substr);
    }
    else
    {
        if ( == mat[i][j])
            sub_str(mat, i - , j, s, substr);
        else if ( == mat[i][j])
            sub_str(mat, i, j - , s, substr);
    }
}

//注意此处是寻找顺序的最长公共子序列(可以非连续)
void LengthofSubstr_1(const string& s1, const string& s2)
{
    int i, j, len1 = s1.length(), len2 = s2.length();
    if ( == len1 ||  == len2) return;

    int **matrix; //创建矩阵并初始化
    matrix = new int*[len1 + ];
    //0无意义,1表示左边,2表示上面,3表示左上角
    unsigned char **signmat;
    signmat = new unsigned char*[len1 + ];
    for (i = ; i < len1 + ; i++)
    {
        matrix[i] = new int[len2 + ];
        signmat[i] = new unsigned char[len2 + ];
    }

    //此处其实无需全部初始化，初始化边界元素即可
    for (i = ; i < len1 + ; i++)
        for (j = ; j < len2 + ; j++)
        {
            matrix[i][j] = signmat[i][j] = ;
        }

    //填充矩阵
    for (i = ; i < len1 + ; i++)
    {
        for (j = ; j < len2 + ; j++)
        {
            if (s1[i - ] == s2[j - ])
            {
                signmat[i][j] = ;
                matrix[i][j] = matrix[i - ][j - ] + ;
            }
            else
            {
                //比较“左边”和“上边”的信息，选取最大值进行填充
                if (matrix[i - ][j] >= matrix[i][j - ])
                {
                    signmat[i][j] = ;
                    matrix[i][j] = matrix[i - ][j];
                }
                else
                {
                    signmat[i][j] = ;
                    matrix[i][j] = matrix[i][j - ];
                }
            }
        }
    }

    string substr; //将最长公共子序列输出
    sub_str(signmat, len1, len2, s2, substr);
    std::reverse(substr.begin(), substr.end());

    cout << "最大公共子序列长度为：" << matrix[len1][len2] << "；最长字串为：" << substr << endl;

    //释放矩阵
    for (i = ; i < len1 + ; i++)
    {
        delete[] matrix[i];
        delete[] signmat[i];
    }
    delete[] signmat;
    delete[] matrix;
}

个人建议还是将中间过程进行输出，这样方便理解，最好是看下面网址的图解。

http://www.cnblogs.com/huangxincheng/archive/2012/11/11/2764625.html

不过博客里面的图解初始位置应该为0，自己输出中间变量的就会比较清楚。漂亮的解法。

5.字符串相似度

对于两个字符串A和B，通过基本的增删改将字符串A改成B，或者将B改成A，在改变的过程中我们使用的最少步骤称之为“编辑距离”。

虽然没太看懂，不过这个解题思路和上面类似，仅仅是初始化方式进行了改变，意义完全不一样了，赞

int MinofThree(const int x1, const int x2, const int x3)
{
    int min = x1 < x2 ? x1 : x2;
    return x3 < min ? x3 : min;
}

int SameofStr(const string& s1, const string& s2)
{
    int i,j,len1 = s1.length(), len2 = s2.length();
    if (len1 <=  || len2 <= ) return ;

    int **matrix = NULL;
    matrix = new int*[len1 + ];
    for (i = ; i < len1 + ; i++)
        matrix[i] = new int[len2 + ];
    //初始化矩阵,跟前面的求公共字符串初始化不同
    for (i = ; i < len1 + ; i++)
        matrix[i][] = i;
    for (i = ; i < len2 + ; i++)
        matrix[][i] = i;

    for ( i = ; i < len1+; i++)
    {
        for (j = ; j < len2 + ; j++)
        {
            if (s1[i - ] == s2[j - ])
            {
                matrix[i][j] = matrix[i - ][j - ];
            }
            else
            {
                matrix[i][j] = MinofThree(matrix[i - ][j], matrix[i][j - ], matrix[i - ][j - ]) + ;
            }
        }
    }

    int res = matrix[len1][len2];
    for (i = ; i < len1 + ; i++)
        delete[] matrix[i];
    delete[] matrix;

    //返回字符串的编辑距离
    return res;
}

6.KMP算法（暂时未理解）

void GetNextVal(int next[], const string& str)
{
    //前缀起始位置以及后缀起始位置
    int k = -, j = ;
    next[j] = -;

    while (j < str.length() - )
    {
        if (- == k || str[k] == str[j])
        {
            next[++j] = ++k;
        }
        else
        {
            k = next[k];
        }
    }
}

//s1为主串,s2为子串
int KMP(const string& s1, const string& s2)
{
    int i = , j = , len1 = s1.length(), len2 = s2.length();

    if (len1 < len2 || len1 <=  || len2 <= )
        return -;
    else if (len1 == len2)
    {
        for (i = ; i < len1; i++)
            if (s1[i] == s2[i])
                return -;
        return ;
    }

    int *next = new int[len2];
    memset(next, , sizeof(next));
    GetNextVal(next, s2);

    while (i < len1&&j < len2)
    {
        if (- == j || s1[i] == s2[j])
        {
            ++i;++j;
        }
        else
        {
            j = next[j];
        }
    }

    delete[] next;
    if (j == len2)
        return i - len2;
    else return -;
}

7.改进版KMP算法

void getnext(const string& T,int next[])
{
    next[] = -;
    int i = , j = -; //分别表示前后缀串的初始位置

    while (i < T.length() - )
    {
        if (- == j || T[i] == T[j])
        {
            ++i;++j;
            if (T[i] != T[j])
                next[i] = j;
            else next[i] = next[j];
        }
        else
        {
            j = next[j];
        }
    }
}

//pos表示从主串的第pos个位置进行匹配
int KMP(const string& S, const string& T, int pos = )
{
    int i = pos, j = -, len1 = (int)S.length(), len2 = (int)T.length();
    int *next = new int[T.length()];

    getnext(T, next);
    //此处不能使用i < S.length() && j < T.length()
    //因为length()函数返回的为size_t，负数与其比较时会转换为size_t
    while (i < len1&&j < len2)
    {
        if ((- == j) || S[i] == T[j])
        {
            ++i;++j;
        }
        else
        {
            j = next[j];
        }
    }
    delete[] next;

    if (j == T.length())
        return i - T.length();
    else return -;
}

8.华为机试题目，猴子分桃

//猴子分桃算法
long long NumOfPeach(int n)
{
    if (n <  || n>)
        return -;

    long long i, j, num, tmp;
    for (i = ; ; ++i)
    {
        num = i;
        for (j = ; j < n; j++)
        {
            if (num%n == )
            {
                tmp = (num - ) / n;
                num = num -  - tmp;
            }
            else break;
        }
        if (j == n)
            break;
    }
    return i;
}