#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;
}