-----Indian National Olympiad in Informatics 2014-----
Nikhil’s slogan has won the contest conducted by Drongo Airlines and he is entitled to a free ticket between any two destinations served by the airline. All cities served by Drongo Airlines can be reached from each other by some sequence of connecting flights. Nikhil is allowed to take as many connecting flights as needed, but he must take the cheapest route between his chosen destinations.
Each direct flight between two cities has a fixed price. All pairs of cities connected by direct flights have flights in both directions and the price is the same in either direction. The price for a sequence of connecting flights is the sum of the prices of the direct flights along the route.
Nikhil has information about the cost of each direct flight. He would like to maximize the value of his prize, so he would like to choose a pair of cities on the network for which the cost of the cheapest route is as high as possible.
For instance, suppose the network consists of four cities {1, 2, 3, 4}, connected as shown on the right.
In this case, Nikhil should choose to travel between 1 and 4, where the cheapest route has cost 19. You can check that for all other pairs of cities, the cheapest route has a smaller cost. For instance, notice that though the direct flight from 1 to 3 costs 24, there is a cheaper route of cost 12 from 1 to 2 to 3.

-----Input Format:-----
- Line 1 : Two space-separated integers, C and F . C is the number of cities on the network, numbered 1, 2, . . . , C. F is the number of pairs of cities connected by a direct flight
- Lines 2 to F + 1 : Each line describes one direct flight between a pair of cities and consists of three integers, x, y and p, where x and y are the two cities connected by this flight and p is the price of this
For all direct flights, $x \neq y$, and no pair of cities is connected by more than one direct flight. If there is a direct flight from x to y with price p, there is also a flight from y to x with price p and exactly one of these two will be listed.

-----Output Format-----
- The output consists of a single integer, the maximum cost among the cheapest routes between all pairs of cities across the airline’s network.

-----Test Data-----
The testdata is grouped into three subtasks. In all subtasks, 2 ≤ C ≤ 230 and 1 ≤ F ≤ 23665. In addition, each subtask has the following constraints on the inputs.
- Subtask 1 (20 marks) : F = C − 1 (that is, the airline network is a tree) and p = 1 for each direct flight.
- Subtask 2 (30 marks) : There is no constraint on the shape of the network, but for each direct flight, p = 1.
- Subtask 3 (50 marks) : There is no constraint on the shape of the network, but for each direct flight, 0 ≤ p ≤ $10^5$.

-----Sample Input-----
4 5
1 2 10
1 3 24
2 3 2
2 4 15
3 4 7

-----Sample Output-----
19

Note: Your program should not print anything other than what is specified in the output format. Please remove all diagnostic print statements before making your final submission. A program with extraneous output will be treated as incorrect!

Difficulty: UNKNOWN_DIFFICULTY

Starter code:

Solutions:
(c, f) = list(map(int, input().split()))
l = [[1000001 for i in range(c)] for j in range(c)]
while f:
	(x, y, cost) = list(map(int, input().split()))
	l[x - 1][y - 1] = cost
	l[y - 1][x - 1] = cost
	f -= 1
for i in range(c):
	l[i][i] = 0
for k in range(c):
	for x in range(c):
		for y in range(c):
			if x == k or y == k or x == y:
				continue
			elif x != y:
				l[x][y] = min(l[x][y], l[x][k] + l[k][y])
m = -1
for i in range(c):
	for j in range(c):
		if m < l[i][j]:
			m = l[i][j]
print(m)


I = int(1e+16)
(c, f) = [int(i) for i in input().split()]
arr = [[0 for i in range(c)] for j in range(c)]
sdc = []
for x in range(f):
	sdc.append(list((int(x) for x in input().split())))
for i in sdc:
	arr[i[0] - 1][i[1] - 1] = i[2]
	arr[i[1] - 1][i[0] - 1] = i[2]
for x in range(c):
	for y in range(c):
		if x != y:
			if arr[x][y] == 0:
				arr[x][y] = I

def f_w(v, arr):
	for k in range(0, v):
		for i in range(0, v):
			for j in range(0, v):
				arr[i][j] = min(arr[i][j], arr[i][k] + arr[k][j])
f_w(c, arr)
m = -1
for x in range(c):
	m = max(m, max(arr[x]))
print(m)


(c, f) = list(map(int, input().split()))
l = [[10000 for i in range(c)] for j in range(c)]
while f:
	(x, y, cost) = list(map(int, input().split()))
	l[x - 1][y - 1] = cost
	l[y - 1][x - 1] = cost
	f -= 1
for k in range(c):
	for x in range(c):
		for y in range(c):
			if x != y:
				l[x][y] = min(l[x][y], l[x][k] + l[k][y])
			else:
				l[x][y] = 0
m = -1
for i in range(c):
	for j in range(c):
		if m < l[i][j]:
			m = l[i][j]
print(m)


(c, n) = input().split()
(c, n) = (int(c), int(n))
a = []
for i in range(c):
	a.append([1000000] * c)
while n > 0:
	n -= 1
	(x, y, p) = input().split()
	(x, y, p) = (int(x) - 1, int(y) - 1, int(p))
	a[x][y] = a[y][x] = p
for k in range(c):
	for i in range(c):
		for j in range(c):
			if a[i][k] + a[k][j] < a[i][j]:
				a[i][j] = a[i][k] + a[k][j]
mx = 0
for i in range(c):
	for j in range(c):
		if i != j and mx < a[i][j]:
			mx = a[i][j]
print(mx)


import numpy as np
import sys
import heapq

