一道面试题——四人喝酒的问题

有a,b,c,d四个人,现在有X,Y,Z三个不规则酒杯,X,Y容量为8两,现在已装满酒,Z容量为3两,为空杯.现在要求四个人每人都能平均喝到4两酒,请说出该怎么喝?写出算法,并打印出每步X,Y,Z杯内的酒多少和四个人每人所喝的酒?
这道题的来源不可考。在网上搜《编程之美》烙饼问题的相关资料的时候看到了这道题,之前没接触过算法,手算想了一会儿居然没有算出来~难过想了大概一天的时间,终于把代码搞定了。
此题类似于《编程之美》中烙饼问题所采用的剪枝+分支定界,关键是对问题过程的处理。只要把问题过程理清,找好边界条件和退出条件,问题自然迎刃而解。我们先找边界条件,显然
    a)每个人都喝到4两酒肯定是程序执行完成的条件,
    b)为了避免重复进入之前某种状态,我们需要判断当前状态是否出现过。
再明确我们倒酒的过程,这里只需要弄清可以倒酒的状态分类。首先,对X、Y、Z三个酒杯的状态和a、b、c、d四个人喝酒的状态要区别对待:
    a)当且仅当某人当前的酒量和酒杯中酒量之和小于等于4,此人才能喝酒。显然,这才是最终可以满足边界条件a的过程
    b)在三个酒杯之间互相倒酒,要注意每个酒杯都不能溢出
    c)如果此状态之前出现过,说明这种状态之下走不通,就没有必要在此状态之下继续进行。另外,X和Y酒杯由于容量一样,在其他状态相同的情况下,可视为相同的状态。
理解了这些,写出代码就比较容易。

/* 有a,b,c,d四个人,现在有X,Y,Z三个不规则酒杯,X,Y容量为8两,现在已装满酒,
 * Z容量为3两,为空杯.现在要求四个人每人都能平均喝到4两酒,请说出该怎么喝?
 * 写出算法,并打印出每步X,Y,Z杯内的酒多少和四个人每人所喝的酒?
 */

#include <stdio.h>

/* 递归调用退出条件:每人都喝到4两,或者回到中间的某个状态 */
#define MAX_STATES	1024		/* 保存中间状态,如果是之前的某个状态就退出 */
#define MAX_STEPS	100			/* 保存最终采用的步骤 */
typedef struct
{
	unsigned char StateArray[7];	/* StateArray 0~2 represent X, Y, Z;
										3~6 represent A, B, C, D*/
}STATE;

static int StateIndex;
static int PourStepState[MAX_STATES];	/* 类似于栈结构,中间状态 */
static int MaxSteps;
static STATE PrintStepIndex[MAX_STEPS];	/* 最终采用的状态 */

static __inline void PrintPourSteps(STATE TempState)
{
	int i;
	++MaxSteps;
	for(i = 0; i < 7; i++)
	{
		PrintStepIndex[MaxSteps].StateArray[i] = TempState.StateArray[i];
	}
}

#define STATE_EXIST		1
#define STATE_NOT_EXIST	0
static int CheckState(STATE TempState)
{	/* 检查当前状态,如果是之前的状态则直接返回,否则保存当前状态 */
	int i, TempSum = 0;
	for(i = 0; i < 7; i++)
	{
		TempSum = TempSum * 10 + TempState.StateArray[i];
	}
	for(i = StateIndex; i > 0; i--)
	{
		if(TempSum == PourStepState[i])
			return STATE_EXIST;
		if(TempState.StateArray[0] == (PourStepState[i]/100000)%10 &&
			TempState.StateArray[1] == PourStepState[i]/1000000 &&
			TempSum%100000 == PourStepState[i]%100000)
		{	/* 对X和Y的状态不做区分 */
			return STATE_EXIST;
		}
	}
	PourStepState[++StateIndex] = TempSum;
	return STATE_NOT_EXIST;
}

static __inline void PourStepNext(STATE *TempState, STATE *PreState)
{
	int i;
	for(i = 0; i < 7; i++)
	{
		TempState->StateArray[i] = PreState->StateArray[i];
	}
	return;
}

#define POUR_SUCCEED	1
#define POUR_FAIL		0
/* 分清处理步骤,注意顺序先尝试X,Y,Z向A,B,C,D中倒,然后进行
 * X,Y,Z之间的处理,否则容易出现死循环或者中间过程过度展开
 */
