tour java code

Java Tutorial

Control statements, java object class, java inheritance, java polymorphism, java abstraction, java encapsulation, java oops misc.

Approach: Using Backtracking

In this approach, we start with an empty chessboard and try to place the Knight on each square in turn, backtracking when we reach a point where no further moves are possible. The Backtracking approach is a common algorithmic technique used to solve optimization problems, where we are searching for the best solution among many possible solutions.

• Define a static integer variable N representing the chessboard size (8).
• Define a Method isSafe(x, y, sol) to check if a knight can be placed at position (x, y) on the chessboard. The Method checks if (x, y) is within the board limits and if a knight does not already occupy the position.
• Define a Method print solution (sol) to print the final knight tour solution.
• Define a Method to solve KT () to solve the Knight's tour problem. a. Initialize an empty 2D array (sol) of size NxN, where -1 represents an empty cell. b. Define two arrays (xMove, yMove) to represent all possible knight moves. c. Set the starting position to (0,0) and mark it as visited by setting sol[0][0] to 0. d. Call the recursive Method solveKTUtil() with the starting position, movei=1, and the arrays xMove and yMove. e. If solveKTUtil() returns false, the Knight's tour solution does not exist. If it returns true, print the solution using printSolution() and return true.
• Define a recursive Method solveKTUtil(x, y, movie, sol, xMove, yMove) to solve the Knight's tour problem. a. If movie = N*N, the Knight's tour solution has been found, return true. b. Loop through all possible knight moves (k) using xMove and yMove arrays. c. Calculate the next position (next_x, next_y) using the current position (x, y) and the current knight move (k). d. If the next position is safe (i.e., isSafe(next_x, next_y, sol) returns true), mark it as visited by setting sol[next_x][next_y] = movei, and recursively call solveKTUtil() with the next position (next_x, next_y) and movei+1. e. If solveKTUtil() returns true, the Knight's tour solution has been found, return true. If it returns false, mark the next position as unvisited by setting sol[next_x][next_y] = -1 and continue to the next possible knight move. f. If no move leads to a solution, return false.
• The main method, called solveKT(), is to solve the Knight's tour problem. If a solution exists, it will be printed to the console.

Implementation

Filename: KnightTour.java

Complexity Analysis: The time complexity of the Knight's tour problem using backtracking is O(8^(N^2)), where N is the size of the chessboard. It is because at each move, the Knight has 8 possible moves to choose from, and the total number of moves the Knight can make is N^2.

The space complexity of the program is O(N^2).

• Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Transact-SQL

Reinforcement Learning

R Programming

React Native

Python Design Patterns

Python Pillow

Python Turtle

Preparation

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

Cloud Computing

Data Science

Machine Learning

B.Tech / MCA

Data Structures

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

C Programming

Control System

Data Mining

Data Warehouse

Welcome.please sign up.

By signing up or logging in, you agree to our Terms of service and confirm that you have read our Privacy Policy .

Already a member? Go to Log In

Welcome.please login.

Forgot your password

Not registered yet? Go to Sign Up

• Introduction
• Analyze Your Algorithm
• Growth of a Function
• Analyze Iterative Algorithms
• Recurrences
• Let's Iterate
• Now the Recursion
• Master's Theorem
• Sort It Out
• Bubble Sort
• Count and Sort
• Divide and Conquer
• Binary Search
• Dynamic Programming
• Knapsack Problem
• Rod Cutting
• Coin Change
• Backtracking
• Knight's Tour Problem
• Greedy Algorithm
• Activity Selection
• Egyptian Fraction
• Huffman Codes
• Minimum Spanning Tree
• Prim's Algorithm

Knight's Tour Problem | Backtracking

In the previous example of backtracking , you have seen that backtracking gave us a $O(n!)$ running time. Generally, backtracking is used when we need to check all the possibilities to find a solution and hence it is expensive. For the problems like N-Queen and Knight's tour, there are approaches which take lesser time than backtracking, but for a small size input like 4x4 chessboard, we can ignore the running time and the backtracking leads us to the solution.

