剑指Offer（面试题43~45）

面试题43：n个骰子的点数

题目：把n个骰子仍在地上，所有骰子朝上一面的点数之和为s。输入n，打印出s的所有可能的值出现的概念。
解法一：基于递归求骰子点数，时间效率不够高
要想求出n个骰子的点数和，可以先把n个骰子分成两堆：第一堆只有一个，另一堆有n-1个。单独的那一个有可能从1到6的点数。我们需要计算从1到6的每一种和剩下的n-1个骰子来计算点数和。接下来把剩下的n-1个骰子还是分成两堆，第一堆只有一个，第二堆有n-2个。我们把上一轮那个单独骰子的点数和这一轮骰子的点数相加，再和剩下的n-2个骰子来计算点数和。分析到这里，不难发现这是一种递归的思想，递归结束条件就是最后只剩下一个骰子。

int g_maxValue = 6;
void PrintProbability(int number)
{
    if(number < 1)
        return;

    int maxSum = number*g_maxValue;
    int* pProbabilities = new int[masSum -number +1];
    for(int i = number;i <= maxSum; ++i)
        pProbabilities[i-number] = 0;

    Probability(number,pProbabilities);

    int total = pow((double)g_maxValue,number);
    for(int i = number;i <= maxSum;++ i)
    {
        double ratio =(double)pProbabilities[i - number] / total;
        printf("%d:%e\n",i,ratio);
    }
    delete[] pProbabilities;
}

void Probability(int number,int* pProbabilities)
{
    for(int i = 1;i <= g_maxValue; ++i)
        Probability(number,number,i,pProbabilities);
}

void Probability(int original,int current,int sum,int* pProbabilities)
{
    if(current == 1)
    {
        pProbabilities[sum - original]++;
    }
    else
    {
        for(int i = 1;i <= g_maxValue; ++i)
        {
            Probability(original,current - 1,i + sum,pProbabilities);
        }
    }
}

上述思路很简洁，实现起来很容易。但由于是基于递归的实现，它有很多计算是重复的，从而导致当number变大时性能慢得让人不能接受。

解法二：基于循环求骰子点数，时间性能好
我们可以考虑用两个数组来存储骰子点数的每一个总数出现的次数。在一次循环中，第一个数组中的第n个数字表示骰子和为n出现的次数。在下一循环中，我们加上一个新的骰子，此时和为n的骰子出现的次数应该等于上一次循环中骰子点数和为n-1、n-2、n-3、n-4、n-5与n-6的次数的总和，所以我们把另一个数组的第n个数字设为前一个数组对应的第n-1、n-2、n-3、n-4、n-5与n-6之和。其代码如下：

int g_maxValue = 6;
void PrintProbability(int number)
{
    if(number < 1)
        return;
    int* pProbabilities[2];
    pProbabilities[0] = new int[g_maxValue*number +1];
    pProbabilities[1] = new int[g_maxValue*number +1];
    for(int i = 0;i < g_maxValue * number + 1;++i)
    {
        pProbabilities[0][i] = 0;
        pProbabilities[1][i] = 0;
    }

    int flag = 0;
    for(int i = 1;i <= g_maxValue; ++i)
        pProbabilities[flag][i] = 1;
    for(int k = 2;k <= number; ++k)
    {
        for(int i = 0;i<k;++i)
            pProbabilities[1-flag][i] = 0;

        for(int i=k; i<= g_maxValue*k; ++i)
        {
            pProbabilities[1-flag][i] = 0;
            for(int j=1;j<=i && j<=g_maxValue;++j)
                pProbabilities[1-flag][i]+=pProbabilities[flag][i-j];
        }
        flag = 1-flag;
    }

    double total = pow((double)g_maxValue,number);
    for(int i = number;i <= g_maxValue*number; ++i)
    {
        double ratio =(double)pProbabilities[flag][i] / total;
        printf("%d: %e\n",i,ratio);
    }

    delete[] pProbabilities[0];
    delete[] pProbabilities[1];
}

面试题45：圆圈中最后剩下的数字
题目：0，1，…，n-1这n个数字排成一个圆圈，从数字0开始每次从这个圆圈里删除第m个数字。求出这个圆圈里剩下的最后一个数字。
经典的解法，用环形链表模拟圆圈

int LastRemaining(unsigned int n,unsigned int m)
{
    if(n < 1 || m < 1)
        return -1;

    unsigned int i = 0;

    list<int> numbers;
    for(i = 0;i < n;++i)
        numbers.push_back(i);
    list<int>::iterator current = numbers.begin();
    while(numbers.size() > 1)
    {
        for(int i =1;i<m;++i)
        {
            current++;
            if(current == numbers.end())
                current = numbers.begin();
        }

        list<int>::iterator next = ++current;
        if(next == numbers.end())
            next = numbers.begin();

        --current;
        numbers.erase(current);
        current = next;
    }
    return *(current);
}

上述代码的运行中，我们会发现实际上需要在环形链表里重复遍历很多遍。重复的遍历当然对时间效率有负面的影响。这种方法没删除一个数字需要m步运算，总共有n个数字，因此总的时间复杂度是O(mn)。同时还需要一个辅助链表来模拟圆圈，其空间复杂度是O(n)。

创新的解法：

int LastRemaining(unsigned int n,unsigned int m)
{
    if(n < 1 || m < 1)
        return -1;

    int last = 0;
    for(int i=2;i <= n;i ++)
        last =(last +m) %i;
    return last;
}

参考资料《剑指Offer》