Reibello AoC 11

#aoc_2016_11
import copy
import collections

input_file_object = open("aoc_2016_input_11.txt")
input_as_string = input_file_object.read()
input_file_object.close()
input_by_line = input_as_string.split('\n')

floor1a = ['v','A','a']
floor1b = ['v','A','a','F','f','G','g']
floor2 = ['B','C','D','E']
floor3 = ['b','c','d','e']
floor4 = []
moves = 0
floors = [floor1b, floor2, floor3, floor4]

initial_state = [floors, moves]
'''
[
  [
   [f1],[],[],[]
  ],
   0
]
'''

#goal = ',,,ABCDEabcdev,'
goal = ',,,ABCDEFGabcdefgv,'
seen = {}
queue = collections.deque([])

test_state = [[[], ['B', 'C', 'D', 'E', 'a'], ['b', 'c', 'd', 'e', 'A', 'v'], []]]

'''def is_new(current):
    #current = queue[0] = [state,moves]
    c_state = current[0]
    c_moves = current[1]
    n_state = copy.deepcopy(current[0])
    for x in range(len(n_state)):
        n_state[x] = sorted(n_state[x])
    if n_state == goal:
        print(n_state, c_moves)
        return (n_state, c_moves)
    for pair in seen:
        if pair[0] == n_state:
            return False
    else:
        seen.append((n_state,c_moves))
        return True'''

def is_new(current):
    c_state = current[0]
    c_moves = current[1]
    n_state = copy.deepcopy(current[0])
    for x in range(len(n_state)):
        n_state[x] = sorted(n_state[x])
    temp = ''
    for x in range(len(n_state)):
        #print(n_state[x])
        temp += ''.join(n_state[x])
        temp += ','
    if temp == goal:
        print(temp, c_moves)
    if temp in seen:
        return False
    else:
        seen[temp] = True
        return True


def is_valid(current):
    #current = queue[0]
    #c_state = queue[0][0]
    c_state = current[0]

    for floor in c_state:
        if len(floor) == 1 and floor[0] == 'v':
            return False
        for chip in 'abcdefg':
            if chip in floor:
                #print('floor=',floor)
                #print('chip=',chip)
                if chip.upper() not in floor:
                    for thing in floor:
                        if thing.isupper():
                            return False
    else:
        #print(c_state)
        return True



def expand_queue(current, stack):
    c_state = current[0]
    c_moves = current[1]

    for i in range(len(c_state)):

        if 'v' in c_state[i] and len(c_state[i]) > 1:
            for item_one in c_state[i]:
                if item_one != 'v':
                    #print(c_state)
                    #print(item_one)
                ######################################################
                    if i != 3:#as long as this isn't the top floor
                        u_state = copy.deepcopy(c_state)

                        u_state[i+1].append(item_one)
                        u_state[i].remove(item_one)
                        u_state[i+1].append('v')
                        u_state[i].remove('v')

                        if is_valid([u_state, c_moves +1]) and is_new([u_state, c_moves+1]):
                            queue.append([u_state, c_moves + 1])

                        for item_two in c_state[i]:
                            if item_two != 'v' and item_two != item_one:

                                uu_state = copy.deepcopy(u_state)
                                uu_state[i+1].append(item_two)
                                uu_state[i].remove(item_two)

                                if is_valid([uu_state, c_moves +1]) and is_new([uu_state, c_moves+1]):
                                    queue.append([uu_state, c_moves + 1])

                #########################################################
                    if i != 0:#as long as this isn't the bottom floor
                        d_state = copy.deepcopy(c_state)

                        d_state[i-1].append(item_one)
                        d_state[i].remove(item_one)
                        d_state[i-1].append('v')
                        d_state[i].remove('v')

                        if is_valid([d_state, c_moves +1]) and is_new([d_state, c_moves+1]):
                            queue.append([d_state, c_moves + 1])


                        for item_two in c_state[i]:
                            if item_two != 'v' and item_two != item_one:

                                dd_state = copy.deepcopy(d_state)
                                dd_state[i-1].append(item_two)
                                dd_state[i].remove(item_two)

                                if is_valid([dd_state, c_moves +1]) and is_new([dd_state, c_moves+1]):
                                    queue.append([dd_state, c_moves + 1])


    queue.popleft()

###############################################################################

queue.append(initial_state)
is_new(initial_state)
while queue:
    expand_queue(queue[0],queue)