SGLearn@Artificial Intelligence I: Basics and Games in Java

Explore how breadth-first search visits every vertex exactly once using a FIFO queue, delivering linear time in V+E but higher memory usage, with applications in artificial intelligence and shortest-path problems.

Explore a concrete breadth-first search implementation in Java, with a vertex class, neighbor lists, a queue, and a test main method to verify traversal.

Explore depth-first search, a depth-oriented graph traversal using stacks or recursion, and its applications in cycle detection, topological ordering, and strongly connected components.

Master depth-first search implementation using a stack in Java to traverse a graph. Handle multiple clusters, adjacency lists, and visited vertices for memory friendly exploration.

Perform depth-first search using a recursive method that visits unvisited vertices, explores neighbor lists, and prints; while the operating system manages the call stack, order of children does not matter.

Explore iterative deepening depth-first search, a hybrid that preserves the order of breadth-first search while reducing memory use. Compare its time complexity and the trade-offs of repeated visits.

Learn to implement iterative deepening depth-first search in Java, using a node-based graph with depth tracking, adjacency lists, and a stack-driven search to locate a target vertex layer by layer.

Explore the a-star search algorithm for pathfinding on graphs and grids, and learn how g and h drive node expansion using Manhattan distance for obstacle-rich maps.

Explore brute force search as a local search algorithm that iterates through all candidates to find the true maximum or minimum, highlighting its simplicity, exhaustiveness, and the curse of dimensionality.

Apply brute force search to find the global optimum of a function on a given interval by partitioning the range and evaluating f(x) at sample points.

Explore stochastic search as a fast, non deterministic local search that uses random indices to evaluate the function, offering speed over brute force and applicability to multidimensional finance problems.

Learn how random search minimizes a function by generating random points and updating the minimum, illustrating stochastic search and its use in Monte-Carlo simulations.

Explore the hill climbing algorithm, its goal to find local maxima or minima, and how repeated restarts from different starting points help avoid local optima, compared to brute-force search.

Implement hill climbing in Java by defining a function, choosing an interval and step size, iterating to find the maximum, and printing the best x and its value.

Explore the difference between heuristics and meta-heuristics, including problem-specific approaches like alpha-beta pruning and A* search, and problem-independent methods such as genetic algorithms and simulated annealing for solving NP-hard problems.

Learn tabu search, a local search method using a tabu list and aspiration criteria to avoid revisiting moves and escape local optima in traveling salesman problem optimization.

Explore simulated annealing to escape local optima and approach the global optimum, using a temperature parameter, random neighbor moves, and an acceptance function based on energy.

Implement simulated annealing in Java to find the extremum of a one-dimensional function, covering project setup, constants, and algorithms, with high initial temperature and cooling ideas.

Implement simulated annealing to minimize a one-dimensional function by defining an energy function, generating random neighbors, calculating acceptance probability, and cooling the temperature toward a global minimum.

Apply simulated annealing in Java to find a function extremum by tuning temperature and cooling rate while updating energy and the best solution.

Explore the traveling salesman problem and how simulated annealing finds a near-optimal city tour. Learn to model cities, distances, and a repository in Java.

Learn a Java-based implementation of the traveling salesman problem, constructing a hamiltonian single tour that visits each city once for the shortest path with distance calculations and simulated annealing.

Explore the simulated annealing algorithm applied to the traveling salesman problem, swapping cities to explore solutions, and using temperature, cooling rate, and acceptance probability to reach a near-optimal tour.

Demonstrate testing of simulated annealing for the traveling salesman problem with 100 cities and random coordinates, comparing brute-force limits to approximated, improved tours.

Genetic algorithms mimic natural evolution to evolve candidate solutions through a population, using mutation, crossover, and a fitness function across generations, terminating when a satisfactory fitness is reached.

Encode potential solutions into chromosomes using binary strings and initialize a random population for genetic algorithms. Represent real numbers as binary, apply mutation, and evaluate fitness to select better solutions.

Learn how genetic algorithms use binary chromosomes and crossover to generate new solutions by swapping bits at random points, guided by a crossover threshold to balance exploration and efficiency.

Explore how mutation flips bits on a chromosome using a mutation threshold and random numbers. Contrast crossover driving toward local optima with mutation enabling diversification to reach the global optimum.

Discover how genetic algorithms encode solutions as bit strings, define fitness, and evolve via selection, crossover, and mutation to optimize one-dimensional functions and scale to high dimensions.

