Buggy python submission (verdict: Time Limit Exceeded):
def dfs(g, last, vs, first):
    if vs:return min(g[last][v] + dfs(g, v, vs - {v}, first) for v in vs)
    else:return g[last][first]

from sys import stdin
from collections import defaultdict
from math import isinf

readline = stdin.readline

v, e = map(int, readline().split())
g = [[float('inf')] * v for _ in range(v)]
for _ in range(e):
    s, t, d = map(int, readline().split())
    g[s][t] = d

cost = []
vs = set(range(v))

first = 0
for second in range(1, v):
    if isinf(g[first][second]):continue
    cost.append(g[first][second] + dfs(g, second, vs - {first,second}, first))
        
ans = min(cost) if cost else -1
print(-1 if isinf(ans) else ans)

Fixed submission:
# http://www.geocities.jp/m_hiroi/light/pyalgo65.html

def memoize(f):
    table = {}
    def func(*args):
        if not args in table:
            table[args] = f(*args)
        return table[args]
    return func

@memoize
def tsp(p, v):
    if (1 << point_size) - 1 == v:
        return distance_table[p][0]
    else:
        return min(distance_table[p][x] + tsp(x, v | (1 << x)) for x in range(point_size) if not (v & (1 << x)))

from sys import stdin
from collections import defaultdict
from math import isinf

readline = stdin.readline

point_size, e = map(int, readline().split())
distance_table = [[float('inf')] * point_size for _ in range(point_size)]
for _ in range(e):
    s, t, d = map(int, readline().split())
    distance_table[s][t] = d
ans = tsp(0,1)
print(-1 if isinf(ans) else ans)

Buggy python submission (verdict: Time Limit Exceeded):
from sys import stdin
from math import isinf

readline = stdin.readline


min_cost = float('inf')


def main():
    v, e = map(int, readline().split())
    g = [[float('inf')] * v for _ in range(v)]
    for _ in range(e):
        s, t, d = map(int, readline().split())
        g[s][t] = d
    dfs(g, 0, 0, set(range(1, v)))
    global min_cost
    print(-1 if isinf(min_cost) else min_cost)


def dfs(g, cost, last, vs):
    global min_cost
    if min_cost < cost:
        return
    if vs:
        for v in vs:
            if isinf(g[last][v]):
                continue
            dfs(g, cost + g[last][v], v, vs - {v})
    elif min_cost > cost + g[last][0]:
        min_cost = cost + g[last][0]

main()

Fixed submission:
# http://www.geocities.jp/m_hiroi/light/pyalgo65.html

def memoize(f):
    table = {}
    def func(*args):
        if not args in table:
            table[args] = f(*args)
        return table[args]
    return func

@memoize
def tsp(p, v):
    if (1 << point_size) - 1 == v:
        return distance_table[p][0]
    else:
        return min(distance_table[p][x] + tsp(x, v | (1 << x)) for x in range(point_size) if not (v & (1 << x)))

from sys import stdin
from collections import defaultdict
from math import isinf

readline = stdin.readline

point_size, e = map(int, readline().split())
distance_table = [[float('inf')] * point_size for _ in range(point_size)]
for _ in range(e):
    s, t, d = map(int, readline().split())
    distance_table[s][t] = d
ans = tsp(0,1)
print(-1 if isinf(ans) else ans)

Buggy python submission (verdict: Time Limit Exceeded):
from sys import stdin
from collections import defaultdict
from math import isinf

readline = stdin.readline

def main():
    v, e = map(int, readline().split())
    g = [[float('inf')] * v for _ in range(v)]
    for _ in range(e):
        s, t, d = map(int, readline().split())
        g[s][t] = d
    from collections import deque
    min_cost = float('inf')

    que = deque()
    que.append((0, 0, set(range(1, v))))
    while que:
        cost, last, vs = que.pop()
        if min_cost < cost:
            continue
        if vs:
            que.extend((cost + g[last][v], v, vs - {v}) for v in vs)
        elif min_cost > cost + g[last][0]:
            min_cost = cost + g[last][0]

    print(-1 if isinf(min_cost) else min_cost)

main()

Fixed submission:
# http://www.geocities.jp/m_hiroi/light/pyalgo65.html

def memoize(f):
    table = {}
    def func(*args):
        if not args in table:
            table[args] = f(*args)
        return table[args]
    return func

@memoize
def tsp(p, v):
    if (1 << point_size) - 1 == v:
        return distance_table[p][0]
    else:
        return min(distance_table[p][x] + tsp(x, v | (1 << x)) for x in range(point_size) if not (v & (1 << x)))

from sys import stdin
from collections import defaultdict
from math import isinf

readline = stdin.readline

point_size, e = map(int, readline().split())
distance_table = [[float('inf')] * point_size for _ in range(point_size)]
for _ in range(e):
    s, t, d = map(int, readline().split())
    distance_table[s][t] = d
ans = tsp(0,1)
print(-1 if isinf(ans) else ans)

Buggy python submission (verdict: Time Limit Exceeded):
from sys import stdin
from collections import defaultdict
from math import isinf

readline = stdin.readline

min_cost = float('inf')

def main():
    v, e = map(int, readline().split())
    g = [[float('inf')] * v for _ in range(v)]
    for _ in range(e):
        s, t, d = map(int, readline().split())
        g[s][t] = d
    dfs(g, 0, 0, set(range(1, v)))
    global min_cost
    print(-1 if isinf(min_cost) else min_cost)


def dfs(g, cost, last, vs):
    global min_cost
    if min_cost < cost:
        return
    if vs:
        for v in vs:
            dfs(g, cost + g[last][v], v, vs - {v})
    elif min_cost > cost + g[last][0]:
        min_cost = cost + g[last][0]

main()