def eccentricities(graph, vertices):
	ecc = []
	dist = floyd_warshall(graph, vertices)
	for u in dist:
		d = [dist[u][v] for v in dist[u] if dist[u][v] != INFINITY]
		if d:
			ecc.append(max(d))
	return ecc

def floyd_warshall(graph, vertices):
	dist = {}
	for u in vertices:
		dist[u] = {}
		for v in vertices:
			dist[u][v] = INFINITY
	for u in graph:
		dist[u][u] = 0
		for v in graph[u]:
			dist[u][v[0]] = v[1]
	for k in vertices:
		for i in vertices:
			for j in vertices:
				dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
	return dist
(n, e) = list(map(int, input().split()))
graph = {}
for _ in range(e):
	(u, v, w) = list(map(int, input().split()))
	u -= 1
	v -= 1
	if u in graph:
		graph[u] += [[v, w]]
	else:
		graph[u] = [[v, w]]
	if v in graph:
		graph[v] += [[u, w]]
	else:
		graph[v] = [[u, w]]
vertices = list(range(n))
INFINITY = 10 ** 9
ecc = eccentricities(graph, vertices)
radius = min(ecc)
diameter = max(ecc)
print(diameter)


MAX = 10 ** 9
(c, f) = list(map(int, input().split()))
d = []
for i in range(c):
	d.append([-1 for j in range(c)])
for i in range(f):
	(x, y, p) = list(map(int, input().split()))
	d[x - 1][y - 1] = p
	d[y - 1][x - 1] = p
for i in range(c):
	for j in range(c):
		if i == j:
			d[i][j] = 0
		elif d[i][j] == -1:
			d[i][j] = MAX
for k in range(c):
	for i in range(c):
		for j in range(c):
			d[i][j] = min(d[i][j], d[i][k] + d[k][j])
p = 0
for i in range(c):
	for j in range(c):
		p = max(d[i][j], p)
print(p)


MAX = 999999
(c, f) = list(map(int, input().split()))
d = []
for i in range(c):
	d.append([-1 for j in range(c)])
for i in range(f):
	(x, y, p) = list(map(int, input().split()))
	d[x - 1][y - 1] = p
	d[y - 1][x - 1] = p
for i in range(c):
	for j in range(c):
		if i == j:
			d[i][j] = 0
		elif d[i][j] == -1:
			d[i][j] = MAX
for w in range(c):
	for i in range(c):
		for j in range(c):
			d[i][j] = min(d[i][j], d[i][w] + d[w][j])
p = 0
for i in range(c):
	for j in range(c):
		p = max(d[i][j], p)
print(p)


try:
	MAX = 10 ** 9
	(a, b) = list(map(int, input().split()))
	c = []
	for i in range(a):
		c.append([-1 for j in range(a)])
	for j in range(b):
		(d, e, p) = [int(i) for i in input().split()]
		c[d - 1][e - 1] = p
		c[e - 1][d - 1] = p
	for i in range(a):
		for j in range(a):
			if i == j:
				c[i][j] = 0
			elif c[i][j] == -1:
				c[i][j] = MAX
	for k in range(a):
		for i in range(a):
			for j in range(a):
				c[i][j] = min(c[i][j], c[i][k] + c[k][j])
	p = 0
	for i in range(a):
		for j in range(a):
			p = max(c[i][j], p)
	print(p)
except Exception:
	pass


(c, f) = map(int, input().split())
dist = [[float('Inf') for _ in range(c)] for _ in range(c)]
for _ in range(f):
	(u, v, p) = map(int, input().split())
	u -= 1
	v -= 1
	dist[u][v] = p
	dist[v][u] = p
for i in range(c):
	dist[i][i] = 0
for k in range(c):
	for i in range(c):
		for j in range(c):
			if dist[i][j] > dist[i][k] + dist[k][j]:
				dist[i][j] = dist[i][k] + dist[k][j]
massimo = 0
for i in range(c):
	massimo = max(massimo, max(dist[i]))
print(massimo)


a = input().split()
(c, f) = (int(a[0]), int(a[1]))
mindistance = [[float('inf') for i in range(c)] for i in range(c)]
for corner in range(c):
	mindistance[corner][corner] = 0
for i in range(f):
	a = input().split()
	(x, y, p) = (int(a[0]) - 1, int(a[1]) - 1, int(a[2]))
	mindistance[x][y] = p
	mindistance[y][x] = p
for i in range(c):
	for j in range(c):
		for k in range(c):
			if mindistance[i][k] != float('inf') and mindistance[j][i] != float('inf'):
				if mindistance[j][k] > mindistance[j][i] + mindistance[i][k]:
					mindistance[j][k] = mindistance[j][i] + mindistance[i][k]
mincost = -float('inf')
for i in mindistance:
	if mincost < max(i):
		mincost = max(i)
print(mincost)


def floyd_warshall(graph, N):
	dist = [[float('inf')] * (N + 1) for i in range(N + 1)]
	for u in graph:
		dist[u][u] = 0
		for v in graph[u]:
			dist[u][v] = graph[u][v]
	for k in range(1, N + 1):
		for i in range(1, N + 1):
			for j in range(1, N + 1):
				dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
	return dist

def solve(C, F, cost):
	dist = floyd_warshall(cost, C)
	maximum = 0
	for i in range(1, C + 1):
		for j in range(1, C + 1):
			maximum = max(maximum, dist[i][j])
	return maximum

def __starting_point():
	(C, F) = list(map(int, input().strip().split()))
	cost = {i: {} for i in range(1, C + 1)}
	for flight in range(1, F + 1):
		(x, y, p) = list(map(int, input().strip().split()))
		cost[x][y] = p
		cost[y][x] = p
	print(solve(C, F, cost))
__starting_point()