예제 #1
0
def dfs(level):
    smap = level.smap

    first_node = Node(level.start, None, [])

    stack = []

    #metemos al nodo inicial en la cola

    stack.append(first_node)
    processed = set()

    nodes_processed = 0

    # mientras que la cola tenga elementos y no gane

    won = False

    while stack and not won:
        
        # saco el primer nodo del stack
        node = stack.pop()
        # print('ITERATION: ', nodes_processed, ' --------------------------------------------------------------')
        # print("Current node: ", node.config)

        # agrego este nodo a los nodos procesados
        processed.add(node.config)
    
        # primero me fijo si gane
        if(finished(node.config.boxes, level)):
            # si gane listo
            # print("Found solution!")
            won = True
        else:
            nodes_processed += 1

            # si no gane pido mis movimientos legales
            possible_configs = next_configs(node.config, level.smap)
            # print("Possible configs: ", possible_configs)

            children = node.children
            
            #por cada movimiento legal me fijo si ya tube esta config antes y si no la apendeo a la cola
            # print("Procesed: ===>", processed)
            for config in possible_configs.difference(processed):
                # print("Config: +++>", config)
                # print("Was not in processed")
                new_node = Node(copy.copy(config), node, [])
                children.append(new_node)
                stack.append(new_node)
                # print("Added move: ", new_node.config)

            # print("Used configs: ", processed)
            # print("Stack is: ", stack)

    if won:
        path = build_path(node)
        return process_results(won, smap, node, path, ALGORITHM_NAME, nodes_processed - 1, len(stack))
    else:
        return process_results(won, smap, None, [], ALGORITHM_NAME, nodes_processed - 1, len(stack))
예제 #2
0
def bfs(level):
    smap = level.smap

    first_node = Node(level.start, None, [])

    queue = []

    #metemos al nodo inicial en la cola

    queue.append(first_node)
    processed = set()

    nodes_processed = 0

    # mientras que la cola tenga elementos y no gane

    won = False

    while queue and not won:
        
        # saco el primer nodo de la cola
        node = queue.pop(0)
        # print("Current node: ", node.config)

        # agrego este nodo a los nodos procesados
        processed.add(node.config)

        # primero me fijo si gane
        if(finished(node.config.boxes, level)):
            # si gane listo
            print("Found solution!")
            won = True
            
        else:
            nodes_processed += 1

            # si no gane pido mis movimientos legales
            possible_configs = next_configs(node.config, level.smap)
            # print("Possible configs: ", possible_configs)

            children = node.children
            
            #por cada movimiento legal me fijo si ya tube esta config antes y si no la apendeo a la cola
            
            for config in possible_configs.difference(processed):
                new_node = Node(copy.copy(config), node, [])
                children.append(new_node)
                queue.append(new_node)
                # print("Added move: ", new_node.config)

            # print("Used configs: ", processed)
            # print("Queue is: ", queue)

    if won:
        path = build_path(node)
        return process_results(won, smap, node, path, ALGORITHM_NAME, nodes_processed - 1, len(queue))
    else:
        return process_results(won, smap, None, [], ALGORITHM_NAME, nodes_processed - 1, len(queue))