Knight's tour is a problem in which we are provided with a NxN chessboard and a knight.

For a person who is not familiar with chess, the knight moves two squares horizontally and one square vertically, or two squares vertically and one square horizontally as shown in the picture given below.

Thus if a knight is at (3, 3), it can move to the (1, 2) ,(1, 4), (2, 1), (4, 1), (5, 2), (5, 4), (2, 5) and (4, 5) cells.

Thus, one complete movement of a knight looks like the letter "L", which is 2 cells long.

According to the problem, we have to make the knight cover all the cells of the board and it can move to a cell only once.

There can be two ways of finishing the knight move - the first in which the knight is one knight's move away from the cell from where it began, so it can go to the position from where it started and form a loop, this is called closed tour ; the second in which the knight finishes anywhere else, this is called open tour .

Approach to Knight's Tour Problem

Similar to the N-Queens problem, we start by moving the knight and if the knight reaches to a cell from where there is no further cell available to move and we have not reached to the solution yet (not all cells are covered), then we backtrack and change our decision and choose a different path.

So from a cell, we choose a move of the knight from all the moves available, and then recursively check if this will lead us to the solution or not. If not, then we choose a different path.

As you can see from the picture above, there is a maximum of 8 different moves which a knight can take from a cell. So if a knight is at the cell (i, j), then the moves it can take are - (i+2, j+1), (i+1, j+2), (i-2,j+1), (i-1, j+2), (i-1, j-2), (i-2, j-1), (i+1, j-2) and (i+2, j-1).

We keep the track of the moves in a matrix. This matrix stores the step number in which we visited a cell. For example, if we visit a cell in the second step, it will have a value of 2.

This matrix also helps us to know whether we have covered all the cells or not. If the last visited cell has a value of N*N, it means we have covered all the cells.

Thus, our approach includes starting from a cell and then choosing a move from all the available moves. Then we check if this move will lead us to the solution or not. If not, we choose a different move. Also, we store all the steps in which we are moving in a matrix.

Now, we know the basic approach we are going to follow. So, let's develop the code for the same.

Code for Knight's Tour

Let's start by making a function to check if a move to the cell (i, j) is valid or not - IS-VALID(i, j, sol) . As mentioned above, 'sol' is the matrix in which we are storing the steps we have taken.

A move is valid if it is inside the chessboard (i.e., i and j are between 1 to N) and if the cell is not already occupied (i.e., sol[i][j] == -1 ). We will make the value of all the unoccupied cells equal to -1.

As stated above, there is a maximum of 8 possible moves from a cell (i, j). Thus, we will make 2 arrays so that we can use them to check for the possible moves.

Thus if we are on a cell (i, j), we can iterate over these arrays to find the possible move i.e., (i+2, j+1), (i+1, j+2), etc.

Now, we will make a function to find the solution. This function will take the solution matrix, the cell where currently the knight is (initially, it will be at (1, 1)), the step count of that cell and the two arrays for the move as mentioned above - KNIGHT-TOUR(sol, i, j, step_count, x_move, y_move) .

We will start by checking if the solution is found. If the solution is found ( step_count == N*N ), then we will just return true.

KNIGHT-TOUR(sol, i, j, step_count, x_move, y_move)   if step_count == N*N     return TRUE

Our next task is to move to the next possible knight's move and check if this will lead us to the solution. If not, then we will select the different move and if none of the moves are leading us to the solution, then we will return false.

As mentioned above, to find the possible moves, we will iterate over the x_move and the y_move arrays.

KNIGHT-TOUR(sol, i, j, step_count, x_move, y_move)   ...   for k in 1 to 8     next_i = i+x_move[k]     next_j = j+y_move[k]

Now, we have to check if the cell (i+x_move[k], j+y_move[k]) is valid or not. If it is valid then we will move to that cell - sol[i+x_move[k]][j+y_move[k]] = step_count and check if this path is leading us to the solution ot not - if KNIGHT-TOUR(sol, i+x_move[k], j+y_move[k], step_count+1, x_move, y_move) .

