Зациклить код

# Стартовая конфигурация преследователей
start = [3, 3, 3] 
 
# Последовательность ориентированных рёбер графа однозначно задаёт пошаговый поиск 
tr = [[3, 1], [3, 2], [3, 4], [1, 3], [2, 3], [3, 4], [3, 4], [4, 5], [4, 5], [4, 8], [5, 6], [5, 7], [6, 5], [7, 5], [5, 4], [5, 4], [4, 8], [4, 8], [8, 9], [8, 9], [9, 10], [9, 10], [10, 11], [11, 10], [10, 12], [12, 10], [10, 9], [10, 9], [9, 8], [8, 9], [9, 13], [9, 13], [13, 14], [13, 15], [14, 13], [15, 13], [13, 9], [13, 9], [9, 8], [9, 8], [8, 16], [8, 16], [8, 16], [16, 17], [16, 17], [17, 18], [17, 19], [18, 17], [17, 16], [16, 20], [16, 20], [20, 21], [20, 22]] 
 
# Вершины графа
V = list(range(1, 22 + 1)) 
 
# Рёбра графа
E = [[1, 3], [2, 3], [3, 4], [4, 5], [4, 8], [5, 6], [5, 7], [10, 11], [10, 12], [9, 10], [8, 9], [9, 13], [13, 14], [13, 15], [8, 16], [16, 17], [17, 18], [17, 19], [16, 20], [20, 21], [20, 22]]
 
# Программа
# Время поиска
T = len(tr) + 1
 
# Задаём ориентацию на рёбрах графа
def double(E):
  set = []
  for e in E:
    set.append(e)  
  for e in E:
    e0 = []
    e0.append(e[1])
    e0.append(e[0])
    set.append(e0)
  return set
 
# Убираем ориентацию с рёбер графа
def a_double(E):
  set = []
  for e in E: 
    e0 = [e[1], e[0]]
    if e0 not in set: 
      set.append(e)
  return set
 
# Пробел (в тексте)
def space(a):
  if 0 <= a < 10:
    return 2
  if 10 <= a < 100:
    return 1
  if 100 <= a:
    return 0 
 
# Убираем повторяющиеся элементы списка 
def factor(list):
  set = [] 
  for x in list: 
    if x not in set: 
      set.append(x) 
  return set 
 
# Подмножество другого множества
def subset(A, B):
  for x in A:
    if x in B:
      B.remove(x)
    else:
      return False 
  return True 
 
# Пересечение множеств
def cap(A, B):
  set = []
  for x in A:
    if x in B:
      set.append(x)
  return set
 
 
# Инцидентные рёбра
def U(v):
  set = []
  for e in E:
    if v in e:
      set.append(e)
  return set
  
# Проколотая рёберная окрестность
def U1(v, w):
  set = []
  for e in E:
    if v in e and e != w and e != [w[1], w[0]]:
      set.append(e)
  return set  
  
# Конфигурация преследователей
def F(t):
  set = []
  if t == 0:
    for n in start:
      set.append(n)
    return set
  if t > 0:
    for f in F(t - 1):
      set.append(f)
    set.append(tr[t - 1][1])
    set.remove(tr[t - 1][0])
    return set
 
# Второй случай: отнимаем рёбра
def minus(v0, config, set):
  end = [v0]
  while len(end) > 0:
    for v in end:
      if v in config or len(U(v)) == 1:
        end.remove(v)
      else:
        for e in cap(U(v), set):
          set.remove(e)
          e.remove(v)
          end.append(e[0])
        end.remove(v)
  return set
 
# Первый случай: добавляем одно ребро 
def plus(vec, set):
  if vec in E:
    set.append(vec)
  else:
    set.append([vec[1], vec[0]])
  return factor(set)
 
######################
######################
######################
######################
######################
######################
#Начало программы (она работает и работает правильно!)
 
E0 = []
print("0) " + str(E0))
print("")
 
E1 = E0
vect = tr[0] 
v0 = vect[0]
config = F(0)
config.remove(v0)
if v0 in config or subset(U1(v0, vect), double(E0)):
  E1 = plus(vect, E1)