Fixed submission:
# http://www.geocities.jp/m_hiroi/light/pyalgo65.html

def memoize(f):
    table = {}
    def func(*args):
        if not args in table:
            table[args] = f(*args)
        return table[args]
    return func

@memoize
def tsp(p, v):
    if (1 << point_size) - 1 == v:
        return distance_table[p][0]
    else:
        return min(distance_table[p][x] + tsp(x, v | (1 << x)) for x in range(point_size) if not (v & (1 << x)))

from sys import stdin
from collections import defaultdict
from math import isinf

readline = stdin.readline

point_size, e = map(int, readline().split())
distance_table = [[float('inf')] * point_size for _ in range(point_size)]
for _ in range(e):
    s, t, d = map(int, readline().split())
    distance_table[s][t] = d
ans = tsp(0,1)
print(-1 if isinf(ans) else ans)

Buggy python submission (verdict: Time Limit Exceeded):
from sys import stdin
from collections import defaultdict
from math import isinf

readline = stdin.readline

min_cost = float('inf')

def main():
    v, e = map(int, readline().split())
    g = [[float('inf')] * v for _ in range(v)]
    for _ in range(e):
        s, t, d = map(int, readline().split())
        g[s][t] = d
    dfs(g, 0, 0, set(range(1, v)))
    global min_cost
    print(-1 if isinf(min_cost) else min_cost)


def dfs(g, cost, last, vs):
    global min_cost
    if min_cost <= cost:
        return
    if vs:
        for v in vs:
            dfs(g, cost + g[last][v], v, vs - {v})
    elif min_cost > cost + g[last][0]:
        min_cost = cost + g[last][0]

main()

Fixed submission:
# http://www.geocities.jp/m_hiroi/light/pyalgo65.html

def memoize(f):
    table = {}
    def func(*args):
        if not args in table:
            table[args] = f(*args)
        return table[args]
    return func

@memoize
def tsp(p, v):
    if (1 << point_size) - 1 == v:
        return distance_table[p][0]
    else:
        return min(distance_table[p][x] + tsp(x, v | (1 << x)) for x in range(point_size) if not (v & (1 << x)))

from sys import stdin
from collections import defaultdict
from math import isinf

readline = stdin.readline

point_size, e = map(int, readline().split())
distance_table = [[float('inf')] * point_size for _ in range(point_size)]
for _ in range(e):
    s, t, d = map(int, readline().split())
    distance_table[s][t] = d
ans = tsp(0,1)
print(-1 if isinf(ans) else ans)

Buggy python submission (verdict: Time Limit Exceeded):
from sys import stdin
from collections import defaultdict
from math import isinf

readline = stdin.readline

from collections import deque

def main():
    v, e = map(int, readline().split())
    g = [[float('inf')] * v for _ in range(v)]
    for _ in range(e):
        s, t, d = map(int, readline().split())
        g[s][t] = d
    min_cost = float('inf')

    que = deque([(0, 0, set(range(1, v)))])
    while que:
        cost, last, vs = que.pop()
        if min_cost <= cost:continue
        if vs:que.extend((cost + g[last][v], v, vs - {v}) for v in vs)
        elif min_cost > cost + g[last][0]:min_cost = cost + g[last][0]

    print(-1 if isinf(min_cost) else min_cost)

main()

Fixed submission:
# http://www.geocities.jp/m_hiroi/light/pyalgo65.html

def memoize(f):
    table = {}
    def func(*args):
        if not args in table:
            table[args] = f(*args)
        return table[args]
    return func

@memoize
def tsp(p, v):
    if (1 << point_size) - 1 == v:
        return distance_table[p][0]
    else:
        return min(distance_table[p][x] + tsp(x, v | (1 << x)) for x in range(point_size) if not (v & (1 << x)))

from sys import stdin
from collections import defaultdict
from math import isinf

readline = stdin.readline

point_size, e = map(int, readline().split())
distance_table = [[float('inf')] * point_size for _ in range(point_size)]
for _ in range(e):
    s, t, d = map(int, readline().split())
    distance_table[s][t] = d
ans = tsp(0,1)
print(-1 if isinf(ans) else ans)

Buggy python submission (verdict: Time Limit Exceeded):
from sys import stdin
from collections import defaultdict
from math import isinf

readline = stdin.readline

min_cost = float('inf')

def main():
    v, e = map(int, readline().split())
    g = [[float('inf')] * v for _ in range(v)]
    for _ in range(e):
        s, t, d = map(int, readline().split())
        g[s][t] = d
    dfs(g, 0, 0, set(range(1, v)))
    global min_cost
    print(-1 if isinf(min_cost) else min_cost)


def dfs(g, cost, last, vs):
    global min_cost
    if min_cost <= cost:return
    if vs:
        for v in vs:dfs(g, cost + g[last][v], v, vs - {v})
    elif min_cost > cost + g[last][0]:min_cost = cost + g[last][0]

main()

Fixed submission:
# http://www.geocities.jp/m_hiroi/light/pyalgo65.html

def memoize(f):
    table = {}
    def func(*args):
        if not args in table:
            table[args] = f(*args)
        return table[args]
    return func

@memoize
def tsp(p, v):
    if (1 << point_size) - 1 == v:
        return distance_table[p][0]
    else:
        return min(distance_table[p][x] + tsp(x, v | (1 << x)) for x in range(point_size) if not (v & (1 << x)))

from sys import stdin
from collections import defaultdict
from math import isinf

readline = stdin.readline

point_size, e = map(int, readline().split())
distance_table = [[float('inf')] * point_size for _ in range(point_size)]
for _ in range(e):
    s, t, d = map(int, readline().split())
    distance_table[s][t] = d
ans = tsp(0,1)
print(-1 if isinf(ans) else ans)