Von Neumann Airport/인수

~cpp

// ������ 깔������ ������ ��������� ��������� ������ �����걸 ������������ ���각��������� ������������..
// ��������� ��������� ������ OOP��������� ������������ ������������������.
// 근��� ��� ��������� --; ��������� ������ ������ ���겠���
// ������������ ��������������� ��������� ���������.. ����������� 그��� map��� ���������������. map<int,int> ������ ���값��� traffic���, 값��� ���������������, ��������������� ������ ����� ��������� ������������.
// ����� ��� ����������� ���������--;

//Traffic��� 거��� ��������� ������고(data holder)��� ��������� ���고 ���������. C��� struct������ ���������.
//������ ������(intelligence)��� ��� ��� ���������거���, ������(responsibility)��� ��� ��� ��� ���������
//���거��� ��������� ����� ������ ������까 ���������. --JuNe

#include <iostream>
#include <fstream>
#include <vector>
#include <cmath>
#include <map>
using namespace std;

class Traffic;
class Airport;
class Admin;

class Traffic
{
private :
	int _departureGateNum;
	int _arrivalGateNum;
	int _passengerNum;

public :
	Traffic(int departureGateNum, int arrivalGateNum, int passengerNum) 
		: _departureGateNum(departureGateNum), _arrivalGateNum(arrivalGateNum), _passengerNum(passengerNum) {}

	int getPassengerNum() const
	{
		return _passengerNum;
	}

	int getDepartureGateNum() const
	{
		return _departureGateNum;
	}

	int getArrivalGateNum() const
	{
		return _arrivalGateNum;
	}
};

class Airport
{
private:
	enum { DISTANCE = 1 };
	vector<Traffic> _traffics;
	vector<int> _arrivalGateNums;
	vector<int> _departureGateNums;
	int _totalTraffic;
	int _numCity;

public :
	Airport(int numCity) : _numCity(numCity)
	{
		_arrivalGateNums.resize(_numCity);
		_departureGateNums.resize(_numCity);
	}

	void addTrafficData(const Traffic& traffic)
	{
		_traffics.push_back(traffic);
	}

	int getTrafficAmount(const Traffic& traffic) const
	{
		return traffic.getPassengerNum();
	}

	void eraseGateOrder() 
	{
		_arrivalGateNums.clear();
		_departureGateNums.clear();
	}

	int getDistance(const Traffic& traffic) const
	{
		int ar, dp;
		for(int i = 0 ; i < _departureGateNums.size(); ++i)
		{
			if( _departureGateNums[i] == traffic.getDepartureGateNum() )
			{
				dp = i;
				for(int j = 0 ; j < _arrivalGateNums.size(); ++j)
				{
					if( _arrivalGateNums[j] == traffic.getArrivalGateNum() )
					{				
						ar = j;
						break;
					}
				}
				break;		
			}
		}
		return DISTANCE + abs(ar-dp) * DISTANCE;
	}

	int getTotalTraffic()
	{
		int total = 0;
		for(int i = 0 ; i < _traffics.size() ; ++i)
			total += getDistance(_traffics[i]) * getTrafficAmount(_traffics[i]);
		_totalTraffic = total;
		return _totalTraffic;
	}

	void addArrivalGate(int num)
	{
		_arrivalGateNums.push_back(num);
	}

	void addDepartureGate(int num)
	{
		_departureGateNums.push_back(num);
	}
};

class Admin
{
private :
	map<int, int> _trafficAmountCollection;
public :
	Admin()
	{
		runProcess();
	}
	void runProcess()
	{
		ifstream fin("airport.in");

		while(1)
		{
			int numCity;
			fin >> numCity;
			if(!numCity)
				break;

			Airport airport(numCity);

			int departureNum, iterateNum, arrivalNum, trafficAmount;
			for(int i = 0 ; i < numCity ; ++i)
			{
				fin >> departureNum;
				fin >> iterateNum;

				for(int j = 0 ; j < iterateNum ; ++j)
				{
					fin >> arrivalNum;
					fin >> trafficAmount;
					
					Traffic traffic(arrivalNum, departureNum, trafficAmount);					
					airport.addTrafficData(traffic);
				}
			}

			int testCaseNum, gateNum, testCount = 0;
			
			cout << "ConfigurationtLoad" << endl;

			while(1)
			{
				fin >> testCaseNum;

				if(!testCaseNum)
					break;
				for(int i = 0 ; i < numCity ; ++i)
				{
					fin >> gateNum;			
					airport.addArrivalGate(gateNum);
				}

				for(int i = 0 ; i < numCity ; ++i)
				{
					fin >> gateNum;			
					airport.addDepartureGate(gateNum);
				}

				_trafficAmountCollection[airport.getTotalTraffic()] = testCaseNum;
				++testCount;

				airport.eraseGateOrder();
			}
						
			showTrafficAmount();
		}
	}
	void showTrafficAmount()
	{
		for(map<int, int>::iterator j = _trafficAmountCollection.begin() ; j != _trafficAmountCollection.end() ; ++j)
		{
			cout << "t" << j->second << "t" << j->first << endl;
		}

		_trafficAmountCollection.clear();
	}
};

int main()
{
	Admin gogo;
	return 0;
}