else:
  E1 = minus(v0, config, E1)
print("1) " + str(E1))
print("")
 
E2 = E1
vect = tr[1]
v0 = vect[0]
config = F(1)
config.remove(v0)
if v0 in config or subset(U1(v0, vect), double(E1)):
  E2 = plus(vect, E2)
else:
  E2 = minus(v0, config, E2)
print("2) " + str(E2))
print("")
 
E3 = E2
vect = tr[2] 
v0 = vect[0]
config = F(2)
config.remove(v0)
if v0 in config or subset(U1(v0, vect), double(E2)):
  E3 = plus(vect, E3)
else:
  E3 = minus(v0, config, E3)
print("3) " + str(E3))
print("")
 
E4 = E3
vect = tr[3] 
v0 = vect[0]
config = F(3)
config.remove(v0)
if v0 in config or subset(U1(v0, vect), double(E3)):
  E4 = plus(vect, E4)
else:
  E4 = minus(v0, config, E4)
print("4) " + str(E4))
print("")
 
E5 = E4
vect = tr[4] 
v0 = vect[0]
config = F(4)
config.remove(v0)
if v0 in config or subset(U1(v0, vect), double(E4)):
  E5 = plus(vect, E5)
else:
  E5 = minus(v0, config, E5)
print("5) " + str(E5))
print("")
 
E6 = E5
vect = tr[5]
v0 = vect[0]
config = F(5)
config.remove(v0) 
if v0 in config or subset(U1(v0, vect), double(E5)):
  E6 = plus(vect, E6)
else:
  E6 = minus(v0, config, E6)
print("6) " + str(E6))
print("")
 
E7 = E6
vect = tr[6]
v0 = vect[0]
config = F(6)
config.remove(v0) 
if v0 in config or subset(U1(v0, vect), double(E6)):
  E7 = plus(vect, E7)
else:
  E7 = minus(v0, config, E7)
print("7) " + str(E7))
print("")
 
E8 = E7
vect = tr[7]
v0 = vect[0]
config = F(7)
config.remove(v0) 
if v0 in config or subset(U1(v0, vect), double(E7)):
  E8 = plus(vect, E8)
else:
  E8 = minus(v0, config, E8)
print("8) " + str(E8))
print("")
 
E9 = E8
vect = tr[8] 
v0 = vect[0]
config = F(8)
config.remove(v0)
if v0 in config or subset(U1(v0, vect), double(E8)):
  E9 = plus(vect, E9)
else:
  E9 = minus(v0, config, E9)
print("9) " + str(E9))
print("")
 
E10 = E9
vect = tr[9] 
v0 = vect[0]
config = F(9)
config.remove(v0)
if v0 in config or subset(U1(v0, vect), double(E9)):
  E10 = plus(vect, E10)
else:
  E10 = minus(v0, config, E10)
print("10) " + str(E10))
print("")
 
E11 = E10
vect = tr[10]
v0 = vect[0]
config = F(10)
config.remove(v0) 
if v0 in config or subset(U1(v0, vect), double(E10)):
  E11 = plus(vect, E11)
else:
  E11 = minus(v0, config, E11)
print("11) " + str(E11))
print("")
 
E12 = E11
vect = tr[11] 
v0 = vect[0]
config = F(11)
config.remove(v0)
if v0 in config or subset(U1(v0, vect), double(E11)):
  E12 = plus(vect, E12)
else:
  E12 = minus(v0, config, E12)
print("12) " + str(E12))
print("")
 
E13 = E12
vect = tr[12]
v0 = vect[0]
config = F(12)
config.remove(v0) 
if v0 in config or subset(U1(v0, vect), double(E12)):
  E13 = plus(vect, E13)
else:
  E13 = minus(v0, config, E13)
print("13) " + str(E13))
print("")
 
E14 = E13
vect = tr[13]
v0 = vect[0]
config = F(13)
config.remove(v0) 
if v0 in config or subset(U1(v0, vect), double(E13)):
  E14 = plus(vect, E14)
else:
  E14 = minus(v0, config, E14)
print("14) " + str(E14))
print("")
 