int DoPouring(STATE PreState)
{
	int	i, j;
	STATE TempState;

	for(i = 0; i <= 2; i++)
	{
		for(j = 3; j < 7; j++)
		{
			if(PreState.StateArray[i] + PreState.StateArray[j] <= 4 && PreState.StateArray[i])
			{
				PourStepNext(&TempState, &PreState);
				TempState.StateArray[j] += TempState.StateArray[i];
				TempState.StateArray[i] = 0;
				if(TempState.StateArray[3] == 4 && TempState.StateArray[4] == 4 &&
					TempState.StateArray[5] == 4 && TempState.StateArray[6] == 4)
				{
					PrintPourSteps(TempState);
					return POUR_SUCCEED;
				}
				if(CheckState(TempState) == STATE_NOT_EXIST)
				{
					if(DoPouring(TempState) == POUR_SUCCEED)
					{
						PrintPourSteps(TempState);
						return POUR_SUCCEED;
					}
				}
			}
		}
	}
	if(PreState.StateArray[1] < 8 && PreState.StateArray[0])	/* X --> Y */
	{
		if(PreState.StateArray[0] + PreState.StateArray[1] > 8)
		{
			PourStepNext(&TempState, &PreState);
			TempState.StateArray[0] = TempState.StateArray[0] + TempState.StateArray[1] - 8;
			TempState.StateArray[1] = 8;
		}
		else
		{
			PourStepNext(&TempState, &PreState);
			TempState.StateArray[1] += TempState.StateArray[0];
			TempState.StateArray[0] = 0;
		}
		if(CheckState(TempState) == STATE_NOT_EXIST)
		{
			if(DoPouring(TempState) == POUR_SUCCEED)
			{
				PrintPourSteps(TempState);
				return POUR_SUCCEED;
			}
		}
	}
	if(PreState.StateArray[2] < 3 && PreState.StateArray[0])	/* X --> Z */
	{
		if(PreState.StateArray[0] + PreState.StateArray[2] > 3)
		{
			PourStepNext(&TempState, &PreState);
			TempState.StateArray[0] = TempState.StateArray[0] + TempState.StateArray[2] - 3;
			TempState.StateArray[2] = 3;
		}
		else
		{
			PourStepNext(&TempState, &PreState);
			TempState.StateArray[2] += TempState.StateArray[0];
			TempState.StateArray[0] = 0;
		}
		if(CheckState(TempState) == STATE_NOT_EXIST)
		{
			if(DoPouring(TempState) == POUR_SUCCEED)
			{
				PrintPourSteps(TempState);
				return POUR_SUCCEED;
			}
		}
	}
	if(PreState.StateArray[0] < 8 && PreState.StateArray[1])	/* Y --> X */
	{
		if(PreState.StateArray[0] + PreState.StateArray[1] > 8)
		{
			PourStepNext(&TempState, &PreState);
			TempState.StateArray[1] = TempState.StateArray[0] + TempState.StateArray[1] - 8;
			TempState.StateArray[0] = 3;
		}
		else
		{
			PourStepNext(&TempState, &PreState);
			TempState.StateArray[0] += TempState.StateArray[1];
			TempState.StateArray[1] = 0;
		}
		if(CheckState(TempState) == STATE_NOT_EXIST)
		{
			if(DoPouring(TempState) == POUR_SUCCEED)
			{
				PrintPourSteps(TempState);
				return POUR_SUCCEED;
			}
		}
	}
	if(PreState.StateArray[2] < 3 && PreState.StateArray[1])	/* Y --> Z */
	{
		if(PreState.StateArray[1] + PreState.StateArray[2] > 3)
		{
			PourStepNext(&TempState, &PreState);
			TempState.StateArray[1] = TempState.StateArray[1] + TempState.StateArray[2] - 3;
			TempState.StateArray[2] = 3;
		}
		else
		{
			PourStepNext(&TempState, &PreState);
			TempState.StateArray[2] += TempState.StateArray[1];
			TempState.StateArray[1] = 0;
		}
		if(CheckState(TempState) == STATE_NOT_EXIST)
		{
			if(DoPouring(TempState) == POUR_SUCCEED)
			{
				PrintPourSteps(TempState);
				return POUR_SUCCEED;
			}
		}
	}
	if(PreState.StateArray[0] < 8 && PreState.StateArray[2])	/* Z --> X */
	{
		if(PreState.StateArray[0] + PreState.StateArray[2] > 8)
		{
			PourStepNext(&TempState, &PreState);
			TempState.StateArray[2] = TempState.StateArray[0] + TempState.StateArray[2] - 8;
			TempState.StateArray[0] = 8;
		}
		else
		{
			PourStepNext(&TempState, &PreState);
			TempState.StateArray[0] += TempState.StateArray[2];
			TempState.StateArray[2] = 0;
		}
		if(CheckState(TempState) == STATE_NOT_EXIST)
		{
			if(DoPouring(TempState) == POUR_SUCCEED)
			{
				PrintPourSteps(TempState);
				return POUR_SUCCEED;
			}
		}
	}
	if(PreState.StateArray[1] < 8 && PreState.StateArray[2])	/* Z --> Y */
	{
		if(PreState.StateArray[1] + PreState.StateArray[2] > 8)
		{
			PourStepNext(&TempState, &PreState);
			TempState.StateArray[2] = TempState.StateArray[1] + TempState.StateArray[2] - 8;
			TempState.StateArray[1] = 8;
		}
		else
		{
			PourStepNext(&TempState, &PreState);
			TempState.StateArray[1] += TempState.StateArray[2];
			TempState.StateArray[2] = 0;
		}
		if(CheckState(TempState) == STATE_NOT_EXIST)
		{
			if(DoPouring(TempState) == POUR_SUCCEED)
			{
				PrintPourSteps(TempState);
				return POUR_SUCCEED;
			}
		}
	}
	return POUR_FAIL;
}