예제 #3
0
파일: iddfs.py 프로젝트: mbaiges/sia-tp1
def iddfs(level, n, testall):
    initial_time = datetime.now()

    smap = level.smap

    first_node = Node(level.start, None, [], 0)

    deque = []

    #metemos al nodo inicial en la cola
    deque.append(first_node)
    known_nodes = HashTable()

    known_nodes.put(first_node.config, first_node)

    nodes_processed = 0

    # curr_n = n

    # mientras que la cola tenga elementos y no gane
    won = False

    limit_nodes_per_n = []
    limit_nodes_per_n_size = 0

    while deque and not won:

        # saco el primer nodo del stack
        node = deque.pop()

        # if node in processed:
        #     l = list(processed)
        #     idx = l.index(node)

        #     if idx >= 0 and idx < len(l):
        #         proc_node = l[idx]
        #         if node.depth >= proc_node.depth:
        #             pase = True
        #             continue
        #     else:
        #         continue

        # primero me fijo si gane
        if (finished(node.config.boxes, level)):
            # si gane listo
            won = True
        else:
            nodes_processed += 1

            # si no gane pido mis movimientos legales
            possible_configs = next_configs(node.config, level.smap)
            children = node.children

            if (node.depth + 1) % n == 0:
                children_at_limit = True
            else:
                children_at_limit = False

            for config in possible_configs:
                proc_node = known_nodes.get(config)

                if proc_node and node.depth + 1 >= proc_node.depth:
                    continue

                new_node = Node(copy.copy(config), node, [], node.depth + 1)

                known_nodes.put(config, new_node)

                children.append(new_node)

                if children_at_limit:
                    limit_idx = int(new_node.depth / n) - 1
                    if len(limit_nodes_per_n) < limit_idx + 1:
                        limit_nodes_per_n.append(0)
                    limit_nodes_per_n[limit_idx] += 1

                    deque.insert(0, new_node)
                else:
                    deque.append(new_node)

                # print("Added move: ", new_node.config)

            # print("Used configs: ", processed)
            # print("deque is: ", deque)

    finish_time = datetime.now()

    elapsed_time = finish_time - initial_time

    #print(limit_nodes_per_n)

    if won:
        path = build_path(node)
        return process_results(won, testall, elapsed_time, smap, node, path,
                               f"{ALGORITHM_NAME} (n='{n}')",
                               nodes_processed - 1, len(deque))
    else:
        return process_results(won, testall, elapsed_time, smap, None, [],
                               f"{ALGORITHM_NAME} (n='{n}')",
                               nodes_processed - 1, len(deque))
예제 #4
0
def idastar(level, heu, testall):
    h=heu["func"]
    initial_time = datetime.now()

    smap = level.smap

    first_node = Node(level.start, None, [], 0, {'g': 0, 'h': h(smap, level.goals, level.start)})

    lim = first_node.meta['g'] + first_node.meta['h'] # f(n0)

    min_exceeded_lim = -1

    def cp(e1, e2):
        g1 = e1.meta['g']
        g2 = e2.meta['g']
        h1 = e1.meta['h']
        h2 = e2.meta['h']

        f1 = g1 + h1
        f2 = g2 + h2
        
        if f1 == f2:
            return h1 - h2
        else:
            return f1 - f2

    q1 = []
    q2 = []

    out_of_frontier = OrderedList(cp)

    q1.append(first_node)
    known_nodes = HashTable()

    known_nodes.put(first_node.config, first_node)

    nodes_processed = 0

    won = False

    first_found = False

    while (q1 or q2) and not won:

        if not q1:
            q1 = q2
            q2 = []
            lim = min_exceeded_lim
            min_exceeded_lim = -1

        node = q1.pop()

        f = node.meta['g'] + node.meta['h']

        if f > lim:
            q2.append(node)
            continue

        if(finished(node.config.boxes, level)):
            won = True
        else:
            nodes_processed += 1
            possible_configs = next_configs(node.config, level.smap)

            children = node.children
            
            for config in possible_configs:

                proc_node = known_nodes.get(config)

                if proc_node and node.depth + 1 >= proc_node.depth:
                    continue

                new_node = Node(copy.copy(config), node, [], node.depth + 1, {'g': node.depth + 1, 'h': h(smap, level.goals, config)})

                known_nodes.put(config, new_node)  

                children.append(new_node)

                f = new_node.meta['g'] + new_node.meta['h']

                if f > lim:
                    q2.append(new_node) 
                    if min_exceeded_lim == -1 or f < min_exceeded_lim:
                        min_exceeded_lim = f
                else:
                    q1.append(new_node)     
                

    finish_time = datetime.now()

    elapsed_time = finish_time - initial_time

    if won:
        path = build_path(node)
        return process_results(won, testall, elapsed_time, smap, node, path, f"{ALGORITHM_NAME} ({heu['name']})", nodes_processed - 1, len(q1) + len(q2))
    else:
        return process_results(won, testall, elapsed_time, smap, None, [], f"{ALGORITHM_NAME} ({heu['name']})", nodes_processed - 1, len(q1) + len(q2))
