PROGRAM

import java.util.Scanner;

public class hillClimbing {

public static void main(String[] args) {

int n,i,j;

Scanner sc=new Scanner(System.in);

System.out.println("Enter number of nodes in graph");

n=sc.nextInt();

int[][] graph=new int[n][n];

for(i=0;i<n;i++)

for(j=0;j<n;j++)

graph[i][j]=0;

for(i=0;i<n;i++)

for(j=i+1;j<n;j++)

System.out.println("Is "+i+" is connected to "+ j);

graph[i][j]=sc.nextInt();

System.out.println("The adjacency matrix is:");

for(i=0;i<n;i++)

for(j=0;j<n;j++)

{ System.out.print(graph[i][j]+ "\t");

}
 System.out.println();

}}}

OUTPUT
PROGRAM
import java.io.*;
import java.util.*;

public class Node implements Comparable<Node> {

// Id for readability of result purposes
private static int idCounter = 0;
public int id;

// Parent in the path

public Node parent = null;

public List<Edge> neighbors;

// Evaluation functions
public double f = Double.MAX_VALUE;
public double g = Double.MAX_VALUE;
// Hardcoded heuristic
public double h;

Node(double h){
this.h = h;
this.id = idCounter++;
this.neighbors = new ArrayList<>();
}

@Override
public int compareTo(Node n) {
return Double.compare(this.f, n.f);
}
 public static class Edge {
Edge(int weight, Node node){
this.weight = weight;
this.node = node;
}

public int weight;

public Node node;
}

public void addBranch(int weight, Node node){

Edge newEdge = new Edge(weight, node);
neighbors.add(newEdge);
}

public double calculateHeuristic(Node target){

return this.h;
}
public static Node aStar(Node start, Node target){
PriorityQueue<Node> closedList = new PriorityQueue<>();
PriorityQueue<Node> openList = new PriorityQueue<>();

start.f = start.g + start.calculateHeuristic(target);

openList.add(start);

while(!openList.isEmpty()){
Node n = openList.peek();
if(n == target){
return n;
}
 for(Node.Edge edge : n.neighbors){
Node m = edge.node;
double totalWeight = n.g + edge.weight;

if(!openList.contains(m) && !closedList.contains(m)){

m.parent = n;
m.g = totalWeight;
m.f = m.g + m.calculateHeuristic(target);
openList.add(m);
} else {
if(totalWeight < m.g){
m.parent = n;
m.g = totalWeight;
m.f = m.g + m.calculateHeuristic(target);

if(closedList.contains(m)){
closedList.remove(m);
openList.add(m);
}
}
}
}

openList.remove(n);
closedList.add(n);
}
return null;
}
public static void printPath(Node target){
Node n = target;

if(n==null)
return;

List<Integer> ids = new ArrayList<>();

while(n.parent != null){
ids.add(n.id);
n = n.parent;
}
ids.add(n.id);
Collections.reverse(ids);

for(int id : ids){
System.out.print(id + " ");
}
System.out.println("");
}
public static void main(String[] args) {
Node head = new Node(3);
head.g = 0;

Node n1 = new Node(2);

Node n2 = new Node(2);
Node n3 = new Node(2);

head.addBranch(1, n1);
head.addBranch(5, n2);
 head.addBranch(2, n3);
n3.addBranch(1, n2);

Node n4 = new Node(1);

Node n5 = new Node(1);
Node target = new Node(0);

n1.addBranch(7,n4);
n2.addBranch(4, n5);
n3.addBranch(6, n4);

n4.addBranch(3, target);
n5.addBranch(1, n4);
n5.addBranch(3, target);
Node res = aStar(head, target);
printPath(res);
}
}

OUTPUT
PROGRAM
import java.util.Scanner;

