Тера Инкогнита

import random as rr

lst1 = ['1', '2', '3']
lst2 = []

while lst1:
    idx = rr.randint(0, len(lst1)-1)
    lst2.append(lst1[idx])
    del lst1[idx]
    pass

print(lst1, lst2, sep = '\n')

# []
# ['2', '1', '3']

Раз у вас есть переменные и списки, берите код дейкстры из википедии, переведите его в эти ваши блоки, вот и ваша дейкстра.

Граф задается очень просто: введите систему координат - каждой вершине соответствует 2 числа - номер стороки (горизонтальная линия, где она находится) и номер в строке (какая она по порядку там). На нечетных строках будет n вершин, на четных - n-1.

В списках ребер для каждой вершины добавьте ребра влево и вправо (на (x, y+1) и (x, y-1)). Наклонные ребра надо по разному создавать для вершин с четным x и нечетным x. В первом случае это будут (x+-1, y-1), (x+-1, y); во втором - (x+-1, y), (x+-1, y+1);

Отключить целевой комп от интернета. А еще лучше - если уж такая паранойя - и из розетки выдернуть. По другому - никак.

Есть довольно простой и понятный алгоритм:
1) Становимся в начальную точку, смежную со входом.
2) Генерируем случайный тайл (г, -, +, т, ...) таким образом, чтобы у него был соединён вход и не блокирован (стенками лабиринта и других тайлов) хотя бы один выход.
3) Если такого выхода нет, генерируем новый тайл, чтобы был. Если всё равно нет, то переходим к пункту 5.
4) Перемещаемся к выходу текущего тайла. Теперь пустое место - это наша текущая точка.
5) Повторяем до тех пор, пока не упрёмся в тупик, т.е. не будет свободного выхода из текущего тайла.
6) Возвращаемся назад до первого ветвления и повторяем алгоритм.
7) Если опять тупики во всех ветках, то возвращаемся ещё дальше назад.
8) Если мы всё-таки вернулись ко входу в лабиринт, значит всё стираем и запускаем алгоритм по новой.

Пояснение
Код:

import math


def arg_min(T, S):
    amin = -1
    m = math.inf  # максимальное значение
    for i, t in enumerate(T):
        if t < m and i not in S:
            m = t
            amin = i

    return amin


D = ((0, 3, 1, 3, math.inf, math.inf),
     (3, 0, 4, math.inf, math.inf, math.inf),
     (1, 4, 0, math.inf, 7, 5),
     (3, math.inf, math.inf, 0, math.inf, 2),
     (math.inf, math.inf, 7, math.inf, 0, 4),
     (math.inf, math.inf, 5, 2, 4, 0))

N = len(D)  # число вершин в графе
T = [math.inf]*N   # последняя строка таблицы

v = 0       # стартовая вершина (нумерация с нуля)
S = {v}     # просмотренные вершины
T[v] = 0    # нулевой вес для стартовой вершины
M = [0]*N   # оптимальные связи между вершинами

while v != -1:          # цикл, пока не просмотрим все вершины
    for j, dw in enumerate(D[v]):   # перебираем все связанные вершины с вершиной v
        if j not in S:           # если вершина еще не просмотрена
            w = T[v] + dw
            if w < T[j]:
                T[j] = w
                M[j] = v        # связываем вершину j с вершиной v

    v = arg_min(T, S)            # выбираем следующий узел с наименьшим весом
    if v >= 0:                    # выбрана очередная вершина
        S.add(v)                 # добавляем новую вершину в рассмотрение

#print(T, M, sep="\n")

# формирование оптимального маршрута:
start = 0
end = 4
P = [end]
while end != start:
    end = M[P[-1]]
    P.append(end)

print(P)