110903 The Tourist Guide

#include <map>
#include <vector>
#include <set>
#include <iostream>

using namespace std;

class TouristGuid
{
public:
	TouristGuid(int cities, int roads)
	{
		int city1, city2, capacity;
		m_cities.resize(cities);

		for (int i = 0; i < roads; ++i)
		{
			cin >> city1 >> city2 >> capacity;

			m_cities[city1 - 1].insert(pair<int, int>(city2 - 1, capacity));
			m_cities[city2 - 1].insert(pair<int, int>(city1 - 1, capacity));
		}

		cin >> m_startCity >> m_endCity >> m_peopleCnt;
		--m_startCity;
		--m_endCity;
		m_peopleCnt;
	}

	int GetMinTransferTimes()
	{
		int maxCapacity = GetMaxCapacity(m_cities, m_startCity, m_endCity);
		int times = m_peopleCnt / (maxCapacity - 1);
		if ((m_peopleCnt % (maxCapacity - 1)) > 0)
			++times;
		return times;
	}

private:
	static int Min(int a, int b)
	{
		return (a < b) ? a : b;
	}

	static int Max(int a, int b)
	{
		return (a > b) ? a : b;
	}

	static int GetMaxCapacity(
		vector< map<int, int> >& cities,
		int startCity, int endCity)
	{
		// A kind of Dijkstra SPF algorithm is used.
		set<int> processedCities;
		vector<int> fromStartToThisCityCapacities;
		vector<int> toProcessCities;
		size_t processedCnt = 0;

		fromStartToThisCityCapacities.resize(cities.size());
		for (size_t i = 0; i < fromStartToThisCityCapacities.size(); ++i)
			fromStartToThisCityCapacities[i] = -1;

		toProcessCities.push_back(startCity);
		processedCities.insert(startCity);

		while (processedCnt < toProcessCities.size())
		{
			int currentCity = toProcessCities[processedCnt];
			map<int, int>::iterator iter = cities[currentCity].begin();
			while (iter != cities[currentCity].end())
			{
				int neighborCity = iter->first;
				if (neighborCity == startCity)
				{
					++iter;
					continue;
				}
				int fromCurrentToNeighborCityCapacity = iter->second;

				if (currentCity == startCity)
					fromStartToThisCityCapacities[neighborCity] = fromCurrentToNeighborCityCapacity;
				else
				{

					int tmp = Min(fromStartToThisCityCapacities[neighborCity], fromCurrentToNeighborCityCapacity);
					if (tmp > fromStartToThisCityCapacities[currentCity])
						fromStartToThisCityCapacities[currentCity] = tmp;
					else
					{
						tmp = Min(fromStartToThisCityCapacities[currentCity], fromCurrentToNeighborCityCapacity);
						if (tmp > fromStartToThisCityCapacities[neighborCity])
							fromStartToThisCityCapacities[neighborCity] = tmp;
					}
				}

				if (processedCities.find(neighborCity) == processedCities.end())
				{
					processedCities.insert(neighborCity);
					toProcessCities.push_back(neighborCity);
				}

				++iter;
			}

			++processedCnt;
		}

		return fromStartToThisCityCapacities[endCity];
	}

private:
	vector< map<int, int> > m_cities;
	int m_startCity, m_endCity, m_peopleCnt;
};

static void Test()
{
	int cities, roads, cnt = 1;
	while (true)
	{
		cin >> cities >> roads;
		if ((cities <= 0) || (roads <= 0))
			return;

		TouristGuid guide(cities, roads);
		cout << "Scenario #" << cnt << endl;
		cout << "Minimum Number of Trips = " << guide.GetMinTransferTimes() << endl << endl;

		++cnt;
	}
}

int main(int argc, char* argv[])
{
	Test();
	return 0;
}