KNIGHT-TOUR(sol, i, j, step_count, x_move, y_move)   ...   for k in 1 to 8     ...     if IS-VALID(i+x_move[k], j+y_move[k])       sol[i+x_move[k]][j+y_move[k]] = step_count       if KNIGHT-TOUR(sol, i+x_move[k], j+y_move[k], step_count+1, x_move, y_move)         return TRUE

If the move (i+x_move[k], j+y_move[k]) is leading us to the solution - if KNIGHT-TOUR(sol, i+x_move[k], j+y_move[k], step_count+1, x_move, y_move) , then we are returning true.

If this move is not leading us to the solution, then we will choose a different move (loop will iterate to a different move). Also, we will again make the cell (i+x_move[k], j+y_move[k]) of solution matrix -1 as we have checked this path and it is not leading us to the solution, so leave it and thus it is backtracking.

KNIGHT-TOUR(sol, i, j, step_count, x_move, y_move)   ...   for k in 1 to 8     ...       sol[i+x_move[k], j+y_move[k]] = -1

At last, if none the possible move returns us false, then we will just return false.

We have to start the KNIGHT-TOUR function by passing the solution, x_move and y_move matrices. So, let's do this.

As stated earlier, we will initialize the solution matrix by making all its element -1.

for i in 1 to N   for j in 1 to N     sol[i][j] = -1

The next task is to make x_move and y_move arrays.

x_move = [2, 1, -1, -2, -2, -1, 1, 2] y_move = [1, 2, 2, 1, -1, -2, -2, -1]

We will start the tour of the knight from the cell (1, 1) as its first step. So, we will make the value of the cell(1, 1) 0 and then call KNIGHT-TOUR(sol, 1, 1, 1, x_move, y_move) .

Analysis of Code

We are not going into the full time complexity of the algorithm. Instead, we are going to see how bad the algorithm is.

There are N*N i.e., N 2 cells in the board and we have a maximum of 8 choices to make from a cell, so we can write the worst case running time as $O(8^{N^2})$.

But we don't have 8 choices for each cell. For example, from the first cell, we only have two choices.

Even considering this, our running time will be reduced by a factor and will become $O(k^{N^2})$ instead of $O(8^{N^2})$. This is also indeed an extremely bad running time.

So, this chapter was to make you familiar with the backtracking algorithm and not about the optimization. You can look for more examples on the backtracking algorithm with the backtracking tag of the BlogsDope .

Code With C

The Way to Programming

• C Tutorials
• Java Tutorials
• Python Tutorials
• PHP Tutorials
• Java Projects

Java in History: Virtual Museum Tour Project

Programming with Priya: Unraveling the Java Journey! 🚀

Hey there, tech enthusiasts! 🤗 I hope you’re ready to embark on a thrilling adventure through the captivating world of Java programming. As an code-savvy friend 😋 with a passion for coding, I’m thrilled to take you on a virtual tour of the historical significance and implementation of Java in the remarkable Virtual Museum Tour Project. Buckle up as we unravel the fascinating evolution and impact of Java programming in this enthralling journey! 💻

I. Background of Java Programming

A. introduction to java.

Let’s kick things off by delving into the origins and early development of Java. Picture this – it’s the early 1990s, and a team of ingenious minds at Sun Microsystems set out to create a programming language for consumer electronic devices. Fast forward to today, and Java stands tall as a versatile, platform-independent language with a myriad of applications! 🌟

🌍 Origins and early development

I mean, Java’s DNA is intricately woven with the concept of “Write Once, Run Anywhere” – a game-changing idea that allows Java code to be executed on any device with a Java Virtual Machine (JVM). Talk about breaking down barriers and embracing universality! 🌐

Key features and advantages