int main()
{
	int i, j;
	STATE OriginalState;

	StateIndex = 0;
	MaxSteps = 0;
	for(i = 0; i < MAX_STATES; i++)
		PourStepState[i] = 0;

	OriginalState.StateArray[0] = 8;
	OriginalState.StateArray[1] = 8;
	for(i = 2; i < 7; i++)
		OriginalState.StateArray[i] = 0;

	DoPouring(OriginalState);

	printf("\tX\tY\tZ\tA\tB\tC\tD\nSTATE:");
	for(j = 0; j < 7; j++)
	{
		printf("\t%d", OriginalState.StateArray[j]);
	}
	printf("\n");
	for(i = MaxSteps; i > 0; i--)
	{
		printf("STATE:");
		for(j = 0; j < 7; j++)
			printf("\t%d", PrintStepIndex[i].StateArray[j]);
		printf("\n");
	}
	printf("Total steps: %d.\ndone.\n", MaxSteps);
	return 0;
}
### 回答1: 好的,下面是对大数据面试题——spark面试题(一)的回答: 1. 什么是Spark?它与Hadoop有什么区别? Spark是一个快速、通用、可扩展的大数据处理引擎,它可以在内存中进行数据处理,因此比Hadoop更快。与Hadoop相比,Spark的优点在于它可以在内存中进行数据处理,因此速度更快,而且它支持更多的数据处理方式,例如流处理、图形处理等。 2. Spark的核心组件有哪些? Spark的核心组件包括Spark Core、Spark SQL、Spark Streaming、MLlib和GraphX。 3. 什么是RDD?它有哪些特点? RDD是Spark中的一个基本概念,它代表一个不可变的分布式数据集合。RDD具有以下特点: - 可以在内存中进行计算,因此速度快; - 支持多种操作,例如map、reduce、filter等; - 可以进行持久化,以便在后续计算中重复使用。 4. Spark中的map和flatMap有什么区别? map和flatMap都是RDD中的转换操作,它们的区别在于: - map操作对每个元素进行转换,返回一个新的元素; - flatMap操作对每个元素进行转换,返回一个包含多个元素的序列。 5. 什么是Spark的shuffle操作? Spark的shuffle操作是指将数据重新分区的操作,它通常发生在reduce操作之前。Shuffle操作会将数据从多个节点上收集到一个节点上,然后重新分区,以便进行后续的计算。 6. Spark中的cache和persist有什么区别? cache和persist都是将RDD持久化到内存中,以便在后续计算中重复使用。它们的区别在于: - cache操作默认将数据持久化到内存中,而persist操作可以指定将数据持久化到内存、磁盘或者其他存储介质中; - cache操作是persist操作的一种简化形式,它默认将数据持久化到内存中,并且只能持久化到内存中。 7. Spark中的reduceByKey和groupByKey有什么区别? reduceByKey和groupByKey都是对键值对RDD进行操作的函数,它们的区别在于: - reduceByKey操作会在每个分区内先进行本地聚合,然后再进行全局聚合,因此效率更高; - groupByKey操作会将所有的键值对都进行网络传输,然后在一个节点上进行聚合,因此效率较低。 8. Spark中的broadcast变量有什么作用? broadcast变量是一种只读的变量,它可以在所有节点上共享,以便在计算过程中使用。使用broadcast变量可以避免在网络上传输大量的数据,从而提高计算效率。 9. 什么是Spark的checkpoint操作? Spark的checkpoint操作是将RDD持久化到磁盘上,以便在后续计算中重复使用。与cache和persist不同的是,checkpoint操作会将数据持久化到磁盘上,以便在内存不足时可以从磁盘上恢复数据。 10. Spark中的Task是什么? Task是Spark中的一个基本概念,它代表一个可以在一个节点上执行的计算任务。Spark将一个RDD分成多个分区,每个分区对应一个Task,这些Task可以并行执行,以提高计算效率。 ### 回答2: 今天我们来讨论一下关于Spark大数据面试的一些常见问题。Spark是一种基于Hadoop的开源计算系统,它能够快速处理大规模数据,并且支持多种编程语言,包括Java、Scala和Python等。以下是一些Spark面试题及其答案: 1. Spark有哪几种部署模式? Spark有三种部署模式,分别是本地模式、集群模式和分布式模式。本地模式指的是在本地运行Spark应用程序,不需要连接到外部计算机。集群模式指的是单个Spark集群环境,它由一组Spark节点组成,可以在数据中心或云中运行。分布式模式指的是使用多个Spark集群并行处理大规模数据。 2. Spark和Hadoop的区别是什么? Spark和Hadoop都是处理大规模数据的工具,但它们有一些区别。首先,Spark处理数据速度快,因为它将数据存储在内存中,而Hadoop则将数据存储在磁盘中。其次,Spark支持更多的编程语言,包括Java、Scala和Python等,而Hadoop只支持Java。此外,Spark具有更好的机器学习和图形处理功能,可以更好地支持大规模数据分析。 3. Spark的RDD是什么? RDD是Spark中重要的概念,全称为Resilient Distributed Dataset。它是一个不可变的分布式数据集合,可以分区存储在不同节点上,并且每个分区都可以在并行处理中进行处理。RDD支持两种操作,即转化操作和行动操作。转化操作将一个RDD转换为另一个RDD,而行动操作返回一个结果或将结果输出至外部系统。 4. Spark的优化技术有哪些? Spark优化技术包括数据本地化、共享变量、宽依赖和窄依赖、缓存和持久化,以及数据分区等技术。数据本地化将数据存储在尽可能接近计算节点的位置,以减少网络传输的开销。共享变量将常用的变量通过广播或累加器的方式在节点中共享,从而减少网络传输量。宽依赖和窄依赖指的是在转化操作中RDD之间的依赖关系,窄依赖表示每个父分区最多与一个子分区有关联,而宽依赖则表示多个子分区可能与多个父分区关联。缓存和持久化技术可将RDD保存在内存中,从而加速访问速度。数据分区可以将数据划分为较小的块进行并行处理。 5. Spark Streaming是什么? Spark Streaming是Spark的一个扩展模块,它支持实时数据流处理。Spark Streaming可以将实时数据流以微批次方式处理,每个批次的数据处理平均耗时只有几秒钟。Spark Streaming可以将数据存储在内存或磁盘中,同时支持多种数据源和数据输出方式。 以上是关于Spark大数据面试题的一些回答,希望能够对大家有所帮助。如果你想深入学习Spark和大数据处理技术,可以考虑参加相关的培训课程或在线课程。 ### 回答3: Spark是一个分布式计算框架,它可以使大规模数据处理更加高效和便捷。因此,在企业招聘大数据领域的人才时,对Spark的技术能力要求越来越高。以下是Spark面试题的回答: 1. Spark有哪些组件? Spark框架由三个核心组件组成:Spark Core、Spark SQL和Spark Streaming。此外,还有Spark MLlib、Spark GraphX、Spark R等个别不同的子组件。 2. 什么是RDD?与Dataframe有什么区别? RDD(弹性分布式数据集)是Spark的核心数据抽象,是不可变的分布式对象集合。RDD可以从文件中读取数据、从内存中读取数据、并行修改数据等。而Dataframe和RDD类似,但是Dataframe更加强大,因为它是带有结构化的RDD。Dataframe在处理大规模结构化数据时非常有效和便捷。 3. Spark如何处理缺失数据? Spark提供了两种处理缺失数据的方法:第一种是使用DataFrame API中的na函数,可以删除或替换缺失值;第二种是使用MLlib中的Imputer类,可以将缺失值替换为均值或中位数。 4. 什么是Spark的任务(task)? 一个任务是Spark作业中的最小执行单位。Spark集群上的作业被划分为多个任务,这些任务可以并行执行。 5. Spark的shuffle操作是什么?它为什么是昂贵的? Spark的shuffle操作是将一组数据重新分配到不同计算节点上的操作。Shuffle操作可能会导致大量数据的磁盘写入、网络传输和数据重组,这些都是非常昂贵的操作。因此,它在Spark集群中是一个相当昂贵的操作。 6. Spark中的Partition有什么作用? Partition是Spark中的数据划分单位。它可以将数据分成多个块并对每个块进行处理。Partition 可以提高 Spark 的并行度和运行效率,因为它可以将大规模数据分成多个小块,并在集群的多个计算节点上并行处理数据。 总而言之,Spark是大数据领域中使用最广泛的计算引擎之一,其技术理念和应用场景非常广泛。对于求职者而言,掌握 Spark 的基本概念和技术特点,提高对 Spark 的理解和应用能力,将有助于更好地处理和分析大规模数据集。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值