Implement a Java genetic algorithm to find a target solution sequence by building an individual class, a population, and GA constants like crossover rate, mutation rate, and fitness.

Implement the population for a genetic algorithm in Java, using a one-dimensional array of individuals with random digit genes. Track the fittest by gene matches to the target sequence.

Implement the genetic algorithm from scratch by creating a random population and applying crossover and mutation to evolve the fittest. The video covers population creation, crossover, mutation, and the fittest.

Explore a genetic algorithm implemented in Java, including building an individual's string representation, initializing a population, evolving with fitness, crossover, and mutation to reach the optimal solution.

Implement a genetic algorithm from scratch in Java to optimize a one-dimensional function, using binary chromosome representation, genes-to-doubles conversion, fitness evaluation, and selection for maximum or minimum.

Explore swarm intelligence by showing how simple, local interactions among agents and the environment produce emergent, complex behavior, from colony optimization to Conway's Game of Life.

Explore particle swarm optimization, a swarm intelligence algorithm that finds the global optimum by guiding particles with velocity and position updates toward local and global best positions, without gradients.

Explore the particle swarm optimization algorithm, using particle position, velocity, and personal and global bests, guided by inertia, cognitive, and social coefficients with random factors.

Implement particle swarm optimization in Java by defining constants, two-dimensional particles, and a cost function to optimize within -2 to 2. Track velocity, position, and global best to guide the search.

Implement particle swarm optimization initialization by setting the global best solutions, creating the particle swarm, and randomizing locations and velocities for the solver.

Initialize particles with locations and velocities to build a particle swarm optimization solver. Update velocity and position, clamp within min and max bounds, and track local and global best solutions.

demonstrates testing a particle swarm optimization implementation to find the function's minimum and maximum, detailing initialization, iterative velocity and position updates, and how to adapt the approach for maximization.

Explore game trees as directed graphs of positions with moves as edges. Apply minimax and heuristic evaluation to estimate best moves in large games like chess, noting trees are memory-heavy.

Introduces minimax as a recursive, two-player decision rule on a game tree, maximizing our win and minimizing the opponent's, using states, moves, and heuristic evaluation (tic tac toe example).

Learn how the minimax algorithm uses a game tree with leaf values and a heuristic to alternate between maximizing and minimizing levels to pick the optimal move at the root.

Learn how the minimax algorithm constructs a tic-tac-toe game tree to select the optimal move, using leaf values of plus or minus one and alternating maximizing and minimizing layers.

Explore alpha-beta pruning to accelerate the minimax algorithm by maintaining alpha and beta values across maximizer and minimizer layers, pruning branches and speeding up game-tree search.

Explore chess as a game of perfect information, using minimax to build a partial game tree with leaf evaluations, addressing memory limits, and comparing to tic-tac-toe.

Explore tic tac toe gameplay and the minimax algorithm, using a 3x3 grid and a two-player X and O setup to analyze optimal moves.

Implement a tic tac toe game in a Java project by modeling a 3x3 board with cells identified by x and y, using minimax values (+1, 0, -1) for outcomes.

Define a 3x3 board constant and prevent instantiation with private constructor; model each cell as a solid state of X, O, or dash, with coordinates x, y and minimax value.

Implement the tic-tac-toe game class, handling a random first move for the computer, user coordinates input, and a minimax-driven move selection with board updates and status checks.

Continue implementing the game class with a board and random moves, decide who starts, and perform the computer's first move; initialize and display the board for the next lesson.

Implement a board using a two-dimensional array, handle player and computer moves with scanner input, and compute minimax values to evaluate root values in a game tree.

Define and implement a winning method that checks for three in a row for a given player across diagonals, rows, and columns, returning true when a win is detected.

Implement the board with minimax support: track max and min values, determine the best move, initialize the board, and add getters and setters, laying groundwork for minimax algorithm.

Implement the minimax algorithm for tic tac toe in the board class, using a root-to-leaf tree where the computer maximizes while the user minimizes and returns win, loss, or draw.

Java tic-tac-toe uses the minimax algorithm to exhaustively evaluate the game tree and compute optimal moves. The computer can often win or force a draw, especially when it starts.

Rican traces a path from early web work to machine learning and data mining in informatics, and highlights Singapore’s AI shift with Virtual Singapore and vehicle-to-vehicle communication.

Explore how Singapore small and medium enterprises can adopt data analytics and data science, with cybersecurity and blockchain applications for supply chains and food safety.