【算法】扑克牌中的顺子,约瑟夫问题,股票的最大利润

面试题61:扑克牌中的顺子

从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。2～10为数字本身，A为1，J为11，Q为12，K为13，而大、小王可以看成任意数字。

大小王当成0，对其进行排序，统计相邻数字间的空缺总数能否被数组中的0填充。非0数字重复出现，数组一定不连续。

#include<bits/stdc++.h>
using namespace std;

//比较两个指针内容的大小 
int Compare(const void *arg1, const void *arg2) {
	//比较将其转成int指针后取内容的大小 
	return *(int*) arg1 - *(int*) arg2;
}

//输入长为length的numbers数组表示的扑克牌,判断是不是顺子 
bool IsContinuous(int* numbers, int length) {
	if(numbers == nullptr || length < 1)//输入合法性 
		return false;
	
	//扑克牌最多就那些牌,排序时间复杂度是O(1)的而不再是O(nlogn) 
	qsort(numbers, length, sizeof(int), Compare);

	int numberOfZero = 0;//大小王的数目 
	int numberOfGap = 0;//空缺数目 

	//统计数组中0的个数
	for(int i = 0; i < length && numbers[i] == 0; ++i)
		++numberOfZero;

	//统计数组中的间隔数目
	int small = numberOfZero;//初始化为第一个数地址 
	int big = small + 1;//初始化为相邻的第二个数地址 
	while(big < length) {//big=length时统计的是最后一对 
		//两个数相等,有对子,不可能是顺子
		if(numbers[small] == numbers[big])
			return false;
		//空缺数+=相邻两数的数字差-1,例如(1,4)之间少了两数(2,3) 
		numberOfGap += numbers[big] - numbers[small] - 1;
		//向前走一步,下一对 
		small = big;
		++big;
	}
	//至此,说明没有对子
	//如果空缺总数不超过0的总数就能被填满,是顺子 
	return (numberOfGap > numberOfZero) ? false : true;
}

int main() {
	int numbers[] = { 1, 3, 0, 5, 0 };
	cout<<boolalpha<<IsContinuous(numbers,sizeof(numbers)/sizeof(int))<<endl;//true 
	return 0;
}

扑克牌点数只有0到13，直接改用哈希表存会更快，并且不必排序就能第一时间知道有没有对子。

面试题62:约瑟夫问题

0, 1, …, n-1这n个数字排成一个圆圈，从数字0开始每次从这个圆圈里删除第m个数字。求出这个圆圈里剩下的最后一个数字。

解法一（暴力法）

用std::list模拟环形链表，迭代器每次到尾部之后就移动到头部即可，这是最直观的暴力法了。

#include<bits/stdc++.h>
using namespace std;

//0~n-1,每次删除第m个数字,返回最后剩下的数字 
int LastRemaining_Solution1(unsigned int n, unsigned int m) {
	if(n < 1 || m < 1)//n和m都应为正 
		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) {//"第m个"即是要向后走m-1步 
			current ++;
			if(current == numbers.end())//走出尾(end没存数字) 
				current = numbers.begin();//就回到头部 
		}

		list<int>::iterator next = ++ current;//要删除数字的下一个数字 
		if(next == numbers.end())//还是,模拟环形结构 
			next = numbers.begin();

		-- current;//迭代器回到这个要删除的数字 
		numbers.erase(current);//将它删除 
		current = next;//迭代器指向刚刚删除数字的下一个数字 
	}//继续重复这个过程,直到链表中只剩下一个数字为止  
	return *(current);//返回这个唯一的数字 
}

int main() {
	cout<<LastRemaining_Solution1(4000,997)<<endl;//1027
	return 0;
}

解法二（递推）

有点复杂，详细分析见书上。0~n-1的序列删除$(m-1)\%n$位置的数字后得到的新序列可以映射到一个从0~n-2的新序列，然后在新序列上做相同的操作，从而输入n和m的问题结果可以由输入n-1和m的问题来解决。

#include<bits/stdc++.h>
using namespace std;

int LastRemaining_Solution2(unsigned int n, unsigned int m) {
	if(n < 1 || m < 1)//输入合法性 
		return -1;
	
	//相当于书上的f(n,m)
	//当n=1时因为只有一个数字0,没有东西可删所以就是0 
	int last = 0;
	for (int i = 2; i <= n; i ++)//n从2开始一直到输入的n 
		last = (last + m) % i;//新的f(n,m)=(旧的f(n,m)+m)%n

	return last;
}

int main() {
	cout<<LastRemaining_Solution2(4000,997)<<endl;//1027
	return 0;
}

面试题63:股票的最大利润

假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖交易该股票可能获得的利润是多少？例如一只股票在某些时间节点的价格为{9, 11, 8, 5, 7, 12, 16, 14}。如果我们能在价格为5的时候买入并在价格为16时卖出，则能收获最大的利润11。

最大利润就是数组中所有数对的最大差值，只要在扫描过程中记录下来之前扫描过的数字中最小的那个即可不断更新最大利润。

#include<bits/stdc++.h>
using namespace std;

//在长为length的numbers数组中找数对的最大差值 
int MaxDiff(const int* numbers, unsigned length) {
	//至少有2个数才能谈最大差值
	if(numbers == nullptr || length < 2)//更正:这里应是||而不是&&关系 
		return 0;

	int min = numbers[0];//min存遇到的最小数字,这里初始化为第一个数字
	
	//注意,不去记录最大数字,而是记录差值
	//要求的是差值最大,而最大数字也可能在最小数字的左边
	//同样地,这个差值完全可能和最小最大数字一个不占
	//但这里记录前面遇到的最小,是为了方便计算后面某个数结尾的最大差值 
	//而所求正是这些"某个数结尾的最大差值"中最大的一个 
	int maxDiff = numbers[1] - min;//存最大差值,初始化为前两个数差值 

	for(int i = 2; i < length; ++i) {//从2号数字开始一直到最后 
		//每次取它前一个数字和最小比较并更新,最后一个数没法作为买入点 
		if(numbers[i - 1] < min) 
			min = numbers[i - 1];//更新最小 

		int currentDiff = numbers[i] - min;//当前数字和前面的最小的差值 
		if(currentDiff > maxDiff)//如果发现更大差值 
			maxDiff = currentDiff;//更新差值 
	}
	//遍历完一趟数组后,就得到了最大差值 
	return maxDiff;
}

int main() {
	int numbers[] = { 4, 1, 3, 2, 5 };
	cout<<MaxDiff(numbers,sizeof(numbers)/sizeof(int))<<endl;//4
	return 0;
}