예제 #5
0
파일: astar.py 프로젝트: mbaiges/sia-tp1
def astar(level, heu, testall):

    h = heu["func"]

    initial_time = datetime.now()

    smap = level.smap

    first_node = Node(level.start, None, [], 0, {
        'g': 0,
        'h': h(smap, level.goals, level.start)
    })

    def cp(e1, e2):
        g1 = e1.meta['g']
        g2 = e2.meta['g']
        h1 = e1.meta['h']
        h2 = e2.meta['h']

        f1 = g1 + h1
        f2 = g2 + h2

        if f1 == f2:
            return h1 - h2
        else:
            return f1 - f2

    nodes_list = OrderedList(cp)

    nodes_list.add(first_node)

    #known_cfgs = set()
    known_nodes = HashTable()

    #known_cfgs.add(first_node.config)
    known_nodes.put(first_node.config, first_node)

    nodes_processed = 0

    won = False

    while nodes_list.length() > 0 and not won:

        node = nodes_list.pop()

        if (finished(node.config.boxes, level)):
            won = True
        else:
            nodes_processed += 1

            possible_configs = next_configs(node.config, level.smap)

            children = node.children

            for config in possible_configs:

                proc_node = known_nodes.get(config)
                new_node = Node(copy.copy(config), node, [], node.depth + 1, {
                    'g': node.depth + 1,
                    'h': h(smap, level.goals, config)
                })

                if proc_node:
                    new_node_f = new_node.meta['g'] + new_node.meta['h']
                    proc_node_f = proc_node.meta['g'] + proc_node.meta['h']

                    if (new_node_f >= proc_node_f):
                        continue

                # if config in known_cfgs:
                #     continue

                #known_cfgs.add(config)
                known_nodes.put(config, new_node)

                children.append(new_node)
                nodes_list.add(new_node)

    finish_time = datetime.now()

    elapsed_time = finish_time - initial_time

    if won:
        path = build_path(node)
        return process_results(won, testall, elapsed_time, smap, node, path,
                               f"{ALGORITHM_NAME} ({heu['name']})",
                               nodes_processed - 1, nodes_list.length())
    else:
        return process_results(won, testall, elapsed_time, smap, None, [],
                               f"{ALGORITHM_NAME} ({heu['name']})",
                               nodes_processed - 1, nodes_list.length())
예제 #6
0
def ggs(level, heu, testall):

    h = heu["func"]

    initial_time = datetime.now()

    smap = level.smap

    first_node = Node(level.start, None, [], 0,
                      {'h': h(smap, level.goals, level.start)})

    def cp(e1, e2):
        return e1.meta['h'] - e2.meta['h']

    nodes_list = OrderedList(cp)

    #metemos al nodo inicial en la cola ( ͡° ͜ʖ ͡°)

    nodes_list.add(first_node)
    known_cfgs = set()

    known_cfgs.add(first_node.config)

    nodes_processed = 0

    # mientras que la cola tenga elementos y no gane

    won = False

    while nodes_list.length() > 0 and not won:

        # saco el primer nodo del nodes_list
        node = nodes_list.pop()
        # print('ITERATION: ', nodes_processed, ' --------------------------------------------------------------')

        # print("Current node: ", node.config)

        # primero me fijo si gane
        if (finished(node.config.boxes, level)):
            # si gane listo
            # print("Found solution!")
            won = True
        else:
            nodes_processed += 1

            # si no gane pido mis movimientos legales
            possible_configs = next_configs(node.config, level.smap)
            # print("Possible configs: ", possible_configs)

            children = node.children

            #por cada movimiento legal me fijo si ya tube esta config antes y si no la apendeo a la cola
            # print("Procesed: ===>", processed)
            for config in possible_configs:

                if config in known_cfgs:
                    continue

                known_cfgs.add(config)

                new_node = Node(copy.copy(config), node, [], node.depth + 1,
                                {'h': h(smap, level.goals, config)})
                children.append(new_node)
                nodes_list.add(new_node)
                # print("Added move: ", new_node.config)

            # print("Used configs: ", processed)
            # print("Stack is: ", stack)

    finish_time = datetime.now()

    elapsed_time = finish_time - initial_time

    if won:
        path = build_path(node)
        return process_results(won, testall, elapsed_time, smap, node, path,
                               f"{ALGORITHM_NAME} ({heu['name']})",
                               nodes_processed - 1, nodes_list.length())
    else:
        return process_results(won, testall, elapsed_time, smap, None, [],
                               f"{ALGORITHM_NAME} ({heu['name']})",
                               nodes_processed - 1, nodes_list.length())