一、丑数
1、题目要求
我们把只包含因子2、3、5的数称作丑数,求按从小到大的顺序的第1500个丑数。例如,6、8都是丑数,但14不是,因为它包含因子7.习惯上我们把1当做第一个丑数。
2、题目分析
方法一:
首先,我们再来仔细分析一下丑数的概念,因为2,3,5是丑数的因子,那么就可以说明任意一个丑数对其中一个因子求余为0。丑数只能被2,3,5整除,也就是说,如果能被5整除,就除以连续5,如果最后得到的是1,那么这个数就是丑数。
因此,我们可以写出下面的函数来判断一个数是不是丑数
bool IsUgly(int number)
{
while (number % 2 == 0)
number /= 2;
while (number % 3 == 0)
number /= 3;
while (number % 5 == 0)
number /= 5;
return(number == 1) ? true : false;
}
int GetUglyNumber(int index)
{
if (index < 0)
return 0;
int number = 0;
int uglyFound = 0;
while (uglyFound < index)
{
++number;
if (IsUgly(number))
{
++uglyFound;
}
}
return number;
}
但是这种方法最大的问题就是每个整数都要计算,即使一个整数不是丑数,我们还是要对其进行除法和求余操作。因此这种算法的时间效率不是很高。
方法二:创建数组保存已经找到的丑数,用空间换时间的解法
基于上述算法的弊端,我们要找到一种只计算丑数的方法,而不在非丑数的整数上花费时间。我们可以创建一个数组,里面的数字是排好序的丑数。每个丑数都是前面的丑数乘以2、3或者5得到的。我们把已有最大的丑数记做M,接下来分析如何生成下一个丑数,该丑数肯定是前面某一个丑数乘以2、3或者5的结果,所以我们把已有的丑数乘以2得到M2,把已有的丑数乘以3得到M3,把已有的丑数乘以5得到M5。最后比较三个数的最小值。代码实现如下:
int MIN(int number1, int number2, int number3)
{
int min = (number1 < number2) ? number1 : number2;
min = (min < number3) ? min : number3;
return min;
}
int GetUglyNumber(int index)
{
if (index <= 0)
return 0;
int* pUglyNumber = new int[index];
pUglyNumber[0] = 1;
int nextUglyIndex = 1;
int* pMultiply2 = pUglyNumber;
int* pMultiply3 = pUglyNumber;
int* pMultiply5 = pUglyNumber;
while (nextUglyIndex < index)
{
int min = MIN(*pMultiply2 * 2, *pMultiply3 * 3, *pMultiply5 * 5);
pUglyNumber[nextUglyIndex] = min;
while (*pMultiply2 * 2 <= pUglyNumber[nextUglyIndex]);
++pMultiply2;
while (*pMultiply3 * 3 <= pUglyNumber[nextUglyIndex]);
++pMultiply3;
while (*pMultiply5 * 5 <= pUglyNumber[nextUglyIndex]);
++pMultiply5;
++nextUglyIndex;
}
int ugly = pUglyNumber[nextUglyIndex - 1];
delete[] pUglyNumber;
return ugly;
}
二、数组中的逆序对
1、题目要求
在数组中的两个数字,如果前面一个数字大于后面的数字,则这两个数字组成一个逆序对,输入一个数组,求出这个数组中的逆序对的总数。例如:在数组{7,5,6,4}中,一共存在5个逆序对,分别是(7,6)、(7,5)、(7,4)、(6,4)和(5,4)。
2、题目分析
方法一:
对这道题最直观的解法可能就是顺序扫描整个数组,每扫描到一个数字,逐个比较该数字后面的数字的大小,求出这个数组中的逆序对。但是这种方法的效率不高,时间复杂度可达O(N^2)
方法二:一种以空间换时间的解法
具体的分析我们还是以数组{7,5,6,4}来进行分析。我们先考虑比较两个相邻的数字。总的概括来说就是一个先分解再组合的过程,类似于归并排序。如下图所示:
过程1和过程2就是一个不断分解的过程,当分解成只有一个元素的时候就要开始合并了,合并的过程是进行排序的合并,并且要统计其中的逆序对。
现在最关键的就是过程4合并、排序并统计逆序对的过程。这时,我们需要定义三个指针,p1,p2和p3,其中p1和p2分别指向两个数组的末尾,p3指向辅助数组的末尾。如下图a所示。每次比较两个指针指向的数字,如果p1指向的数字大于p2指向的数字,则构成了逆序对,并且逆序对的数目为第二个子数组中剩余数字的个数(本题中为2)。接下来把p1,p2所指的数字中较大的数字从后往前复制到下面的辅助数组中,然后对应的指针往前挪动一位,如面b图所示。然后再进行上述的比较过程,此时由于p1指向的数字小于p2所指向的数字,所以是不构成逆序对的,但是同样将p1,p2所指的数字中较大的数字从后往前复制到下面的辅助数组中,然后对应的指针往前挪动一位,如面c图所示
有了上述详细的讨论,我们就可以总结出统计逆序对的过程:先把数组分隔成子数组,统计出子数组内部的逆序对数目,然后再统计出两个相邻子数组之间的逆序对的数组。在统计逆序对的过程中,还需要对数组进行排序。所以写出代码实现如下:
int InversePairscore(int* data, int* copy, int start, int end)
{
if (start = end)
{
copy[start] = data[start];
return 0;
}
int length = (end - start) / 2;
int left = InversePairscore(data, copy, start, start + length);
int right = InversePairscore(data, copy, start + length, end);
//i初始化为前半段的最后一个数字的下标
int i = start + length;
//jj初始化为后半段的最后一个数字的下标
int j = end;
int indexCopy = end;
int count = 0;
while (i >= start && j >= start + length + 1)
{
if (data[i] > data[j])
{
copy[indexCopy--] = data[i--];
count += j - start- length;
}
else
{
copy[indexCopy--] = data[j--];
}
}
for (; i >= start; i--)
copy[indexCopy--] = data[i];
for (; j >= start + length + 1; j--)
copy[indexCopy--] = data[j];
return count + left + right;
}
int InversePairs(int* data, int length)
{
if (data == nullptr || length < 0)
return 0;
int* copy = new int[length];
for (int i = 0; i < length; i++)
copy[i] = data[i];
int count = InversePairscore(data, copy,0,length-1);
delete[] copy;
return count;
}