Now, let’s not overlook the impressive lineup of features that Java brings to the table. From its robust security to its object-oriented structure, Java has certainly carved a niche for itself in the programming realm. “But Priya,” you ask, “what about its unparalleled portability and vast community support?” Ah yes, my dear friends, these are just a few feathers in Java’s cap! 🎩

II. Historical Significance of Virtual Museum Tour Project

A. importance of virtual tours in the museum industry.

Hold onto your seats as we venture into the realm of virtual museum tours. In a world where digital experiences reign supreme , virtual tours have emerged as a beacon of innovation in the museum industry. Imagine strolling through ancient artifacts and spellbinding exhibits without leaving the comfort of your living room – now that’s magic, isn’t it? ✨

Advantages of virtual tours over physical visits

Let’s pause to appreciate the sheer convenience of virtual tours. Bid farewell to long queues and restrictive visiting hours; with virtual tours, the museum is just a few clicks away! Plus, they open doors for global accessibility, allowing enthusiasts from across the globe to partake in the cultural extravaganza. Talk about breaking barriers! 🌍

Impact of technology on the museum experience

Take a moment to consider the transformative impact of technology on museum experiences. With virtual tours, the boundaries of time and space dissolve, paving the way for immersive, interactive encounters with history and heritage. It’s almost like time-traveling from the comfort of your couch! How’s that for a mind-boggling experience? ⏳

III. Project Requirements and Planning

A. understanding the objectives of the virtual museum tour.

Now, let’s roll up our sleeves and dive into the nitty-gritty of project planning. First on the agenda – understanding the objectives of our enthralling virtual museum tour. It’s all about identifying our target audience’s needs , preferences, and creating an enriching experience for them! 🎨

Identifying the target audience and their needs

Picture this – we’re catering to history buffs, art aficionados, and curious minds hungry for knowledge. By understanding their preferences and curiosities, we craft a virtual tour that’s nothing short of mesmerizing. It’s all about creating an unforgettable experience, right? 💫

Defining the scope and purpose of the project

Next up, it’s time to map out the scope and purpose of our project. What stories do we want to tell through our virtual museum tour? How do we want to captivate and educate our audience? These are the questions that shape the very essence of our virtual odyssey! 🗺️

IV. Java Programming Implementation

A. selection of appropriate java technologies and tools.

And here comes the grand reveal – the heart and soul of our virtual tour lies in the seamless implementation of Java programming . We’re in for a rollercoaster ride as we handpick the crème de la crème of Java technologies and tools to bring our digital museum to life! 💥

Choosing the right development environment

Let’s talk practicality. The choice of our development environment sets the stage for our Java-powered marvel. We’re looking for a harmonious blend of efficiency, flexibility, and sheer coding delight. Because hey, a smooth development journey makes all the difference, doesn’t it? 🖥️

Integration of Java libraries and APIs for virtual tour functionality

Ah, the sweet symphony of integrating Java libraries and APIs – the building blocks of our virtual museum tour’s functionality. It’s all about enriching the user experience, amping up the interactivity, and creating an immersive journey through the corridors of history. Who’s ready for some serious magic? ✨

V. Challenges and Future Developments

A. overcoming technical hurdles during the project.

Now, let’s address the elephants in the room – the technical hurdles that pepper our path to glory. From user interface challenges to user experience considerations, each hurdle is a stepping stone to refinement and excellence! After all, diamonds are forged under pressure, aren’t they? 💎

Addressing user interface and user experience considerations

In a world of virtual splendor, the user interface and experience reign supreme. We’re on a quest to fine-tune every interaction, every visual feast, and every storytelling element to create a seamless, enchanting journey for our visitors. So, who’s up for a user-centric adventure? 🎢

Exploring potential enhancements and updates for the virtual museum tour using Java

Ah, the thrill of gazing into the crystal ball and envisioning future enhancements for our virtual museum tour. From integrating cutting-edge technologies to amplifying the storytelling experience, the future holds endless possibilities for our digital masterpiece ! It’s all about crafting a journey that evolves with time. 🚀

