Add files via upload

can u please check this  files ,so u can merge it 

Signed-off-by: abhijeet147 <117306670+abhijeet147@users.noreply.github.com>

Author: abhijeet147

Duplicate_subtree.cpp

@@ -0,0 +1,57 @@
+#include <iostream>
+#include <unordered_map>
+#include <string>
+
+class Node {
+public:
+    int data;
+    Node* left;
+    Node* right;
+
+    Node(int data) : data(data), left(nullptr), right(nullptr) {}
+};
+
+std::string inorder(Node* root, std::unordered_map<std::string, int>& m) {
+    if (root == nullptr) {
+        return "";
+    }
+
+    std::string s = "(";
+    s += inorder(root->left, m);
+    s += std::to_string(root->data);
+    s += inorder(root->right, m);
+    s += ")";
+    
+    if (m.find(s) != m.end() && m[s] == 1) {
+        std::cout << root->data << " ";
+    }
+
+    if (m.find(s) != m.end()) {
+        m[s] += 1;
+    } else {
+        m[s] = 1;
+    }
+
+    return s;
+}
+
+int main() {
+    Node* root = new Node(1);
+    root->left = new Node(2);
+    root->right = new Node(3);
+    root->left->left = new Node(4);
+    root->right->left = new Node(2);
+    root->right->left->left = new Node(4);
+
+    std::unordered_map<std::string, int> m;
+    inorder(root, m);
+
+    // Clean up dynamically allocated memory
+    delete root->right->left->left;
+    delete root->right->left;
+    delete root->left->left;
+    delete root->left;
+    delete root;
+
+    return 0;
+}

Pathfinding_algorithm.cpp

@@ -0,0 +1,88 @@
+#include <iostream>
+#include <deque>
+#include <vector>
+
+using namespace std;
+
+class Point {
+public:
+    int x, y;
+    Point(int _x, int _y) : x(_x), y(_y) {}
+};
+
+class QueueNode {
+public:
+    Point pt;
+    int dist;
+    QueueNode(Point _pt, int _dist) : pt(_pt), dist(_dist) {}
+};
+
+bool valid(int row, int col, int ROW, int COL) {
+    return row >= 0 && row < ROW && col >= 0 && col < COL;
+}
+
+int BFS(vector<vector<int>>& matrix, Point source, Point destination) {
+    int ROW = matrix.size();
+    int COL = matrix[0].size();
+
+    if (matrix[source.x][source.y] != 1 || matrix[destination.x][destination.y] != 1)
+        return -1;
+
+    vector<vector<bool>> visited(ROW, vector<bool>(COL, false));
+    visited[source.x][source.y] = true;
+
+    deque<QueueNode> q;
+    QueueNode s(source, 0);
+    q.push_back(s);
+
+    int rowNum[] = {-1, 0, 0, 1};
+    int colNum[] = {0, -1, 1, 0};
+
+    while (!q.empty()) {
+        QueueNode curr = q.front();
+        Point pt = curr.pt;
+        q.pop_front();
+
+        if (pt.x == destination.x && pt.y == destination.y)
+            return curr.dist;
+
+        for (int i = 0; i < 4; i++) {
+            int row = pt.x + rowNum[i];
+            int col = pt.y + colNum[i];
+
+            if (valid(row, col, ROW, COL) && matrix[row][col] == 1 && !visited[row][col]) {
+                visited[row][col] = true;
+                QueueNode adj_cell(Point(row, col), curr.dist + 1);
+                q.push_back(adj_cell);
+            }
+        }
+    }
+
+    return -1;
+}
+
+int main() {
+    vector<vector<int>> matrix = {
+        {1, 1, 1, 1, 1, 1, 0, 1, 1, 1},
+        {0, 0, 1, 0, 1, 1, 1, 0, 1, 1},
+        {1, 1, 1, 0, 1, 1, 0, 1, 0, 1},
+        {0, 0, 0, 0, 1, 0, 0, 0, 0, 1},
+        {1, 1, 1, 0, 1, 1, 1, 0, 1, 0},
+        {1, 0, 1, 1, 1, 1, 0, 1, 0, 0},
+        {1, 0, 0, 0, 0, 0, 0, 0, 0, 1},
+        {1, 0, 1, 1, 1, 1, 0, 1, 1, 1},
+        {1, 1, 0, 0, 0, 0, 1, 0, 0, 1}
+    };
+
+    Point source(0, 0);
+    Point destination(5, 5);
+
+    int distance = BFS(matrix, source, destination);
+
+    if (distance == -1)
+        cout << "Not possible" << endl;
+    else
+        cout << "Shortest distance: " << distance << endl;
+
+    return 0;
+}