public class tic_tac_toe {

private static final char EMPTY = ' ';

private static final char PLAYER_X = 'X';

private static final char PLAYER_O = 'O';

private static final char[][] BOARD = new char[3][3];

private static final Scanner scanner = new Scanner(System.in);

public static void main(String[] args) {

initializeBoard();

char currentPlayer = PLAYER_X;

boolean gameFinished = false;

while (!gameFinished) {

displayBoard();

playerMove(currentPlayer);

gameFinished = checkWin(currentPlayer) || checkDraw();

currentPlayer = (currentPlayer == PLAYER_X) ? PLAYER_O : PLAYER_X;

displayBoard();

printResult();

scanner.close();

static void initializeBoard() {

for (char[] row : BOARD) {

for (int j = 0; j < row.length; j++) {

row[j] = EMPTY;

}
 }

static void displayBoard() {

System.out.println(" -------------");

for (char[] row : BOARD) {

System.out.print("| ");

for (char cell : row) {

System.out.print(cell + " | ");

System.out.println("\n ------------- ");

static void playerMove(char player) {

int row, col;

do {

System.out.println("Player " + player + ", enter your move (row[1-3] column[1-3]):

");

row = scanner.nextInt() - 1;

col = scanner.nextInt() - 1;

} while (!isValidMove(row, col));

BOARD[row][col] = player;

static boolean isValidMove(int row, int col) {

return row >= 0 && row < 3 && col >= 0 && col < 3 && BOARD[row][col] ==
EMPTY;

static boolean checkWin(char player) {

for (int i = 0; i < 3; i++) {

 if (BOARD[i][0] == player && BOARD[i][1] == player && BOARD[i][2] == player
||

BOARD[0][i] == player && BOARD[1][i] == player && BOARD[2][i] ==

player) {

return true; // Row or Column win

return BOARD[0][0] == player && BOARD[1][1] == player && BOARD[2][2] ==

player ||

BOARD[0][2] == player && BOARD[1][1] == player && BOARD[2][0] ==

player; // Diagonal win

static boolean checkDraw() {

for (char[] row : BOARD) {

for (char cell : row) {

if (cell == EMPTY) {

return false;

return true; // Board full, game draw

static void printResult() {

if (checkWin(PLAYER_X)) {

System.out.println("Player X wins!");

} else if (checkWin(PLAYER_O)) {

System.out.println("Player O wins!");

} else {
 System.out.println("It's a draw!"); }}}

OUTPUT
PROGRAM

import java.util.LinkedList;

import java.util.Queue;

public class snakeandladder {

// An entry in queue used in BFS

static class qentry {

int v; // Vertex number

int dist; // Distance of this vertex from source

static int getMinDiceThrows(int move[], int n)

int visited[] = new int[n];

Queue<qentry> q = new LinkedList<>();

qentry qe = new qentry();

qe.v = 0;

qe.dist = 0;

// Mark the node 0 as visited and enqueue it.

visited[0] = 1;

q.add(qe);

// Do a BFS starting from vertex at index 0

while (!q.isEmpty()) {

qe = q.remove();

int v = qe.v;

if (v == n - 1)

break;

for (int j = v + 1; j <= (v + 6) && j < n;

++j) {
if (visited[j] == 0) {

qentry a = new qentry();

a.dist = (qe.dist + 1);

visited[j] = 1;

if (move[j] != -1)

a.v = move[j];

else

a.v = j;

q.add(a);

return qe.dist;

public static void main(String[] args)

int N = 30;

int moves[] = new int[N];

for (int i = 0; i < N; i++)

moves[i] = -1;

// Ladders

moves[2] = 21;

moves[4] = 7;

moves[10] = 25;

moves[19] = 28;

// Snakes

moves[26] = 0;
moves[20] = 8;

moves[16] = 3;

moves[18] = 6;

System.out.println("Min Dice throws required is "

+ getMinDiceThrows(moves, N));

OUTPUT
PROGRAM

import java.util.Random;

import java.util.Scanner;

public class stonepaper {

private static final String[] MOVES = {"rock", "paper", "scissors"};

private static final Random random = new Random();

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

System.out.println("How many rounds of Rock-Paper-Scissors would you like to

play?");

int rounds = Integer.parseInt(scanner.nextLine());

for (int i = 0; i < rounds; i++) {

playRockPaperScissors(scanner);

static void playRockPaperScissors(Scanner scanner) {

System.out.println("Make a move! (rock/paper/scissors)");

String playerMove = scanner.nextLine();

String computerMove = MOVES[random.nextInt(MOVES.length)];

System.out.println("Computer chose " + computerMove + "!");

if (playerMove.equals(computerMove)) {

System.out.println("It's a draw!");

} else if (playerWins(playerMove, computerMove)) {

System.out.println("Player wins!");

} else {

System.out.println("Computer wins!");
 }

static boolean playerWins(String playerMove, String computerMove) {

return (playerMove.equals("rock") && computerMove.equals("scissors")) ||

(playerMove.equals("paper") && computerMove.equals("rock")) ||

(playerMove.equals("scissors") && computerMove.equals("paper"));

OUTPUT
PROGRAM
import java.io.*;
import java.util.*;
public class N_queens {
void printSolution(int board[][], int N)
{
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (board[i][j] == 1)
System.out.print("Q ");
else
System.out.print(". ");
}
System.out.println();
}
}
boolean isSafe(int board[][], int row, int col, int N)
{
int i, j;
for (i = 0; i < col; i++)
if (board[row][i] == 1)
return false;
for (i = row, j = col; i >= 0 && j >= 0; i--, j--)
if (board[i][j] == 1)
return false;
for (i = row, j = col; j >= 0 && i < N; i++, j--)
if (board[i][j] == 1)
return false;
return true;
}
boolean solveNQUtil(int board[][], int col, int N)
{
if (col >= N)
return true;
for (int i = 0; i < N; i++) {
if (isSafe(board, i, col, N)) {
board[i][col] = 1;
if (solveNQUtil(board, col + 1, N) == true)
return true;
board[i][col] = 0; // BACKTRACK
}
}
return false;
}
boolean solveNQ(int N)
{
int board[][] = new int[N][N];
for(int i = 0; i< N ; i++){
for(int j = 0; j < N ; j++)
board[i][j] = 0;
}
if (solveNQUtil(board, 0 , N) == false) {
System.out.print("Solution does not exist");
return false;
}
printSolution(board,N);
return true;
}
public static void main(String args[])
{
 N_queens Queen = new N_queens();
Scanner in = new Scanner(System.in);
System.out.println("Enter the no of queens : ");
int n = in.nextInt();
Queen.solveNQ(n);
}
}

OUTPUT
PROGRAM
import java.util.*;
import java.io.*;
import java.util.Scanner;
class TSP
{
static int findHamiltonianCycle(int[][] distance, boolean[] visitCity, int currPos, int cities,
int count, int cost, int hamiltonianCycle)
{

if (count == cities && distance[currPos][0] > 0)

{
hamiltonianCycle = Math.min(hamiltonianCycle, cost + distance[currPos][0]);
return hamiltonianCycle;
}
for (int i = 0; i < cities; i++)
{
if (visitCity[i] == false && distance[currPos][i] > 0)
{
visitCity[i] = true;
hamiltonianCycle = findHamiltonianCycle(distance, visitCity, i, cities, count + 1,
cost + distance[currPos][i], hamiltonianCycle);
visitCity[i] = false;
}
}
return hamiltonianCycle;
}
public static void main(String[] args)
{
int cities;
Scanner sc = new Scanner(System.in);
 System.out.println("Enter total number of cities ");
cities = sc.nextInt();
int distance[][] = new int[cities][cities];
for( int i = 0; i < cities; i++){
for( int j = 0; j < cities; j++){
System.out.println("Distance from city"+ (i+1) +" to city"+ (j+1) +": ");
distance[i][j] = sc.nextInt();
}
}
boolean[] visitCity = new boolean[cities];
visitCity[0] = true;
int hamiltonianCycle = Integer.MAX_VALUE;
hamiltonianCycle = findHamiltonianCycle(distance, visitCity, 0, cities, 1, 0,
hamiltonianCycle);
System.out.println("Shortest path that visit all nodes is "+hamiltonianCycle);
}
}
OUTPUT