Key Changes Made:

Removed <bits/stdc++.h>: Ensured portability by using specific headers.
Namespace: Avoided using namespace std; for better practices.
Test Function: Created testSolve8TilePuzzle() to handle test cases and moved all main logic there.
Maintained Clarity: The main() function now only calls the test function for cleaner structure.

Author: sushskvnitn

search/Iterative_deepening_search_8_tile_puzzle.cpp

@@ -1,28 +1,32 @@
-#include <bits/stdc++.h>
-using namespace std;
+#include <iostream>      // for IO operations
+#include <vector>       // for std::vector
+#include <set>          // for std::set
+#include <limits>       // for std::numeric_limits
+
 /**
  * @file
- * @brief Implementation of Iterative deepening Search algorithm
+ * @brief Implementation of the Iterative Deepening Search algorithm for the 8-tile puzzle.
  * @author [Sushant Kogurwar](https://github.com/sushskvnitn)
  */
-#define N 3 // Define the size of the tile puzzle (3x3)
+
+#define N 3  ///< Define the size of the tile puzzle (3x3)
 
 /**
  * @class Node
  * @brief Represents a state in the 8-tile puzzle.
  */
 class Node {
 private:
-    vector<vector<int>> state;        ///< Current state of the puzzle
-    pair<int, int> blankIndex;        ///< Index of the blank tile (0)
-    Node *parent;                     ///< Parent node for tracing back the solution
-    int depth;                        ///< Depth of the current node in the search tree
+    std::vector<std::vector<int>> state;        ///< Current state of the puzzle
+    std::pair<int, int> blankIndex;             ///< Index of the blank tile (0)
+    Node *parent;                                ///< Parent node for tracing back the solution
+    int depth;                                   ///< Depth of the current node in the search tree
 
     /**
      * @brief Finds the index of the blank tile in the current state.
      * @return Pair of indices (row, column) of the blank tile.
      */
-    pair<int, int> findBlankIndex() {
+    std::pair<int, int> findBlankIndex() {
         for (int i = 0; i < N; i++) {
             for (int j = 0; j < N; j++) {
                 if (state[i][j] == 0) {
@@ -40,53 +44,31 @@ class Node {
      * @param parent Pointer to the parent node.
      * @param depth Depth of the node.
      */
-    Node(const vector<vector<int>> &state, Node *parent, int depth) 
+    Node(const std::vector<std::vector<int>> &state, Node *parent, int depth) 
         : state(state), parent(parent), depth(depth) {
         blankIndex = findBlankIndex();
     }
 
-    vector<vector<int>> getState() const { return state; }
-    pair<int, int> getBlankIndex() const { return blankIndex; }
+    std::vector<std::vector<int>> getState() const { return state; }
+    std::pair<int, int> getBlankIndex() const { return blankIndex; }
     int getDepth() const { return depth; }
 };
 
 /**
  * @class Solve8TilePuzzle
  * @brief A class to solve the 8-tile puzzle using Iterative Deepening Search (IDS).
- *
- * @details
- * This class implements a solution for the 8-tile puzzle, where the goal is to
- * rearrange the tiles from a given initial state to a specified goal state.
- * The algorithm uses Iterative Deepening Search, which combines the benefits of
- * depth-first search (space efficiency) and breadth-first search (completeness).
- *
- * The initial state of the puzzle is provided by the user, and the algorithm
- * checks if the puzzle is solvable based on the number of inversions in the array.
- * If the puzzle is solvable, it attempts to find the solution using a depth-limited
- * search approach, increasing the depth limit iteratively until a solution is found
- * or it is confirmed that no solution exists.
- *
- * The implementation ensures that:
- * - The space complexity is efficient, as it avoids storing large states in memory.
- * - The time complexity is less than O(n^2) due to the iterative deepening approach.
- * - The original array remains unmodified throughout the process.
- *
- * If the puzzle is not solvable, the algorithm returns a message indicating this.
- * 
- * @note The blank tile is represented by 0 in the puzzle.
  */
-
 class Solve8TilePuzzle {
 public:
-    vector<vector<int>> initialState, goalState; ///< Initial and goal states
-    set<vector<vector<int>>> visitedList;        ///< Set to track visited states
+    std::vector<std::vector<int>> initialState, goalState; ///< Initial and goal states
+    std::set<std::vector<std::vector<int>>> visitedList;   ///< Set to track visited states
 
     /**
      * @brief Constructor for Solve8TilePuzzle class.
      * @param initialState Initial state of the puzzle.
      * @param goalState Goal state of the puzzle.
      */
-    Solve8TilePuzzle(const vector<vector<int>> &initialState, const vector<vector<int>> &goalState)
+    Solve8TilePuzzle(const std::vector<std::vector<int>> &initialState, const std::vector<std::vector<int>> &goalState)
         : initialState(initialState), goalState(goalState) {}
 
     bool boundsOK(int i, int j) const {
@@ -108,20 +90,21 @@ class Solve8TilePuzzle {
             return true;
         }
 
-        const vector<vector<int>> dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
+        const std::vector<std::vector<int>> dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
         for (const auto &dir : dirs) {
             int newI = currNode->getBlankIndex().first + dir[0];
             int newJ = currNode->getBlankIndex().second + dir[1];
 
             if (!boundsOK(newI, newJ)) continue;
 
-            vector<vector<int>> newState = currNode->getState();
-            swap(newState[currNode->getBlankIndex().first][currNode->getBlankIndex().second], newState[newI][newJ]);
+            std::vector<std::vector<int>> newState = currNode->getState();
+            std::swap(newState[currNode->getBlankIndex().first][currNode->getBlankIndex().second], newState[newI][newJ]);
             Node *newNode = new Node(newState, currNode, currNode->getDepth() + 1);
 
             if (visitedList.find(newNode->getState()) == visitedList.end()) {
                 if (dls(newNode, depthLimit)) return true;
             }
+            delete newNode; // Prevent memory leak
         }
         return false;
     }
@@ -130,10 +113,14 @@ class Solve8TilePuzzle {
      * @brief Initiates the iterative deepening search to solve the puzzle.
      */
     void iterativeDeepeningSearch() {
-        for (int depth = 0; depth < INT_MAX; depth++) {
+        for (int depth = 0; depth < std::numeric_limits<int>::max(); depth++) {
             visitedList.clear();
             Node *root = new Node(initialState, nullptr, 0);
-            if (dls(root, depth)) return;
+            if (dls(root, depth)) {
+                delete root; // Clean up
+                return;
+            }
+            delete root; // Clean up
         }
     }
 
@@ -142,7 +129,7 @@ class Solve8TilePuzzle {
      * @param node The node at which the solution is found.
      */
     void printSolution(Node *node) {
-        cout << "Solution found at depth " << node->getDepth() << endl;
+        std::cout << "Solution found at depth " << node->getDepth() << std::endl;
         // Trace back to print the solution path if necessary
     }
 
@@ -168,30 +155,48 @@ class Solve8TilePuzzle {
  * @brief Takes user input for the initial state of the puzzle.
  * @param initialState Reference to the 2D vector where the input will be stored.
  */
-void takeUserInput(vector<vector<int>> &initialState) {
-    cout << "Enter the initial state of the 8-tile puzzle (0 for blank tile):\n";
+void takeUserInput(std::vector<std::vector<int>> &initialState) {
+    std::cout << "Enter the initial state of the 8-tile puzzle (0 for blank tile):\n";
     for (int i = 0; i < N; i++) {
         for (int j = 0; j < N; j++) {
-            cin >> initialState[i][j];
+            std::cin >> initialState[i][j];
         }
     }
 }
 
 /**
- * @brief Main function to run the 8-tile puzzle solver.
+ * @brief Test function to run the 8-tile puzzle solver with predefined cases.
  */
-int main() {
-    vector<vector<int>> initialState(N, vector<int>(N, 0));
-    vector<vector<int>> goalState = {{1, 2, 3}, {4, 5, 6}, {7, 8, 0}};
-
-    takeUserInput(initialState);
+void testSolve8TilePuzzle() {
+    // Test Case 1: Solvable case
+    std::vector<std::vector<int>> initialState1 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 0}};
+    std::vector<std::vector<int>> goalState = {{1, 2, 3}, {4, 5, 6}, {7, 8, 0}};
+    
+    Solve8TilePuzzle puzzle1(initialState1, goalState);
+    if (puzzle1.isSolvable()) {
+        std::cout << "Test Case 1: ";
+        puzzle1.iterativeDeepeningSearch();
+    } else {
+        std::cout << "Test Case 1: Not Solvable" << std::endl;
+    }
 
-    Solve8TilePuzzle solvePuzzle(initialState, goalState);
-    if (solvePuzzle.isSolvable()) {
-        solvePuzzle.iterativeDeepeningSearch();
+    // Test Case 2: Unsolvable case
+    std::vector<std::vector<int>> initialState2 = {{1, 2, 3}, {4, 5, 6}, {0, 7, 8}};
+    
+    Solve8TilePuzzle puzzle2(initialState2, goalState);
+    if (puzzle2.isSolvable()) {
+        std::cout << "Test Case 2: ";
+        puzzle2.iterativeDeepeningSearch();
     } else {
-        cout << "\nNot Solvable" << endl;
+        std::cout << "Test Case 2: Not Solvable" << std::endl;
     }
+}
 
+/**
+ * @brief Main function to run the test function.
+ * @returns 0 on exit
+ */
+int main() {
+    testSolve8TilePuzzle();
     return 0;
 }