Le code que j'aurais aimé faire du premier coup.

Mon premier algo a fait fondre deux CPU en même temps, sur deux machines différentes, avec partage du travail à faire, pour pondre le résultat en pas loin de 40 minutes, avec PyPy.
Voici le second, celui qui fonctionne, qui prends moins d'un dixième de seconde pour résoudre tout le problème, et de façon assez élégante en plus, juste en exploitant le range() de Python.
C'est pour ça que dans l'algo présenté, j'utilise la même méthode pour les deux exercices, avec des range de un élément pour l'exercice 1, je n'ai pas codé ça dès le début.
Et non, je ne posterai pas mon premier algo, très bien pour l'exo 1, mais très crado pour le 2 ^{^}

Les données d'abord, je distingue les graines et le reste :

def seedranges(seeds):
 def __iter():
 while seeds:
 src = seeds.pop(0)
 dst = seeds.pop(0)
 yield range(src, src + dst)
 return __iter()
datas = [x.strip().split(" ") for x in sys.stdin]
seeds = [int(x) for x in datas.pop(0)[1:]]
# Exercice 1
values = [range(seed, seed + 1) for seed in seeds]
# Exercice 2
values = list(seedranges(seeds))

Les graines sont donc une liste de range().

Ensuite les transformations pour trouver les correspondances, on va avoir une classe avec deux listes : les range() source, et les opérations à appliquer sur chaque range, qui sont simplement un entier relatif à ajouter. Et puis les noms des éléments depuis et vers lesquels on transforme :

class Map():
 ranges = None
 operations = None
 def __init__(self, *ranges):
 self.ranges = []
 self.operations = []
 for dst, src, size in ranges:
 self.ranges.append(range(src, src + size))
 self.operations.append(dst - src)
def readmap(lines):
 ranges = None
 mapname = None
 for line in lines:
 if not line[0]:
 if mapname:
 yield mapname[0], mapname[2], Map(*ranges)
 ranges = None
 elif ranges is None:
 mapname = line[0].split("-") # ['seed', 'to', 'soil']
 ranges = []
 else:
 ranges.append(int(x) for x in line)
 yield mapname[0], mapname[2], Map(*ranges)
converters = {
 src: (dst, mapping)
 for src, dst, mapping in readmap(datas)
}

Pour les calculs en eux-même, la méthode qui fait le travail est ajoutée à Map(), et la résolution est assez simple au bout du compte.
On calcule tout simplement les superpositions de deux range() : on va avoir un range d'éléments non traité avant un range de transformation, un range d'éléments non traités après un range de transformation, et enfin un range transformé. On boucle sur toutes les opérations disponibles, en remettant dans le pot les range non traités (avant et après) et en retournant (yield est ton ami) les range traités.
On n'oublie pas à la fin de retourner tous les range ayant échappés aux transformations, car ils restent identiques selon l'énoncé.
Le code est vraiment simple grâce aux itérateurs, avec yield, on ne se fatigue pas à construire une liste, à tester des trucs : on a une donnée finale ? yield, et on continue, elle est envoyée, et on ne s'en occupe plus.
Et on utilise les propriétés des range(), au début je voulais faire des if élément in range_operation qui est immédiat, mais en fait on n'en a pas besoin. La seule subtilité c'est qu'un range est Vrai s'il contient en pratique des éléments, et Faux sinon, donc range(20, 10) c'est faux.
if before signifie donc simplement : si on a des éléments non traités avant.

class Map():
 [...]
 def __call__(self, sources):
 for i, r in enumerate(self.ranges):
 op = self.operations[i]
 new_sources = []
 while sources:
 src = sources.pop()
 before = range(src.start, min(src.stop, r.start))
 after = range(max(src.start, r.stop), src.stop)
 transformed = range(max(src.start, r.start) + op, min(src.stop, r.stop) + op)
 if before:
 new_sources.append(before)
 if after:
 new_sources.append(after)
 if transformed:
 yield transformed
 sources = new_sources
 for src in sources:
 yield src

Enfin le résolution se fait à l'identique pour les deux parties, avec la bonne valeur initiale pour values :

while src in converters:
 dst, converter = converters[src]
 # print(f"Converting from {src} to {dst}")
 values = list(converter(values))
 src = dst
print("Closest location is {}".format(
 min(v.start for v in values)
))

Pour info, faire les 7 moulinettes sur une liste de 850 millions d'éléments, même avec PyPy, ça prend dans les dix/quinze minutes, et je parle pas de la RAM.
Comme quoi ça peut valoir le coup de regarder les données à traiter pour savoir où on va se planter, avant de coder...
Cela dit, un algo non optimisé, même à 45 minutes de calcul réparti sur deux machines (j'aurais pu aller plus vite en parallélélisant sur les multiples proc des machines, un range initial par exécution, en moins de 15 minutes c'était plié), c'est plus rapide que de réinventer un algorithme, le coder, le valider.

• Yth.