strategy_1.cpp

银行排队的数学模型的实现 问题： n银行有n个窗口对外营业

//////////////////////////////////////////////////////////////////////////
// 策略一
// 三个策略的算法相差不大，尤其是输入输出函数
//

#include <fstream.h>

#include "strategy_1.h"

Service_Window_1::Service_Window_1()
{
	m_nClient_num = 0;
}

Strategy_1::Strategy_1()																		// 构造函数，将所需数据初始化
{
	m_pWindows = NULL;
	m_nWindow_num = 0;
	m_nWait_time = 0;
	m_Flag_inputed = FALSE;
	m_Flag_simulated = FALSE;
	m_nClient_num = 0;
	m_nTime = 0;

}

Strategy_1::~Strategy_1()																		// 析构函数，归还所申请的内存
{
	for (int i=0; i<m_nWindow_num; i++)
	{
		m_pWindows[i].m_Client_que.Free();
	}
	SAFEDELETES(m_pWindows);
}
int		Strategy_1::Initial()																	// 初始化数据
{
	SAFEDELETES(m_pWindows);
	m_pWindows = NULL;
	m_nWindow_num = 0;
	m_nWait_time = 0;
	m_Flag_inputed = FALSE;
	m_Flag_simulated = FALSE;
	m_nClient_num = 0;
	m_nTime = 0;
	m_Client.Free();
	return TRUE;
}

int		Strategy_1::Input_Queue()																// 从文件输入队列
{
	Initial();
	fstream	input_client;
	input_client.open("custom.txt", ios::in);
	if (!input_client)
	{
		cout << "Warning: File custom.txt can't open!";
		return FALSE;
	}
	input_client >> m_nWindow_num >> m_nClient_num;
	m_pWindows = new Service_Window_1[m_nWindow_num];
	int	narrive_time, ndeal_time;
	for (int i=0; i<m_nClient_num; i++)
	{
		input_client >> narrive_time >> ndeal_time;
		m_Client.Join_Queue(narrive_time, ndeal_time);
	}
	input_client.close();
	m_Flag_inputed = TRUE;
	return TRUE;
}

int		Strategy_1::Simulation()																// strategy_1 的模拟过程
{
	if (!m_Flag_inputed)
	{
		cout << "Input the data first" << endl;
		return FALSE;
	}
	int		busy_window, nindex = 0;
	m_nTime = 0;
	fstream		output_simulation;
	output_simulation.open("strategy_simulation_1.txt", ios::out);
	if (!output_simulation)
	{
		cout << "Warning: File strategy_simulation_1.txt can't build!";
		return FALSE;
	}
	output_simulation << "NOTE: (arrive time, deal time)" << endl <<"----------------------------------------------------" << endl;
	output_simulation.close();

	do 
	{		
		busy_window = 0;
		int	flag_output = FALSE;																// 用来判断处理情况是否改变，是否应该再次输出模拟的过程
		for (int i=0; i<m_nWindow_num; i++)                                                     // 判断是否有顾客在等待，并算出这一分钟内顾客总的等待世界
		{
			if (m_pWindows[i].m_nClient_num>1)
			{
				m_nWait_time += m_pWindows[i].m_nClient_num-1;
			}
		}
		while (m_Client.m_pHead && m_Client.m_pHead->m_nArrive_Time==m_nTime)					// 当有顾客要进入银行时，此顾客将前往人数最少的窗口
		{
			flag_output = TRUE;
			for (int i=0; i<m_nWindow_num; i++)
			{
				if (m_pWindows[i].m_nClient_num<m_pWindows[nindex].m_nClient_num)
				{
					nindex = i;
				}
			}
			Client*	ptemp;
			ptemp = m_Client.m_pHead;
			m_Client.m_pHead = m_Client.m_pHead->m_pNext;
			if (m_Client.m_pHead)
			{
				m_Client.m_pHead->m_pPrev = NULL;
			}
			else
			{
				m_Client.m_pHead = m_Client.m_pRear = NULL;
			}
			m_pWindows[nindex].m_Client_que.Push_Client(ptemp);	
			m_pWindows[nindex].m_nClient_num++;
			if (m_pWindows[nindex].m_nClient_num==1)											//假如此窗口人数只有一个（包括此顾客），则这个顾客立即开始办理业务
			{
				m_pWindows[nindex].m_Client_que.m_pHead->m_nBegin_deal_time = m_nTime;
			}	
			nindex = 0;
		}
		
		for (int j=0; j<m_nWindow_num; j++)
		{
			if (m_pWindows[j].m_Client_que.m_pHead && m_pWindows[j].m_Client_que.m_pHead->m_nBegin_deal_time+m_pWindows[j].m_Client_que.m_pHead->m_nDeal_Time<=m_nTime)
			{
				flag_output = TRUE;
				m_pWindows[j].m_Client_que.Quit_Queue();
				if (m_pWindows[j].m_Client_que.m_pHead)
				{
					m_pWindows[j].m_Client_que.m_pHead->m_nBegin_deal_time = m_nTime;
				}
				m_pWindows[j].m_nClient_num--;
			}
		}
		for (int k=0; k<m_nWindow_num; k++)
		{
			if (m_pWindows[k].m_nClient_num>1)
			{
				busy_window++;
			}
		}
		if (flag_output)
		{
			Output_Simulation();
		}
		m_nTime++;
	} while(busy_window!=0 || m_Client.m_pHead);
	m_Flag_simulated = TRUE;
	return	TRUE;
}

int		Strategy_1::Output_Result()																				// 将模拟结果输出
{	
	if (!m_Flag_inputed)
	{
		cout << "Input the data first" << endl;
		return FALSE;
	}
	if (!m_Flag_simulated)
	{
		cout << "Simulate first" << endl;
		return FALSE;
	}
	fstream		output_client;
	output_client.open("strategy_1.txt", ios::out);
	if (!output_client)
	{
		cout << "Warning: File strategy_1.txt can't build!";
		return FALSE;
	}
	output_client << "strategy 1:" << endl;
	cout << "strategy 1:" << endl;
	output_client << "service windows number: " << m_nWindow_num << endl;
	cout << "service windows number: " << m_nWindow_num << endl;
	output_client << "client number: " << m_nClient_num << endl;
	cout << "client number: " << m_nClient_num << endl;
	output_client << "average wait time: " << (double)m_nWait_time/m_nClient_num << endl; 
	cout << "average wait time: " << (double)m_nWait_time/m_nClient_num << endl << endl; 
	output_client.close();
	return	TRUE;
}

int		Strategy_1::Output_Simulation()																	// 将模拟过程输出
{
	fstream	output_simulation;
	output_simulation.open("strategy_simulation_1.txt", ios::app);
	if (!output_simulation)
	{
		cout << "Warning: File strategy_simulation_1.txt can't build!";
		return FALSE;
	}
	output_simulation << "TIME NOW: " << m_nTime << endl;
	for (int i=0; i<m_nWindow_num; i++)
	{
		Client*		ptemp;
		int			j;
		j = 0;
		output_simulation << "window " << i+1 << ": ";
		ptemp = m_pWindows[i].m_Client_que.m_pHead;
		while (ptemp)
		{
			j++;
			output_simulation << "(" << ptemp->m_nArrive_Time << ", " << ptemp->m_nDeal_Time << ") ";
			if(j%10==0)
			{
				output_simulation << endl;
			}
			ptemp = ptemp->m_pNext;
		}
		output_simulation << endl;
	}
	output_simulation << endl;
	output_simulation << "----------------------------------------------------" << endl;
	output_simulation.close();
	return	TRUE;
}