Overall, Let’s Keep Coding and Creating Magic! ✨

As we draw the curtains on this exhilarating escapade through the evolution and implementation of Java programming in the Virtual Museum Tour Project, I urge you to keep the coding flames burning bright. Embrace the challenges, savor the triumphs, and let your creativity run wild as you craft remarkable experiences through code! After all, in the world of programming, magic is just a few keystrokes away. So, here’s to coding, creating, and making history, one line of code at a time! 💻🌟

Program Code – Java in History: Virtual Museum Tour Project

Code output:, code explanation:.

The program begins by defining a MuseumItem class, which represents individual items in our virtual museum. Each MuseumItem has an ID, name, description, and a history. This information is not just some random sentence, it encapsulates the unique narrative of each exhibit.

We then have the VirtualMuseum class that acts as a curator for our digital museum experience. It comes equipped with an ArrayList to store the various MuseumItem objects we’ll be displaying. Our tour is seriously top-notch, as we’ve developed methods like addItem() to add new artifacts, and getItem() to retrieve them by their ID, although we don’t use this method in our main tour – don’t want the visitors getting too overwhelmed, you know?

Now, the magic happens in the tour() method. It prints out a hearty welcome message and then takes the visitors (aka the users) through each exhibit one by one. After drooling over the artifacts’ details, you hit ‘enter’ to move to the next piece of history – just like a real museum, but minus the sore feet.

Lastly, in the main method , it’s clear this ain’t no kid’s lemonade stand. We instantiate our VirtualMuseum and start populating it with priceless ‘MuseumItem’s. I mean, we’ve got ‘The Java Lantern’ and ‘The Algorithmic Scroll’, serious heavyweight titles.

Once we’ve set the stage with our exhibits, we call on tour() to take the stage, guiding our user through this splendid array of Java’s historical gems. So, there you have it, a museum tour that’s so vivid and real, you’d swear you could touch the artifacts. If only your screen was a bit more… 3D.

In closing, hope you enjoyed this journey through our Virtual Museum. Coding museums instead of visiting ’em—the ultimate tech geek paradise! Thanks for sticking around, folks, and remember, in the museum of life, the best exhibits are the ones you code yourself. Keep on coding! 🚀

You Might Also Like

Java in meteorology: weather forecasting project, java project: real-time data synchronization, java and geology: earthquake prediction project, java project: dynamic load balancing in clusters, java in archaeology: artifact analysis project.

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Latest Posts

Top Machine Learning Projects in Python with Source Code for Your Next Project

Machine Learning Projects for Final Year with Source Code: A Comprehensive Guide to Success

Top 10 Machine Learning Projects for Students to Excel in Machine Learning Project

Top Machine Learning Projects for Students: A Compilation of Exciting ML Projects to Boost Your Skills in 2022 Project

Top Machine Learning Projects on GitHub for Deep Learning Enthusiasts – Dive into Exciting Project Ideas Now!

Privacy overview.

Sign in to your account

Username or Email Address

Remember Me

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

tourism-management

Here are 5 public repositories matching this topic..., meenalmahajan / travel-and-tourism-agency.

A desktop based application that helps the tourists to manage their trips , booking hotels and explore various destinations - (Core Java , Swing Framework , MySql).

• Updated Aug 18, 2023

stevenzh / tourismwork

早年整理的旅行社管理软件

• Updated Dec 15, 2022

mutebibrian / QulaTravels

Application which promotes ugandan Tourism sites

• Updated Mar 10, 2019

quasarresearchgroup / PreventCrowding-server

Server side of the Prevent Crowding project

• Updated Dec 26, 2022

Hemanth3246 / TravelAndTourism

Travel and Tourism Project Code in Java

• Updated Jun 13, 2020

Improve this page

Add a description, image, and links to the tourism-management topic page so that developers can more easily learn about it.

Curate this topic

Add this topic to your repo

To associate your repository with the tourism-management topic, visit your repo's landing page and select "manage topics."

