微软的一道面试题

有两个范围在1至100以内的整数，甲知道这两个数的和，乙知道这两个数的积。
以下是甲和乙的一段对话，旁边还有A、B、C、D四个听众。 
甲说：“我只知道这两个数的和，我不知道这两个数是什么。”
乙说：“我知道你不知道这两个数是什么，我也不知道这两个数是什么。”
听到这，甲说：“哈，那我现在知道这两个数是什么了。”
乙也说：“现在我也知道这两个数是什么了。”
这时，旁边的四个听众也说：“我们也知道这两个数是什么了。” 
问：这两个数是多少？

首先对题目从数学角度分析一下不难得出:
这两个数一定不是孪生数(两数互质)如果是孪生数那么乙一定知道这两个数是什么,这一点是最基础的.
其次从逻辑关系上分析会得到以下几点疑问:
1.为什么甲开始不知道两个数是什么?
2.为什么乙也不知道这两个数是什么?
3.为什么乙就一定知道甲不知道这两个数是什么?
4.为什么甲听完乙说的话就知道了这两个数是什么?
5.当甲知道后乙也知道了?
6.为什么听众听完对话也知道了答案?

对问题1分析:
 	这个很简单,因为甲根据两数和所得出的组合太多所以他不知道是哪种组合.

对问题2分析:
 	乙开始时根据两数的积也不能判断出是哪种组合(这点也是这两个数一定不是孪生数的理由).

对问题3分析:
 	乙感肯定甲不知道这两个数是什么,意味着,乙通过两数积枚举了所有可能性,并且站在甲的角度
上分析一下得出,这些枚举的值对于甲来说也面临着多种选择,所以乙断言甲不知道这两个数是什么.

对问题4分析:
 	甲听完后知道了两个数,这点是最关键的,甲虽然面年着多种选择(一般情况下,要比乙多),但是,
甲通多这些枚举也肯定分析了乙,那么在什么情况下,甲能判断出结果?
 	首先,分析一下甲枚举的结果,可以分成两种类型的结果:
 	(A) (a1,b1)甲拿这两个数和(a1+b1),并且通过(a1+b1)可判断出乙只有一种可能(a1*b1)
 	(B) (a2,b2)甲拿这两个数和(a2+b2),并且通过(a2+b2)可判断出乙有多种可能(a2*b2)或
(a3*b3)或(a4*b4)等等.
 	甲答案的集合一定是上述两种元素构成,只有在一种情况下通过乙的话才可以判断出答案,就是设

甲的所有可能答案集为(a1,a2,...,an)ai属于{A,B},则只有一个元素ai属于{B},其余元素都属于{A}时

甲才能通过乙自己也不知道两个数来排除其他元素只留下ai,这时候甲就得到了唯一答案.

对问题5分析:
 	当甲得到答案后,乙也得到了答案,推理过程和甲差不多

对问题6分析:
 	呵呵,听众就是你,我,他,现在我们也知道了答案

原码如下:
#define OK 1;
#define ERROR 0;
typedef int Status;
typedef int ElemType;
typedef struct QueueNode
{
	ElemType data[2];
	struct QueueNode *next;
}*QNode;

typedef struct
{
	QNode rear;
 	int length;
}SqQueue;

Status InitQueue(SqQueue &Q)
{
 	Q.rear=new QueueNode;
 	if(!Q.rear) return ERROR;
 	Q.rear->data[0]=NULL;
 	Q.rear->data[1]=NULL;
 	Q.rear->next=Q.rear;
 	Q.length=0;
 	return OK;
}

Status DelQueue(SqQueue &Q)
{
 	QNode MyTemp,temp;
 	if(Q.length<=1) return OK;
 	MyTemp=Q.rear->next;
 	while(MyTemp)
 	{
  		temp=MyTemp;
  		MyTemp=MyTemp->next;
  		delete temp;
 	}
 	return OK;
}

Status EnQueue(SqQueue &Q,ElemType *e)
{
 	QNode p;
 	if(!Q.rear->data[0] && !Q.rear->data[1] )
 	{
  		Q.rear->data[0]=e[0];
  		Q.rear->data[1]=e[1];
  		Q.length++;
  		return OK;
 	}
 	p=new QueueNode;
 	if(!p) return ERROR;
 	p->data[0]=e[0];
 	p->data[1]=e[1];
 	Q.length++;
 	p->next=Q.rear->next;
 	Q.rear->next=p;
 	Q.rear=p;
 	return OK;
}

void DeQueue(SqQueue &Q,ElemType *e)
{
 	QNode p;
 	if(Q.rear->next!=Q.rear)
 	{
  		p=Q.rear->next;
  		Q.rear->next=Q.rear->next->next;
  		e[0]=p->data[0];
  		e[1]=p->data[1];
  		delete p;
 	}
 	else
 	{
  		e[0]=Q.rear->data[0];
  		e[1]=Q.rear->data[1];
  		delete Q.rear;
  		Q.rear=NULL;
 	}
 	Q.length--;
}

int MyTell(ElemType x,ElemType y)
{
 	ElemType MyMul=x*y;
 	ElemType i=2;
 	ElemType D[2];
 	SqQueue MyLove;
 	Status result;
 	int MyEnd;

 	result=InitQueue(MyLove);
	while(i<=MyMul/2)
 	{
  		if(MyMul%i==0 && i<=MyMul/i)
  		{
   			D[0]=i;
   			D[1]=MyMul/i;
   			result=EnQueue(MyLove,D);
  		}
  		i++;
 	}
 	MyEnd=MyLove.length;
 	if(MyLove.length>=1)
 	{
  		//cout<<"/n当甲拿"<<x+y<<"("<<x<<"+"<<y<<")时，甲认为乙拿"<<x*y;
		//cout<<"并且认为此时乙判断这两个数有"<<MyLove.length<<"种可能";
  		while(MyLove.length>0)
  		{
   			DeQueue(MyLove,D);
   			//cout<<"/n"<<D[0]<<"*"<<D[1];
  		}
 	}
	result=DelQueue(MyLove);
 	return MyEnd;
}

Status MyBreak(ElemType x)
{
 	int MyYouQu;
 	int MyMask=0;
 	ElemType i=2;
 	for(i=2;i<=x/2;i++)
 	{
  		MyYouQu=MyTell(i,x-i);
  		if(MyYouQu==1) MyMask+=1;
  		else if(MyYouQu>1) MyMask+=2;
 	}
 	if(i==MyMask+1)
 	{
 		 cout<<"/n谢谢上帝，我找到了"<<i<<"+"<<x-i<<"=";
  		return OK;
 	}
 	return ERROR;
};

int main(int argc, char* argv[])
{
 	int x;
 	Status result;
 	for(x=2;x<100;x++)
 	{
  		result=MyBreak(x);
  		if(result==1) 
  		{
   			cout<<x;
   			//break;
  		}
 	}
 	return 0;
}

答案是3,4