Shortes_job_first.cpp

@@ -0,0 +1,59 @@
+#include <iostream>
+#include <vector>
+#include <queue>
+
+using namespace std;
+
+class Task {
+public:
+    int arrivalTime;
+    int processingTime;
+    int index;
+
+    Task(int arrTime, int procTime, int idx) : arrivalTime(arrTime), processingTime(procTime), index(idx) {}
+
+    bool operator<(const Task& other) const {
+        return processingTime > other.processingTime;  // Min-heap based on processing time
+    }
+};
+
+vector<int> shortestJobFirst(vector<vector<int>>& tasks) {
+    int n = tasks.size();
+
+    // Create Task objects and store them in a priority queue (min-heap) based on processing time
+    priority_queue<Task> taskQueue;
+    for (int i = 0; i < n; ++i) {
+        Task task(tasks[i][0], tasks[i][1], i);
+        taskQueue.push(task);
+    }
+
+    vector<int> orderedTasks;
+    int currentTime = 0;
+
+    while (!taskQueue.empty()) {
+        Task currentTask = taskQueue.top();
+        taskQueue.pop();
+
+        // If the arrival time is later than the current time, update the current time
+        if (currentTask.arrivalTime > currentTime)
+            currentTime = currentTask.arrivalTime;
+
+        // Execute the current task
+        currentTime += currentTask.processingTime;
+        orderedTasks.push_back(currentTask.index);
+    }
+
+    return orderedTasks;
+}
+
+int main() {
+    vector<vector<int>> tasks = {{1, 2}, {2, 4}, {3, 2}, {4, 1}};
+    vector<int> orderedTasks = shortestJobFirst(tasks);
+
+    cout << "Order of Tasks: ";
+    for (int i : orderedTasks)
+        cout << i << " ";
+    cout << endl;
+
+    return 0;
+}

SpiralMatrix.cpp

@@ -0,0 +1,63 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+void spiral_matrix() {
+    int i = 0;  // starting row index
+    int j = 0;  // starting column index
+    int c = 0;
+    int no;
+
+    cout << "Please enter number of rows of the spiral matrix: ";
+    cin >> no;
+
+    int high = no * no;
+    int val = 1;
+
+    vector<vector<int>> a(no, vector<int>(no, 0));
+
+    while (val <= high) {
+        while (j < no - 1) {  // for first row
+            a[i][j] = val;
+            val++;
+            j++;
+        }
+        while (i < no - 1) {  // for last column
+            a[i][j] = val;
+            val++;
+            i++;
+        }
+        while (j > c) {  // for last row
+            a[i][j] = val;
+            val++;
+            j--;
+        }
+        while (i > c) {  // for first column
+            a[i][j] = val;
+            val++;
+            i--;
+        }
+        no--;
+        i++;
+        j++;
+        c++;
+        if (val == high) {  // for odd matrix size
+            a[i][j] = val;
+            break;
+        }
+    }
+
+    cout << "Spiral matrix is:" << endl;
+    for (const auto& row : a) {
+        for (int element : row) {
+            cout << element << " ";
+        }
+        cout << endl;
+    }
+}
+
+int main() {
+    spiral_matrix();
+    return 0;
+}