• Data Structures
• Linked List
• Binary Tree
• Binary Search Tree
• Segment Tree
• Disjoint Set Union
• Fenwick Tree
• Red-Black Tree
• Advanced Data Structures
• Graph Data Structure And Algorithms
• Introduction to Graphs - Data Structure and Algorithm Tutorials
• Graph and its representations
• Types of Graphs with Examples
• Basic Properties of a Graph
• Applications, Advantages and Disadvantages of Graph
• Transpose graph
• Difference Between Graph and Tree

BFS and DFS on Graph

• Breadth First Search or BFS for a Graph
• Depth First Search or DFS for a Graph
• Applications, Advantages and Disadvantages of Depth First Search (DFS)
• Applications, Advantages and Disadvantages of Breadth First Search (BFS)
• Iterative Depth First Traversal of Graph
• BFS for Disconnected Graph
• Transitive Closure of a Graph using DFS
• Difference between BFS and DFS

Cycle in a Graph

• Detect Cycle in a Directed Graph
• Detect cycle in an undirected graph
• Detect Cycle in a directed graph using colors
• Detect a negative cycle in a Graph | (Bellman Ford)
• Cycles of length n in an undirected and connected graph
• Detecting negative cycle using Floyd Warshall
• Clone a Directed Acyclic Graph

Shortest Paths in Graph

• How to find Shortest Paths from Source to all Vertices using Dijkstra's Algorithm
• Bellman–Ford Algorithm
• Floyd Warshall Algorithm
• Johnson's algorithm for All-pairs shortest paths
• Shortest Path in Directed Acyclic Graph
• Multistage Graph (Shortest Path)
• Shortest path in an unweighted graph
• Karp's minimum mean (or average) weight cycle algorithm
• 0-1 BFS (Shortest Path in a Binary Weight Graph)
• Find minimum weight cycle in an undirected graph

Minimum Spanning Tree in Graph

• Kruskal’s Minimum Spanning Tree (MST) Algorithm
• Difference between Prim's and Kruskal's algorithm for MST
• Applications of Minimum Spanning Tree
• Total number of Spanning Trees in a Graph
• Minimum Product Spanning Tree
• Reverse Delete Algorithm for Minimum Spanning Tree

Topological Sorting in Graph

• Topological Sorting
• All Topological Sorts of a Directed Acyclic Graph
• Kahn's algorithm for Topological Sorting
• Maximum edges that can be added to DAG so that it remains DAG
• Longest Path in a Directed Acyclic Graph
• Topological Sort of a graph using departure time of vertex

Connectivity of Graph

• Articulation Points (or Cut Vertices) in a Graph
• Biconnected Components
• Bridges in a graph
• Eulerian path and circuit for undirected graph
• Fleury's Algorithm for printing Eulerian Path or Circuit
• Strongly Connected Components
• Count all possible walks from a source to a destination with exactly k edges
• Euler Circuit in a Directed Graph
• Word Ladder (Length of shortest chain to reach a target word)
• Find if an array of strings can be chained to form a circle | Set 1
• Tarjan's Algorithm to find Strongly Connected Components
• Paths to travel each nodes using each edge (Seven Bridges of Königsberg)
• Dynamic Connectivity | Set 1 (Incremental)

Maximum flow in a Graph

• Max Flow Problem Introduction
• Ford-Fulkerson Algorithm for Maximum Flow Problem
• Find maximum number of edge disjoint paths between two vertices
• Find minimum s-t cut in a flow network
• Maximum Bipartite Matching
• Channel Assignment Problem
• Introduction to Push Relabel Algorithm
• Introduction and implementation of Karger's algorithm for Minimum Cut
• Dinic's algorithm for Maximum Flow

Some must do problems on Graph

• Find size of the largest region in Boolean Matrix
• Count number of trees in a forest
• A Peterson Graph Problem
• Clone an Undirected Graph
• Introduction to Graph Coloring

Traveling Salesman Problem (TSP) Implementation

