artificial-intelligence

A small (3x3, 4x4) tic-tac-toe can be easily solved by considering all the cases. But for example, you have a 30x30 tic-tac-toe. What algorithm would you use to decide the next best move in that case? Minimax + alpha-beta pruning is one way that I know. Is there some other way that is more efficient/not more efficient but cooler? I know it would not be a very interesting game to play. I said 30x30 just to ask what I wanted to i.e. which algorithms work best at these sort of games where the number of cases to consider for a perfect solution is very very high and thus not feasible. I don't think

What I am supposed to do. I have an black and white image (100x100px): I am supposed to train a backpropagation neural network with this image. The inputs are x, y coordinates of the image (from 0 to 99) and output is either 1 (white color) or 0 (black color). Once the network has learned, I would like it to reproduce the image based on its weights and get the closest possible image to the original. Here is my backprop implementation: import os import math import Image import random from random import sample #------------------------------ class definitions class Weight: def __init__(self,

The 15 Puzzle is a classical problem for modelling algorithms involving heuristics. Commonly used heuristics for this problem include counting the number of misplaced tiles and finding the sum of the Manhattan distances between each block and its position in the goal configuration. Note that both are admissible, i.e., they never overestimate the number of moves left, which ensures optimality for certain search algorithms such as A*. What Heuristic do you think is proper, A* seems to work nice, do you have an example, maybe in c or java ? Margus Heuristic My heuristic of choice is to find if

I understand the basics of minimax and alpha-beta pruning. In all the literature, they talk about the time complexity for the best case is O(b^(d/2)) where b = branching factor and d = depth of the tree, and the base case is when all the preferred nodes are expanded first. In my example of the "best case", I have a binary tree of 4 levels, so out of the 16 terminal nodes, I need to expand at most 7 nodes. How does this relate to O(b^(d/2))? I don't understand how they come to O(b^(d/2)). Please, can someone explain it to me? Thans a lot! O(b^(d/2)) correspond to the best case time complexity

I'm working on an AI for a game and I want to use the MinMax algorithm with the Alpha-Beta pruning . I have a rough idea on how it works but I'm still not able to write the code from scratch, so I've spend the last two days looking for some kind of pseudocode online. My problem is that every pseudocode I've found online seems to be based on finding the value for the best move while I need to return the best move itself and not a number. My current code is based on this pseudocode ( source ) minimax(level, player, alpha, beta){ // player may be "computer" or "opponent" if (gameover || level ==