feat: ids algorithm

Author: graceevelyns

src/main_scene/main_scene.cpp

@@ -3,6 +3,7 @@
 #include "../search/bfs/bfs.hpp"
 #include "../search/ucs/ucs.hpp"
 #include "../search/astar/astar.hpp"
+#include "../search/ids/ids.hpp"
 
 MainScene::MainScene() {}
 MainScene::~MainScene() {}
@@ -49,6 +50,7 @@ void MainScene::_notification(int p_what) {
                 algo_button->add_item("Greedy Best First Search");
                 algo_button->add_item("Uniform Cost Search");
                 algo_button->add_item("A* Search");
+                algo_button->add_item("Iterative Deepening Search");
                 algo_button->select(0);
             } 
 
@@ -139,7 +141,7 @@ void MainScene::_on_solve_button_pressed() {
             is_searching = false;
             break;
         }
-        case ASTAR:
+        case ASTAR: {
             solution = astar::search_astar(board, pieces);
             is_searching = true;
 
@@ -150,6 +152,19 @@ void MainScene::_on_solve_button_pressed() {
             }
             is_searching = false;
             break;
+        }
+        case IDS: {
+            solution = ids::search_ids(board, pieces);
+            is_searching = true;
+
+            if (is_solved = solution.is_solved) {
+                UtilityFunctions::print("IDS found a solution!");
+            } else {
+                UtilityFunctions::print("IDS could not find a solution.");
+            }
+            is_searching = false;
+            break;
+        }
         default:
             UtilityFunctions::printerr("Unknown algorithm selected");
             break;
@@ -330,6 +345,10 @@ void MainScene::_on_algo_button_selected(int index) {
             UtilityFunctions::print("A* selected");
             algo_type = ASTAR;
             break;
+        case IDS:
+            UtilityFunctions::print("IDS selected");
+            algo_type = IDS;
+            break;
         default:
             UtilityFunctions::printerr("Unknown algorithm selected");
             break;

src/search/ids/ids.cpp

@@ -0,0 +1,67 @@
+#include "ids.hpp"
+
+// helper
+SearchNode dls(SearchNode current_node, const Board& initial_board, int limit, int& nodes_total, set<string>& visited) {
+    nodes_total++;
+
+    if (Utils::is_exit(initial_board, current_node.pieces)) {
+        return current_node;
+    }
+
+    // jika batas kedalaman saat ini (current_node.val) telah mencapai limit DLS, berhenti
+    if (current_node.val >= limit) {
+        return SearchNode({}, initial_board, {}, -1);
+    }
+
+    vector<SearchNode> next = Utils::generate_next(current_node, [](const Board&, const vector<Piece>&, const SearchNode& parent_node) {
+        return parent_node.val + 1;
+    });
+
+    for (const auto& successor_node : next) {
+        string next_state = Utils::state_to_string(successor_node.pieces);
+        
+        if (visited.find(next_state) == visited.end()) {
+            visited.insert(next_state);
+
+            SearchNode result_node = dls(successor_node, initial_board, limit, nodes_total, visited);
+            
+            visited.erase(next_state); // backtrack
+
+            if (result_node.val != -1) {
+                return result_node;
+            }
+        }
+    }
+    return SearchNode({}, initial_board, {}, -1); // tidak ada solusi ditemukan
+}
+
+Solution ids::search_ids(const Board& initial_board, const vector<Piece>& initial_pieces) {
+    auto time_start = chrono::high_resolution_clock::now();
+    Solution result;
+    result.node = 0;
+
+    const int MAX_DEPTH_LIMIT = 100;
+
+    for (int depth_limit = 0; depth_limit <= MAX_DEPTH_LIMIT; ++depth_limit) {        
+        SearchNode initial_node(initial_pieces, initial_board, {}, 0);
+        set<string> visited_dls;
+        
+        visited_dls.insert(Utils::state_to_string(initial_node.pieces));
+
+        SearchNode found = dls(initial_node, initial_board, depth_limit, result.node, visited_dls);
+
+        if (found.val != -1) {
+            result.is_solved = true;
+            result.moves = found.path;
+            auto time_end = chrono::high_resolution_clock::now();
+            result.duration = chrono::duration<double, milli>(time_end - time_start);
+           
+            return result;
+        }
+    }
+    auto time_end = chrono::high_resolution_clock::now();
+    result.duration = chrono::duration<double, milli>(time_end - time_start);
+    result.is_solved = false;
+
+    return result;
+}

src/search/ids/ids.hpp

@@ -0,0 +1,12 @@
+#ifndef IDS_HPP
+#define IDS_HPP
+
+#include "../../main_scene/main_scene.hpp"
+#include "../../utils/utils.hpp"
+
+class ids {
+public:
+    static Solution search_ids(const Board& initial_board, const std::vector<Piece>& initial_pieces);
+};
+
+#endif

src/utils/utils.hpp

@@ -18,6 +18,7 @@ enum AlgoType {
     BFS,
     UCS,
     ASTAR,
+    IDS,
 };
 
 struct Coordinates {