• Introduction and Approximate Solution for Vertex Cover Problem
• Erdos Renyl Model (for generating Random Graphs)
• Chinese Postman or Route Inspection | Set 1 (introduction)
• Hierholzer's Algorithm for directed graph
• Boggle (Find all possible words in a board of characters) | Set 1
• Hopcroft–Karp Algorithm for Maximum Matching | Set 1 (Introduction)
• Construct a graph from given degrees of all vertices
• Determine whether a universal sink exists in a directed graph
• Number of sink nodes in a graph
• Two Clique Problem (Check if Graph can be divided in two Cliques)

Travelling Salesman Problem (TSP) : Given a set of cities and distances between every pair of cities, the problem is to find the shortest possible route that visits every city exactly once and returns to the starting point.  Note the difference between Hamiltonian Cycle and TSP. The Hamiltonian cycle problem is to find if there exists a tour that visits every city exactly once. Here we know that Hamiltonian Tour exists (because the graph is complete) and in fact, many such tours exist, the problem is to find a minimum weight Hamiltonian Cycle.  For example, consider the graph shown in the figure on the right side. A TSP tour in the graph is 1-2-4-3-1. The cost of the tour is 10+25+30+15 which is 80. The problem is a famous NP-hard problem. There is no polynomial-time known solution for this problem.   

Examples: 

In this post, the implementation of a simple solution is discussed.

• Consider city 1 as the starting and ending point. Since the route is cyclic, we can consider any point as a starting point.
• Generate all (n-1)! permutations of cities.
• Calculate the cost of every permutation and keep track of the minimum cost permutation.
• Return the permutation with minimum cost.

Below is the implementation of the above idea 

Time complexity:  O(n!) where n is the number of vertices in the graph. This is because the algorithm uses the next_permutation function which generates all the possible permutations of the vertex set.  Auxiliary Space: O(n) as we are using a vector to store all the vertices.

Please Login to comment...

Similar reads.

• NP Complete

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Travel Management System Project In Java With Source Code

The Travel Management System Project In Java was developed in  JAVA Programming  using  NetBeans IDE , This  Java Project With Source Code  was designed using a Graphical User Interface (GUI).

This project in Java NetBeans Uses a Selection Statement (If Statement), a Random Function Generator, and the following components, JTextField, JTextArea, JLabel, JRadioButton, and JComboBox.

Please enable JavaScript

A Travel Agency Management System Project In Java is a simple Java project for beginners containing source code from which students can learn how to construct good Java projects.

We also provide significant Java projects for final-year students as well as mini Java projects for semester students.

This  JAVA Project  also includes a Java Project Free Download Source Code, just find the downloadable source code below and click to start downloading.

To start executing a  Travel Management System With Source Code, make sure that you have    NetBeans IDE  or any platform Java installed on your computer.

About The Travel Management System Project

Steps on how to run travel management system project in java.

Time needed:  5 minutes

Travel Management System Project In Java

Complete Source Code

Downloadable Source Code Below

Anyway, if you want to level up your programming knowledge, especially Java, try this new article I’ve made for you  Best Java Projects With Source Code For Beginners Free Download .

The  Java Project With Source Code  is built fully in Java and MySQL Database. It has a full-featured Graphical User Interface (GUI) with all the functionalities.

This article is a way to enhance and develop our skills and logic ideas which is important in practicing the Java programming language which is the most well-known and most usable programming language in many companies.

This Simple Project also includes a downloadable source code for free.

Related articles below

• Load data from MySQL database to Combo box Using Java
• How to use Scanner in Java Tutorial Using Netbeans IDE
• Update Data using MySQL Database and Java with Netbeans IDE
• How to convert text to speech in Java Tutorial using Netbeans IDE
• How to Load data from Mysql Database to Table Element Using Java

If you have any questions or suggestions about the Travel Management System Project In Java With Source Code , please feel free to leave a comment below.

Leave a Comment Cancel reply

You must be logged in to post a comment.