E15 = E14
vect = tr[14]
v0 = vect[0]
config = F(14)
config.remove(v0) 
if v0 in config or subset(U1(v0, vect), double(E14)):
  E15 = plus(vect, E15)
else:
  E15 = minus(v0, config, E15)
print("15) " + str(E15))
print("")
 
E16 = E15
vect = tr[15] 
v0 = vect[0]
config = F(15)
config.remove(v0)
if v0 in config or subset(U1(v0, vect), double(E15)):
  E16 = plus(vect, E16)
else:
  E16 = minus(v0, config, E16)
print("16) " + str(E16))
print("")
 
E17 = E16
vect = tr[16]
v0 = vect[0]
config = F(16)
config.remove(v0) 
if v0 in config or subset(U1(v0, vect), double(E16)):
  E17 = plus(vect, E17)
else:
  E17 = minus(v0, config, E17)
print("17) " + str(E17))
print("")
 
E18 = E17
vect = tr[17] 
v0 = vect[0]
config = F(17)
config.remove(v0)
if v0 in config or subset(U1(v0, vect), double(E17)):
  E18 = plus(vect, E18)
else:
  E18 = minus(v0, config, E18)
print("18) " + str(E18))
print("")
 
E19 = E18
vect = tr[18] 
v0 = vect[0]
config = F(18)
config.remove(v0)
if v0 in config or subset(U1(v0, vect), double(E18)):
  E19 = plus(vect, E19)
else:
  E19 = minus(v0, config, E19)
print("19) " + str(E19))
print("")
 
E20 = E19
vect = tr[19]
v0 = vect[0]
config = F(19)
config.remove(v0)
if v0 in config or subset(U1(v0, vect), double(E19)):
  E20 = plus(vect, E20)
else:
  E20 = minus(v0, config, E20)
print("20) " + str(E20))
print("")
 
E21 = E20
vect = tr[20]
v0 = vect[0] 
config = F(20)
config.remove(v0)
if v0 in config or subset(U1(v0, vect), double(E1)):
  E21 = plus(vect, E21)
else:
  E21 = minus(v0, config, E21)
print("21) " + str(E21))
print("")
 
E22 = E21
vect = tr[21]
v0 = vect[0]
config = F(21)
config.remove(v0) 
if v0 in config or subset(U1(v0, vect), double(E21)):
  E22 = plus(vect, E22)
else:
  E22 = minus(v0, config, E22)
print("22) " + str(E22))
print("")
 
E23 = E22
vect = tr[22] 
v0 = vect[0]
config = F(22)
config.remove(v0)
if v0 in config or subset(U1(v0, vect), double(E22)):
  E23 = plus(vect, E23)
else:
  E23 = minus(v0, config, E23)
print("23) " + str(E23))
print("")
 
E24 = E23
vect = tr[23]
v0 = vect[0]
config = F(23)
config.remove(v0) 
if v0 in config or subset(U1(v0, vect), double(E23)):
  E24 = plus(vect, E24)
else:
  E24 = minus(v0, config, E24)
print("24) " + str(E24))
print("")
 
E25 = E24
vect = tr[24] 
v0 = vect[0]
config = F(24)
config.remove(v0)
if v0 in config or subset(U1(v0, vect), double(E24)):
  E25 = plus(vect, E25)
else:
  E25 = minus(v0, config, E25)
print("25) " + str(E25))
print("")
 
#Конец программы
######################
######################
######################
######################
######################
######################
      
#Сократить программу, переведя всё на язык рекурсии, не получается.  
def S_e(t):
  if t == 0:
    return []   
  else:
    set = S_e(t - 1)
    vect = tr[t - 1]
    v0 = vect[0]
    config = F(t - 1)
    config.remove(v0)
    
    if v0 in config or subset(U1(v0, vect), double(set)):
      return plus(vect, set)
    else:
      return minus(v0, config, set) 
 
print("")
print("")
print("")
#С этого момента начинаются несоответствия (порядок элементов в паре не важен, но всё же)
print(S_e(21))
print("")
#Первый неправильный вывод
print(S_e(22))
print("")
#Дальше всё "снежным комом" 
print(S_e(23))