Menyusun Roadmap Belajar

#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <iomanip>
#include <queue>
using namespace std;

struct Topic {
    string slug;
    string title;
    int difficulty;       // 1=mudah, 2=menengah, 3=sulit
    int est_hours;        // estimasi jam belajar
    vector<string> prereq;
};

class RoadmapPlanner {
public:
    void addTopic(const Topic& t) {
        topics_[t.slug] = t;
    }

    // Topological sort berdasarkan prerequisite (Kahn)
    vector<string> topoSort() {
        unordered_map<string,int> in_deg;
        unordered_map<string, vector<string>> adj;
        for (const auto& kv : topics_) {
            in_deg[kv.first] = kv.second.prereq.size();
            for (const auto& p : kv.second.prereq) {
                adj[p].push_back(kv.first);
            }
        }
        // priority_queue: difficulty rendah dulu, alphabetic tie-break
        auto cmp = [this](const string& a, const string& b) {
            int da = topics_[a].difficulty;
            int db = topics_[b].difficulty;
            if (da != db) return da > db;
            return a > b;
        };
        priority_queue<string, vector<string>, decltype(cmp)> ready(cmp);

        for (const auto& kv : in_deg) {
            if (kv.second == 0) ready.push(kv.first);
        }

        vector<string> order;
        while (!ready.empty()) {
            string cur = ready.top(); ready.pop();
            order.push_back(cur);
            for (const auto& next : adj[cur]) {
                if (--in_deg[next] == 0) ready.push(next);
            }
        }
        return order;
    }

    // Alokasi topik ke minggu (kapasitas jam per minggu)
    void planWeekly(int hours_per_week, int total_weeks) {
        auto order = topoSort();
        cout << "=== Roadmap Belajar DSA ===\n";
        cout << "Estimasi " << hours_per_week << " jam/minggu, "
             << total_weeks << " minggu total\n\n";

        int week = 1;
        int used = 0;
        cout << "Minggu " << week << ":\n";
        for (const auto& slug : order) {
            const Topic& t = topics_[slug];
            if (used + t.est_hours > hours_per_week && used > 0) {
                cout << "  (subtotal: " << used << " jam)\n\n";
                week++;
                if (week > total_weeks) {
                    cout << "... (sisanya tidak muat, perluas total_weeks)\n";
                    break;
                }
                cout << "Minggu " << week << ":\n";
                used = 0;
            }
            cout << "  [" << difficultyLabel(t.difficulty) << "] "
                 << left << setw(28) << t.title
                 << " (" << t.est_hours << " jam)\n";
            used += t.est_hours;
        }
        if (week <= total_weeks && used > 0) {
            cout << "  (subtotal: " << used << " jam)\n";
        }
        cout << "\nTotal topik: " << order.size()
             << ", total jam: " << totalHours() << "\n";
    }

private:
    unordered_map<string, Topic> topics_;

    int totalHours() const {
        int s = 0;
        for (const auto& kv : topics_) s += kv.second.est_hours;
        return s;
    }

    static string difficultyLabel(int d) {
        switch (d) {
            case 1: return "MUDAH";
            case 2: return "MENENGAH";
            case 3: return "SULIT";
            default: return "?";
        }
    }
};

int main() {
    RoadmapPlanner plan;

    plan.addTopic({"array", "Array & Dynamic Array", 1, 4, {}});
    plan.addTopic({"string", "String & Basic Matching", 1, 3, {}});
    plan.addTopic({"linked-list", "Linked List", 1, 4, {}});
    plan.addTopic({"stack", "Stack", 1, 3, {"array"}});
    plan.addTopic({"queue", "Queue", 1, 3, {"array"}});
    plan.addTopic({"hashing", "Hashing & Hash Map", 2, 6, {"array"}});
    plan.addTopic({"sorting", "Sorting Algorithms", 2, 8, {"array"}});
    plan.addTopic({"searching", "Searching", 1, 4, {"array"}});
    plan.addTopic({"tree", "Binary Tree", 2, 8, {"linked-list", "stack"}});
    plan.addTopic({"heap", "Heap & Priority Queue", 2, 6, {"array", "tree"}});
    plan.addTopic({"graph", "Graph Representation", 2, 6, {"hashing"}});
    plan.addTopic({"bfs-dfs", "BFS & DFS", 2, 8, {"graph", "stack", "queue"}});
    plan.addTopic({"shortest-path", "Shortest Path (Dijkstra)", 3, 10, {"heap", "bfs-dfs"}});
    plan.addTopic({"greedy", "Greedy Algorithms", 2, 6, {"sorting", "heap"}});
    plan.addTopic({"dp", "Dynamic Programming", 3, 12, {"array", "recursion"}});
    plan.addTopic({"recursion", "Recursion & Backtracking", 2, 8, {"stack", "tree"}});

    plan.planWeekly(6, 12);
    return 0;
}

=== Roadmap Belajar DSA ===
Estimasi 6 jam/minggu, 12 minggu total

Minggu 1:
  [MUDAH] Array & Dynamic Array        (4 jam)
  (subtotal: 4 jam)

Minggu 2:
  [MUDAH] Linked List                  (4 jam)
  (subtotal: 4 jam)

Minggu 3:
  [MUDAH] Queue                        (3 jam)
  (subtotal: 3 jam)

Minggu 4:
  [MUDAH] Searching                    (4 jam)
  (subtotal: 4 jam)

Minggu 5:
  [MUDAH] Stack                        (3 jam)
  [MUDAH] String & Basic Matching      (3 jam)
  (subtotal: 6 jam)

Minggu 6:
  [MENENGAH] Hashing & Hash Map           (6 jam)
  (subtotal: 6 jam)

Minggu 7:
  [MENENGAH] Graph Representation         (6 jam)
  (subtotal: 6 jam)

Minggu 8:
  [MENENGAH] BFS & DFS                    (8 jam)
  (subtotal: 8 jam)

Minggu 9:
  [MENENGAH] Sorting Algorithms           (8 jam)
  (subtotal: 8 jam)

Minggu 10:
  [MENENGAH] Binary Tree                  (8 jam)
  (subtotal: 8 jam)

Minggu 11:
  [MENENGAH] Heap & Priority Queue        (6 jam)
  (subtotal: 6 jam)

Minggu 12:
  [MENENGAH] Greedy Algorithms            (6 jam)
  (subtotal: 6 jam)

... (sisanya tidak muat, perluas total_weeks)

Total topik: 16, total jam: 99