一步步学算法(算法题解)---1
本人大二，最近开始自学算法，在此记录自己学习过程中接触的习题。与君共勉。
水平有限，目前涉及的题目都比较水。
题目分布为5+1. 5为自己学习的5道水题。 1为从网上找到的比较有水平的相关题目。
一步步学算法(算法题解)---1
数值处理相关问题。
1。19头牛
问题描述:有一个老人在临死前把三个儿子叫到跟前,告诉他们把19头牛分了,老大分1/2,老二分1/4,老三分1/5,说完就死了.按当地习俗,不能宰牛.问三个儿子各能分多少?
问题分析:由于19与2、4、5都不能整除,所以就不能用平常的方法来解决这个问题。但是,如果仔细一点就可以发觉到:1/2+1/4+1/5=19/20,而牛的数量刚好为19。
由此，不难写出下面的代码。
#include
int main()
{
int i;
for (i=1; i<=10; i++) //遍历查找
{
if (i + i/2 + 2*i/5 == 19) //找到满足条件的个数
{
printf("三个儿子分别分得:%d头，%d头，%d头", i, i/2, 2*i/5);
}
}
return 0;
} //打印结果三个儿子分别分得:10头，5头，4头
2.分钱
问题描述：一元钱分成1分、2分、5分的,问有多少种分法?
问题分析：从题目就能看出，分发肯定是有很多种，常规的逐个判断显然不适合。考虑到不是所有的面值都得用到，并且1分得特殊性（最小因子）。我们先从5分开始考虑，遍历5分所有可能个数，然后制约2分的个数，最后1分的无需考虑，缺了全部补一分的就行了。
由此，不难写出下面的代码
#include
int main()
{
int i, j;
int count_ = 0;
for (i=0; i<=20; i++) //遍历5分的所有情况。 0<=i<=20
{
for (j=0; j<=(100-5*i)/2; j++) //制约2分的可能情况 一
{
count_++; //二
} //三
//或者。上述 一二三语句可以替换成如下语句
//for (j=0; j<=50; j++)
//{
// if (5*i + j*2 <= 100)
// {
// count_++;
// }
//}
}
printf("共有%d种分法", count_);
return 0;
}
//打印结果 共有541种分法 3.队列人数
问题描述：在爱尔兰守神节那天,举行每年一度的庆祝游戏,指挥者若将乐队排成10人、9人、8人、7人、6人、5人、4人、3人和2人时,最后的一排总是缺少一个人,那些人想这个位置大概是给数月前死去的乐队成员凯西还留着位置。指挥者见到总缺一人恼火了,叫大家排成一列纵队前进。假定人数不超过7000人,那么乐队究竟有多少人?
#include
int main()
{
int i, j;
for (i=9; i<=7000; i+=10) //用最大步长取最外层循环变量值
{
for (j=9; j>=2; j--) //模拟排队过程
{
if ((i+1)%j != 0) //不满足条件
{
break;
}
}
if (j==1) //满足条件
{
printf("乐队共有%d人", i);
return 0; //找到最小的
}
}
return 0;
}
//打印结果 乐队共有2519人 4.里程碑种数
问题描述：甲、乙两个城市有一条999公里长的公路。公路旁每隔一公里竖立着一个里程碑,里程碑的半边写着距甲城的距离,另半边写着距乙城的距离。有位司机注意到有的里程碑上所写的数仅用了两个不同的数字,例如000/999仅用了0和9,118/881仅用了1和8。算一算具有这种特征的里程碑共有多少个,是什么样的?
问题分析：从题意中可知每对数仅用了两个不同的数字,并且两个数字之和衡等于9.并且,每对数之和也应衡等于999. 通过这两个限制条件，我们也不难写出代码。
#include
int main()
{
int i, j, k, sum_, count_ = 0;
for (i=0; i<=9; i++)
{
for (j=0; j<=9; j++)
{
for (k=0; k<=9; k++)
{
if (((i==j)&&(9-i==k))||((i==k)&&(9-i==j))||((j==k)&&(9-k==i))||((i==j)&&(j==k)))
{
sum_ = i*100 + j*10 + k;
printf("%d---%d\n", sum_, 999-sum_);
count_++;
}
}
}
}
printf("满足条件的里程碑个数: %d", count_);
return 0;
}
//打印结果 满足条件的里程碑个数: 40 （具体省略） 5.同等遗产
问题描述：父亲临终时,让按下列方式分配他的遗产:大儿子分得100克朗和剩下财产的1/10,二儿子分得200克朗和剩下财产的1/10,三儿子分得300克朗和剩下财产的1/10。依此类推,最后发现这种分法好极了,因为所有儿子分得的钱数恰好相等。问他共有几个儿子?每
个儿子分得多少遗产?
问题分析: 还是遍历。不难，直接上代码
#include
int main()
{
int i, j, k, m, n;
for (n=600; ; n=n+10) //由题意得，遗产最少600，并且最小步长10
{
k = 100 + (n-100)/10; //遍历寻找满足条件的
m = n - k; //每个儿子遗产都一样，直接利用大儿子分得的带入计算
for (i=2; m>0; i++)
if ((m%10!=0)||(k!=i*100+(m-i*100)/10))
break;
else m = (m-i*100) - (m-i*100)/10;
if (m==0)
{
printf("他共有%d个儿子,每个儿子分得%d克朗.", i, k);
exit(0); //找出后退出程序，不然无限循环
}
}
return 0;
}
//打印结果 他共有10个儿子,每个儿子分得900克 6*＊ 寻找丑数 (来源：博客园－笨鸟先飞)
问题描述:
我们把只包含因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含因子7。习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第1500个丑数。
分析：这是一道在网络上广为流传的面试题，据说google曾经采用过这道题。
所谓一个数m是另一个数n的因子，是指n能被m整除，也就是n % m == 0。根据丑数的定义，丑数只能被2、3和5整除。也就是说如果一个数如果它能被2整除，我们把它连续除以2；如果能被3整除，就连续除以3；如果能被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_Solution1(int index)
{
if(index <= 0)
return 0;
int number = 0;
int uglyFound = 0;
while(uglyFound < index)
{
++number;
if(IsUgly(number))
{
++uglyFound;
}
}
return number;
}我们只需要在函数GetUglyNumber_Solution1中传入参数1500，就能得到第1500个丑数。该算法非常直观，代码也非常简洁，但最大的问题我们每个整数都需要计算。即使一个数字不是丑数，我们还是需要对它做求余数和除法操作。因此该算法的时间效率不是很高。
接下来我们换一种思路来分析这个问题，试图只计算丑数，而不在非丑数的整数上花费时间。根据丑数的定义，丑数应该是另一个丑数乘以2、3或者5的结果（1除外）。因此我们可以创建一个数组，里面的数字是排好序的丑数。里面的每一个丑数是前面的丑数乘以2、3或者5得到的。
这种思路的关键在于怎样确保数组里面的丑数是排好序的。我们假设数组中已经有若干个丑数，排好序后存在数组中。我们把现有的最大丑数记做M。现在我们来生成下一个丑数，该丑数肯定是前面某一个丑数乘以2、3或者5的结果。我们首先考虑把已有的每个丑数乘以2。在乘以2的时候，能得到若干个结果小于或等于M的。由于我们是按照顺序生成的，小于或者等于M肯定已经在数组中了，我们不需再次考虑；我们还会得到若干个大于M的结果，但我们只需要第一个大于M的结果，因为我们希望丑数是按从小到大顺序生成的，其他更大的结果我们以后再说。我们把得到的第一个乘以2后大于M的结果，记为M2。同样我们把已有的每一个丑数乘以3和5，能得到第一个大于M的结果M3和M5。那么下一个丑数应该是M2、M3和M5三个数的最小者。
前面我们分析的时候，提到把已有的每个丑数分别都乘以2、3和5，事实上是不需要的，因为已有的丑数是按顺序存在数组中的。对乘以2而言，肯定存在某一个丑数T2，排在它之前的每一个丑数乘以2得到的结果都会小于已有最大的丑数，在它之后的每一个丑数乘以2得到的结果都会太大。我们只需要记下这个丑数的位置，同时每次生成新的丑数的时候，去更新这个T2。对乘以3和5而言，存在着同样的T3和T5。
有了这些分析，我们不难写出如下的代码：
int GetUglyNumber_Solution2(int index)
{
if(index <= 0)
return 0;
int *pUglyNumbers = new int[index];
pUglyNumbers[0] = 1;
int nextUglyIndex = 1;
int *pMultiply2 = pUglyNumbers;
int *pMultiply3 = pUglyNumbers;
int *pMultiply5 = pUglyNumbers;
while(nextUglyIndex < index)
{
int min = Min(*pMultiply2 * 2, *pMultiply3 * 3, *pMultiply5 * 5);
pUglyNumbers[nextUglyIndex] = min;
while(*pMultiply2 * 2 <= pUglyNumbers[nextUglyIndex])
++pMultiply2;
while(*pMultiply3 * 3 <= pUglyNumbers[nextUglyIndex])
++pMultiply3;
while(*pMultiply5 * 5 <= pUglyNumbers[nextUglyIndex])
++pMultiply5;
++nextUglyIndex;
}
int ugly = pUglyNumbers[nextUglyIndex - 1];
delete[] pUglyNumbers;
return ugly;
}
int Min(int number1, int number2, int number3)
{
int min = (number1 < number2) ? number1 : number2;
min = (min < number3) ? min : number3;
return min;
}和第一种思路相比，这种算法不需要在非丑数的整数上做任何计算，因此时间复杂度要低很多。感兴趣的读者可以分别统计两个函数 GetUglyNumber_Solution1(1500) 和 GetUglyNumber_Solution2(1500) 的运行时间。当然我们也要指出，第二种算法由于要保存已经生成的丑数，因此需要一个数组，从而需要额外的内存。第一种算法是没有这样的内存开销的。