from machine import Pin
import time
led=Pin(25,Pin.OUT)
while True :
    led.toggle()
    time.sleep(1)#1秒ごとにLEDのON/OFFを切り替え

from machine import Pin
import utime
#ボタンをGPIO15に接続、入力モード、内部プルアップ
button_num=15
button=Pin(button_num,Pin.IN,Pin.PULL_UP)
#GP25はボード上のLED、外部LEDはGP16に接続
led1_num=25
led2_num=16
led1=Pin(led1_num,Pin.OUT)
led2=Pin(led2_num,Pin.OUT)

while True :
    led2.off()#外部LEDをオフ
    if(button.value()==0):#ボタンが押されたか判定（押下時0）
        utime.sleep(0.01)
        if(button.value()==0):#ソフトウェアデバウンス
            led1.toggle()#ボード上のLEDを反転
            led2.on()#外部LEDを点灯（GP16高電位）
            print("The button is pressed.")
            while (button.value()==0):
            #ボタンが押された状態で待機（外部LEDは点灯したまま）
                utime.sleep(0.01)

from machine import Pin,PWM
import time

led=PWM(Pin(25))#ボード上のLEDをPWMオブジェクトとして初期化
led.freq(1000)#周波数設定
led_duty=0#初期値
led_direction=1#ステップ幅

while True:
    led_duty+=led_direction#デューティ比を増加/減少
    if led_duty>=100:#最大
        led_duty=100
        led_direction=-1
    elif led_duty<=0:#最小
        led_duty=0
        led_direction=1
        
    led.duty_u16(int(led_duty*655.36))#デューティ比値変換
    
    if led_duty%5==0:
        print(led_duty)#グラフ観測用
    
    time.sleep(0.01)
    #周期2秒

// 最早開始時間の計算
void calculateEarliestStart() {
    queue<int> q;
    for (const Activity& activity : activities) {// トポロジカルソートを走査
        if (activity.next.empty()) {//あるノードの隣接リストが空の場合（開始イベント）
            q.push(activity.id);//キューに入れる
            earliestStart[activity.id] = 0;//最早開始時間を0に設定
        }
    }

    while (!q.empty()) {//キューが空でない場合
        int currentId = q.front();//最優先イベントcurrentIdを取り出す
        q.pop();

        for (int nextId : activities[currentId].next) {//currentIdの隣接リストを走査
            earliestStart[nextId] = max(earliestStart[nextId], earliestStart[currentId] + activities[currentId].duration);
            // nextIdの最早開始時間==max{現在記録されている最早開始時間,前置きノードcurrentIdの最早開始時間+currentIdイベント時間}
            q.push(nextId);
        }
    }
}

// 最遅開始時間の計算
void calculateLatestStart() {
    latestStart = earliestStart;//最遅開始時間を最早開始時間で初期化

    for (int i = activities.size() - 1; i >= 0; --i) {//最後のイベントiから逆方向に走査
        for (int nextId : activities[i].next) {
            latestStart[i] = min(latestStart[i], latestStart[nextId] - activities[i].duration);
            // 現在のイベントの最遅開始時間==min{記録されている最遅開始時間,次のイベントnextIdの最遅開始時間-現在のイベントiの所要時間}
        }
    }
}

// プロジェクト活動を表す構造体
struct Activity {
    int id;      // 活動番号
    int duration; // 所要時間
    vector<int> next; // 後続活動
};

Critical Path: 0 1 2 3 4 5 
Activity 0: ES=0, LS=0
Activity 1: ES=2, LS=2
Activity 2: ES=6, LS=6
Activity 3: ES=9, LS=9
Activity 4: ES=14, LS=14
Activity 5: ES=16, LS=16

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

// プロジェクト活動を表す構造体
struct Activity {
    int id;      // 活動番号
    int duration; // 所要時間
    vector<int> next; // 後続活動
};

class Project {
private:
    vector<Activity> activities; // プロジェクト活動を格納するベクトル
    vector<int> earliestStart;   // 最早開始時間
    vector<int> latestStart;     // 最遅開始時間

public:
    // 活動の追加
    void addActivity(int id, int duration, const vector<int>& next) {
        activities.push_back({id, duration, next});
    }

    // 最早開始時間の計算
    void calculateEarliestStart() {
        queue<int> q;
        for (const Activity& activity : activities) {// トポロジカルソートを走査
            if (activity.next.empty()) {//あるノードの隣接リストが空の場合（開始イベント）
                q.push(activity.id);//キューに入れる
                earliestStart[activity.id] = 0;//最早開始時間を0に設定
            }
        }

        while (!q.empty()) {//キューが空でない場合
            int currentId = q.front();//最優先イベントcurrentIdを取り出す
            q.pop();

            for (int nextId : activities[currentId].next) {//currentIdの隣接リストを走査
                earliestStart[nextId] = max(earliestStart[nextId], earliestStart[currentId] + activities[currentId].duration);
                // nextIdの最早開始時間==max{現在記録されている最早開始時間,前置きノードcurrentIdの最早開始時間+currentIdイベント時間}
                q.push(nextId);
            }
        }
    }

    // 最遅開始時間の計算
    void calculateLatestStart() {
        latestStart = earliestStart;//最遅開始時間を最早開始時間で初期化

        for (int i = activities.size() - 1; i >= 0; --i) {//最後のイベントiから逆方向に走査
            for (int nextId : activities[i].next) {
                latestStart[i] = min(latestStart[i], latestStart[nextId] - activities[i].duration);
                // 現在のイベントの最遅開始時間==min{記録されている最遅開始時間,次のイベントnextIdの最遅開始時間-現在のイベントiの所要時間}
            }
        }
    }

    // クリティカルパスの出力
    void printCriticalPath() {
        cout << "Critical Path: ";
        for (const Activity& activity : activities) {//トポロジカルソートを順方向に走査
            if (earliestStart[activity.id] == latestStart[activity.id]) {//クリティカルパス上のイベントの最早開始時間==最遅開始時間
                cout << activity.id << " ";
            }
        }
        cout << endl;
    }

    // 最早開始時間と最遅開始時間の出力
    void printTimeInfo() {
        for (const Activity& activity : activities) {
            cout << "Activity " << activity.id << ": ES=" << earliestStart[activity.id]
                 << ", LS=" << latestStart[activity.id] << endl;
        }
    }

    // 初期化関数の構築
    Project(int numActivities) : earliestStart(numActivities), latestStart(numActivities) {}

};

int main() {
    Project project(6); // 6つの活動を仮定

    // 活動の追加、各活動のフォーマットは：活動番号、所要時間、後続活動番号
    project.addActivity(0, 2, {1});
    project.addActivity(1, 4, {2});
    project.addActivity(2, 3, {3});
    project.addActivity(3, 5, {4});
    project.addActivity(4, 2, {5});
    project.addActivity(5, 1, {});

    // 最早開始時間と最遅開始時間の計算
    project.calculateEarliestStart();
    project.calculateLatestStart();

    // クリティカルパスと時間情報の出力
    project.printCriticalPath();
    project.printTimeInfo();

    return 0;
}

sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) {
    return a.weight < b.weight;
});

// Kruskalアルゴリズム
vector<Edge> kruskal(vector<Edge>& edges, int numNodes) {//辺集合とノード数を引数として受け取る
    // 辺を重みの昇順でソート
    sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) 
//比較開始辺、比較終了辺、ラムダ式（比較対象の2要素）
{
        return a.weight < b.weight;//比較ルール：辺の重みを昇順でソート
    });

    // Union-Findの初期化
    UnionFind uf(numNodes);//UnionFind(サイズ)

    // 最小全域木の辺を格納
    vector<Edge> result;

    // ソートされた辺を走査
    for (const Edge& edge : edges) {
        // この辺を追加するとループが形成されるかどうかをチェック
        if (uf.find(edge.start) != uf.find(edge.end)) {//この辺の開始ノードと終了ノードが異なる集合（サブツリー）に属している場合
            // ループが形成されないため、最小全域木に追加
            result.push_back(edge);
            uf.unite(edge.start, edge.end);//2つのノードのサブツリーを結合（同じ集合としてマーク）し、ループ形成を防止
        }
    }

    return result;
}

// 辺の構造体
struct Edge {
    int start, end, weight;//辺の開始ノード、終了ノード、重み
};

// 素集合データ構造の実装
class UnionFind {
public:
    UnionFind(int size) : parent(size), rank(size, 0) {
//parentは各ノードのルートノードを格納し、初期値は自身。rankは各ノードがルートノード時の木の深さを記録し、初期値は0
        for (int i = 0; i < size; ++i) {
            parent[i] = i;//ルートノードを自身に初期化
        }
    }

    int find(int x) {//ルートノードを検索
        if (x != parent[x]) {//xのルートノードが自身でない場合（親ノードが存在）
            parent[x] = find(parent[x]);//ルートノードを親ノードのルートノードに設定
        }
        return parent[x];//親ノード/上位ノードを返す
    }

    void unite(int x, int y) {//2つの部分木を結合
        int rootX = find(x);//xノードのルートノード
        int rootY = find(y);//yノードのルートノード

        if (rootX != rootY) {//x、yが同一集合（部分木）にない場合
            if (rank[rootX] < rank[rootY]) {
                //xの部分木の深さがyの部分木より浅い場合
                parent[rootX] = rootY;
                        //xの部分木をyの部分木に統合し、結合後の深さが増加しないようにする
            } else if (rank[rootX] > rank[rootY]) {
                parent[rootY] = rootX;
            } else {//x、yの部分木の深さが同じ場合
                parent[rootX] = rootY;//xの部分木をyの部分木に統合
                rank[rootY]++;//結合後の深さを++
            }
        }
    }

private:
    vector<int> parent;
    vector<int> rank;
};

Graph:
0 - 1 : 4
0 - 2 : 1
1 - 3 : 2
1 - 4 : 8
2 - 5 : 3
2 - 6 : 7
3 - 7 : 5
3 - 8 : 1
4 - 9 : 6
5 - 6 : 2
6 - 8 : 6
7 - 9 : 3
8 - 9 : 9
1 - 2 : 2
3 - 4 : 3
5 - 7 : 4
6 - 9 : 7
0 - 3 : 6
2 - 8 : 5
4 - 5 : 4
最小全域木の辺:
0 - 2 : 1
3 - 8 : 1
1 - 3 : 2
1 - 2 : 2
5 - 6 : 2
2 - 5 : 3
3 - 4 : 3
7 - 9 : 3
5 - 7 : 4

#include <iostream>
#include <vector>
#include <algorithm>//sort関数を呼び出す

using namespace std;

// 辺の構造体
struct Edge {
    int start, end, weight;//辺の開始ノード、終了ノード、重み
};

// Union-Findの実装
class UnionFind {
public:
    UnionFind(int size) : parent(size), rank(size, 0) {
//parentは各ノードのルートノードを格納し、初期値は自身。rankは各ノードがルートノード時の木の深さを記録し、初期値は0
        for (int i = 0; i < size; ++i) {
            parent[i] = i;//ルートノードを自身に初期化
        }
    }

    int find(int x) {//ルートノードを検索
        if (x != parent[x]) {//xのルートノードが自身でない場合（親ノードが存在）
            parent[x] = find(parent[x]);//ルートノードを親ノードのルートノードに設定
        }
        return parent[x];//親ノード/上位ノードを返す
    }

    void unite(int x, int y) {//2つの部分木を結合
        int rootX = find(x);//xノードのルートノード
        int rootY = find(y);//yノードのルートノード

        if (rootX != rootY) {//x、yが同一集合（部分木）にない場合
            if (rank[rootX] < rank[rootY]) {
                //xの部分木の深さがyの部分木の深さより小さい場合
                parent[rootX] = rootY;
                        //xの部分木をyの部分木に統合し、結合後の深さが増えないようにする
            } else if (rank[rootX] > rank[rootY]) {
                parent[rootY] = rootX;
            } else {//x、yの部分木の深さが同じ場合
                parent[rootX] = rootY;//xの部分木をyの部分木に統合
                rank[rootY]++;//結合後の深さ++
            }
        }
    }

private:
    vector<int> parent;
    vector<int> rank;
};

// Kruskalアルゴリズム
vector<Edge> kruskal(vector<Edge>& edges, int numNodes) {//辺集合、ノード数を渡す
    // 辺を重みの昇順でソート
    sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) 
//比較開始辺、比較終了辺、lambda式（2つの比較要素）
{
        return a.weight < b.weight;//比較ルール：辺の重みの昇順ソート
    });

    // Union-Findを初期化
    UnionFind uf(numNodes);//UnionFind(size)

    // 最小全域木の辺を格納
    vector<Edge> result;

    // ソート後の辺を走査
    for (const Edge& edge : edges) {
        // この辺を追加するとループが形成されるかどうかをチェック
        if (uf.find(edge.start) != uf.find(edge.end)) {//この辺の開始ノードと終了ノードが同一集合（部分木）にない場合
            // ループが形成されないため、最小全域木に追加
            result.push_back(edge);
            uf.unite(edge.start, edge.end);//2つのノードの部分木を結合（同一集合としてマーク）し、ループ形成を防止
        }
    }

    return result;
}

int main() {
  // 10ノードのグラフを作成
    int numNodes = 10;

    // 辺集合を作成し、辺の始点、終点、重みを手動で設定
    vector<Edge> edges = {
        {0, 1, 4},
        {0, 2, 1},
        {1, 3, 2},
        {1, 4, 8},
        {2, 5, 3},
        {2, 6, 7},
        {3, 7, 5},
        {3, 8, 1},
        {4, 9, 6},
        {5, 6, 2},
        {6, 8, 6},
        {7, 9, 3},
        {8, 9, 9},
        {1, 2, 2},
        {3, 4, 3},
        {5, 7, 4},
        {6, 9, 7},
        {0, 3, 6},
        {2, 8, 5},
        {4, 5, 4}
    };
        //グラフを出力
    cout << "Graph:" << endl;
    for (const Edge& edge : edges) {
        cout << edge.start << " - " << edge.end << " : " << edge.weight << endl;
    }
    // Kruskalアルゴリズムを実行
    vector<Edge> minSpanningTree = kruskal(edges, numNodes);

    // 最小全域木の辺を出力
    cout << "Edges in the minimum spanning tree:" << endl;
    for (const Edge& edge : minSpanningTree) {
        cout << edge.start << " - " << edge.end << " : " << edge.weight << endl;
    }

    return 0;
}

int n = graph.size();
distances.resize(n, INF);

priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
distances[start] = 0;
pq.push({0, start});

while (!pq.empty()) {
    int u = pq.top().second;
    pq.pop();

    for (int v = 0; v < n; ++v) {
        if (graph[u][v] != 0 && distances[v] > distances[u] + graph[u][v]) {
            distances[v] = distances[u] + graph[u][v];
            pq.push({distances[v], v});
        }
    }
}

typedef vector<vector<int>> Graph;

vector<int> distances;

priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;

Distance from node 0 to 0: 0
Distance from node 0 to 1: 2
Distance from node 0 to 2: 3
Distance from node 0 to 3: 9
Distance from node 0 to 4: 6

#include <iostream>
#include <vector>
#include <queue>//優先度付きキューを導入
#include <climits>//int型の最大値を導入

using namespace std;

#define INF INT_MAX

// グラフの隣接行列表現を定義
typedef vector<vector<int>> Graph;
//二次元ベクトルでノード間の辺の重みを表現、graph[u][v]

// Dijkstraアルゴリズムの実装
void dijkstra(const Graph& graph, int start, vector<int>& distances) {
//グラフ、開始ノード、開始ノードから各ノードへの距離配列を渡す
    int n = graph.size();//nはノード数
    distances.resize(n, INF);  // 距離配列を初期化、初期値は無限大

    // 優先度付きキュー、距離の小さい順に並べる
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
//pairは他のノードと、そのノードから開始ノードまでの距離で構成されるペア{distance,v}
//優先度キューの要素型はpair、基盤となるコンテナ型はvector
//比較関数greaterを定義、pairを比較し、キューの先頭は距離が最短のノードペアとなる

    distances[start] = 0;  // 開始ノードから自身への距離は0
    pq.push({0, start});   // 開始ノードをキューに追加、距離は0

    while (!pq.empty()) {
        int u = pq.top().second;  // 現在の起点から最短距離にあるノードを取り出し、出発点uとする
        pq.pop();

        for (int v = 0; v < n; v++) {
            if (graph[u][v] != 0 && distances[v] > distances[u] + graph[u][v]) {
                // 現在のノードu経由でノードvに至る距離が既知の距離より短い場合、距離値を更新
                distances[v] = distances[u] + graph[u][v];
                pq.push({distances[v], v});  // 新しい距離とノードvをキューに追加
            }
        }
    }
}

int main() {
    // サンプルグラフの隣接行列表現
    Graph graph = {
        {0, 2, 4, 0, 0},
        {0, 0, 1, 7, 0},
        {0, 0, 0, 0, 3},
        {0, 0, 0, 0, 1},
        {0, 0, 0, 0, 0}
    };

    int startNode = 0;
    vector<int> distances;

    dijkstra(graph, startNode, distances);

    // 各ノードから開始ノードへの最短距離を出力
    for (int i = 0; i < distances.size(); ++i) {
        cout << "Distance from node " << startNode << " to " << i << ": ";
        if (distances[i] == INF) {
            cout << "INF" << endl;
        } else {
            cout << distances[i] << endl;
        }
    }

    return 0;
}

// スレッドを作成する関数
void createThread(Node* p) {
    if (p == NULL) { // ノードが空の場合、直接戻る
        return;
    }
    createThread(p->left); // 左部分木を再帰的に処理
    if (!p->left) { // 左子ノードが空の場合、左ポインタを前のノードに指向させ、左スレッドフラグを1に設定
        p->left = pre;
        p->ltag = 1;
    }
    if (pre && !pre->right) { // 前のノードの右子ノードが空の場合、その右ポインタを現在のノードに指向させ、右スレッドフラグを1に設定
        pre->right = p;
        pre->rtag = 1;
    }
    pre = p; // 前のノードを更新
    createThread(p->right); // 右部分木を再帰的に処理
}

// 二分木ノードの構造体を定義
struct Node {
    int data; // ノードのデータ
    Node* left; // 左子ノード
    Node* right; // 右子ノード
    int ltag, rtag; // 左右スレッドマーク
};

int main() {
    // 二分木を作成
    Node n1, n2, n3, n4, n5;
    n1 = {1, &n2, &n3, 0, 0};
    n2 = {2, &n4, &n5, 0, 0};
    n3 = {3, NULL, NULL, 0, 0};
    n4 = {4, NULL, NULL, 0, 0};
    n5 = {5, NULL, NULL, 0, 0};
    // 二分木をスレッド化
    createThread(&n1);
    // スレッド化された二分木を中順走査
    inOrder(&n1);
    return 0;
}

#include<iostream>
using namespace std;

// 二分木ノードの構造体を定義
struct Node {
    int data; // ノードのデータ
    Node* left; // 左子ノード
    Node* right; // 右子ノード
    int ltag, rtag; // 左右のスレッドマーク
};

// 前のノードを保存するためのグローバル変数preを定義
Node* pre = NULL;

// スレッドを作成する関数
void createThread(Node* p) {
    if (p == NULL) { // ノードが空の場合、直接戻る
        return;
    }
    createThread(p->left); // 左部分木を再帰的に処理
    if (!p->left) { // 左子ノードが空の場合、左ポインタを前のノードに指向し、左スレッドマークを1に設定
        p->left = pre;
        p->ltag = 1;
    }
    if (pre && !pre->right) { // 前のノードの右子ノードが空の場合、その右ポインタを現在のノードに指向し、右スレッドマークを1に設定
        pre->right = p;
        pre->rtag = 1;
    }
    pre = p; // 前のノードを更新
    createThread(p->right); // 右部分木を再帰的に処理
}

// スレッド二分木を中順走査する関数
void inOrder(Node* p) {
    while (p) {
        while (!p->ltag) { // 最も左のノードを見つける
            p = p->left;
        }
        cout << p->data << " "; // ノードデータを出力
        while (p->rtag) { // 右ポインタがスレッドの場合、直接後続ノードにジャンプ
            p = p->right;
            cout << p->data << " ";
        }
        p = p->right; // 右部分木を処理
    }
}

int main() {
    // 二分木を作成
    Node n1, n2, n3, n4, n5;
    n1 = {1, &n2, &n3, 0, 0};
    n2 = {2, &n4, &n5, 0, 0};
    n3 = {3, NULL, NULL, 0, 0};
    n4 = {4, NULL, NULL, 0, 0};
    n5 = {5, NULL, NULL, 0, 0};
    // 二分木をスレッド化
    createThread(&n1);
    // スレッド二分木を中順走査
    inOrder(&n1);
    return 0;
}

for (i = 1; i <= max_edges; i++) {
    cin >> origin >> destin;
    if ((origin == -1) && (destin == -1))
        break;
    if (origin >= n || destin >= n || origin < 0 || destin < 0) {
        i--;
    } else {
        adj[origin][destin] = 1;
    }
}

void Graph::addEdge(int v, int w) {
    adj[v].push_back(w);
}

void Graph::printGraph() {
    for (int v = 0; v < V; v++) {
        cout << "\n Adjacency list of vertex " << v << "\n head ";
        for (auto x : adj[v])
            cout << "-> " << x;
        printf("\n");
    }
}

#include<iostream>
#define MAX 20
using namespace std;

int adj[MAX][MAX];
int n;

void create_graph() {
    int i, max_edges, origin, destin;

    cout << "Enter number of nodes : ";
    cin >> n;
    max_edges = n * (n - 1);

    for (i = 1; i <= max_edges; i++) {
        cout << "Enter edge " << i << " (-1 -1 to quit) : ";
        cin >> origin >> destin;

        if ((origin == -1) && (destin == -1))
            break;

        if (origin >= n || destin >= n || origin < 0 || destin < 0) {
            cout << "Invalid edge!\n";
            i--;
        } else {
            adj[origin][destin] = 1;
        }
    }
}

#include<iostream>
#include<list>
using namespace std;

class Graph {
    int V;
    list<int> *adj;

public:
    Graph(int V);

    void addEdge(int v, int w);

    void printGraph();
};

Graph::Graph(int V) {
    this->V = V;
    adj = new list<int>[V];
}

void Graph::addEdge(int v, int w) {
    adj[v].push_back(w);
}

void Graph::printGraph() {
    for (int v = 0; v < V; v++) {
        cout << "\n Adjacency list of vertex " << v << "\n head ";
        for (auto x : adj[v])
            cout << "-> " << x;
        printf("\n");
    }
}

HuffmanNode* buildHuffmanTree(map<char, int>& frequencies) {
    // 1. 優先度付きキュー（最小ヒープ）を作成してハフマン木を構築
    priority_queue<HuffmanNode*, vector<HuffmanNode*>, CompareNodes> minHeap;

    // 2. リーフノードを作成して最小ヒープに追加
    for (auto& entry : frequencies) {
        HuffmanNode* node = new HuffmanNode(entry.first, entry.second);
        minHeap.push(node);
    }

    // 3. ハフマン木を構築
    while (minHeap.size() > 1) {
        HuffmanNode* left = minHeap.top();
        minHeap.pop();

        HuffmanNode* right = minHeap.top();
        minHeap.pop();

        HuffmanNode* internalNode = new HuffmanNode('$', left->frequency + right->frequency);
        internalNode->left = left;
        internalNode->right = right;

        minHeap.push(internalNode);
    }

    // 4. ハフマン木のルートノードを返す
    return minHeap.top();
}

void generateHuffmanCodes(HuffmanNode* root, string code, map<char, string>& huffmanCodes) {
    // 1. 再帰終了条件：リーフノードに到達
    if (root == nullptr) {
        return;
    }

    // 2. リーフノードの場合、文字と対応するハフマン符号をマッピングに保存
    if (root->data != '$') {
        huffmanCodes[root->data] = code;
    }

    // 3. 左部分木と右部分木のハフマン符号を再帰的に生成
    generateHuffmanCodes(root->left, code + "0", huffmanCodes);
    generateHuffmanCodes(root->right, code + "1", huffmanCodes);
}

string huffmanEncode(string text, map<char, string>& huffmanCodes) {
    string encodedText = "";
    // 元のテキストを走査し、マッピングに基づいて各文字を置き換え
    for (char c : text) {
        encodedText += huffmanCodes[c];
    }
    return encodedText;
}

string huffmanDecode(string encodedText, HuffmanNode* root) {
    string decodedText = "";
    HuffmanNode* current = root;

    // ハフマン符号を走査
    for (char bit : encodedText) {
        // '0' と '1' に従って左部分木または右部分木を訪問
        if (bit == '0') {
            current = current->left;
        } else {
            current = current->right;
        }

        // リーフノードに到達した場合、文字を復号結果に追加し、ルートノードにリセット
        if (current->data != '$') {
            decodedText += current->data;
            current = root;
        }
    }

    return decodedText;
}

Huffman Codes:
d: 00
r: 010
$: 011
w: 1000
e: 1001
o: 101
l: 110
h: 1110
 : 1111
Encoded Text: 111000110010100010010010110111010010011110111100
Decoded Text: hello world

#include <iostream>
#include <queue>
#include <map>
#include <string>

using namespace std;

// ハフマン木のノード構造を定義
struct HuffmanNode {
    char data;
    int frequency;
    HuffmanNode *left, *right;

    HuffmanNode(char d, int freq) : data(d), frequency(freq), left(nullptr), right(nullptr) {}
};

// 2つのノードの優先度を比較
struct CompareNodes {
    bool operator()(HuffmanNode* a, HuffmanNode* b) {//'+'演算子をオーバーロード
        return a->frequency > b->frequency;
    }
};

// ハフマン木を構築
HuffmanNode* buildHuffmanTree(map<char, int>& frequencies) {
    priority_queue<HuffmanNode*, vector<HuffmanNode*>, CompareNodes> minHeap;
    //優先度付きキューテンプレート、要素型HuffmanNode*、コンテナ型vector<HuffmanNode*>、比較規則関数CompareNodes

    // リーフノードを作成し、最小ヒープに追加
    for (auto& entry : frequencies) {//auto、entryの型をfrequenciesのキーと値のペアとして自動判定
        HuffmanNode* node = new HuffmanNode(entry.first, entry.second);
        minHeap.push(node);//キューに追加
    }
    //priority_queueは自動的にキューの優先度を維持
    // ハフマン木を構築
    while (minHeap.size() > 1) {//優先度付きキューにノードが1つだけ残ったらルートノード、ループ終了
        HuffmanNode* left = minHeap.top();
        minHeap.pop();

        HuffmanNode* right = minHeap.top();
        minHeap.pop();

        HuffmanNode* internalNode = new HuffmanNode('$', left->frequency + right->frequency);
        //2つの子ノードのルートノードを作成、frequencyは子ノードのfrequencyの合計
        internalNode->left = left;
        internalNode->right = right;

        minHeap.push(internalNode);//このルートノードをminHeapに追加して再配置
    }
    //ハフマン木を生成、すべての非リーフノードのdataは'$'
    // ルートノードを返す
    return minHeap.top();
}

// 再帰的にハフマン符号を生成
void generateHuffmanCodes(HuffmanNode* root, string code, map<char, string>& huffmanCodes) {
    if (root == nullptr) {
        return;
    }

    if (root->data != '$') {//リーフノードに到達
        huffmanCodes[root->data] = code;//この文字の符号はcode
    }

    generateHuffmanCodes(root->left, code + "0", huffmanCodes);
    generateHuffmanCodes(root->right, code + "1", huffmanCodes);
    //再帰的に実装、左部分木にアクセスすると+0、右部分木にアクセスすると+1
}

// ハフマン符号化
string huffmanEncode(string text, map<char, string>& huffmanCodes) {
    string encodedText = "";//resultを空文字列で初期化
    for (char c : text) {
        encodedText += huffmanCodes[c];//文字cに対応するハフマン符号を追加
    }
    return encodedText;//結果を返す
}

// ハフマン復号化
string huffmanDecode(string encodedText, HuffmanNode* root) {
    string decodedText = "";//復号結果を空文字列で初期化
    HuffmanNode* current = root;

    for (char bit : encodedText) {
        if (bit == '0') {//'0'を読むと左部分木にアクセス、'1'を読むと右部分木にアクセス
            current = current->left;
        } else {
            current = current->right;
        }

        if (current->data != '$') {//リーフノードに到達、このハフマン符号の復号結果を確定
            decodedText += current->data;
            current = root;//ルートノードに戻り、次の復号を続行
        }
    }

    return decodedText;
}

int main() {
    //string text = "hello world";
    string text;
    cin>>text;
    map<char, int> frequencies;

    // 文字頻度を計算
    for (char c : text) {
        frequencies[c]++;
    }

    // ハフマン木を構築
    HuffmanNode* root = buildHuffmanTree(frequencies);

    // ハフマン符号を生成
    map<char, string> huffmanCodes;
    generateHuffmanCodes(root, "", huffmanCodes);

    // ハフマン符号を表示
    cout << "Huffman Codes:" << endl;
    for (auto& entry : huffmanCodes) {
        cout << entry.first << ": " << entry.second << endl;//キーと値のペアを表示
    }

    // ハフマン符号化
    string encodedText = huffmanEncode(text, huffmanCodes);
    cout << "Encoded Text: " << encodedText << endl;

    // ハフマン復号化
    string decodedText = huffmanDecode(encodedText, root);
    cout << "Decoded Text: " << decodedText << endl;

    return 0;
}

TreeNode* insert(TreeNode* root, int val) {
    if (root == nullptr) {
        return new TreeNode(val);
    }

    if (val <= root->data) {
        root->left = insert(root->left, val);
    } else if (val > root->data) {
        root->right = insert(root->right, val);
    }

    return root;
}

TreeNode* buildTree(int input[], int size) {
    TreeNode* root = nullptr;

    for (int i = 0; i < size; ++i) {
        root = insert(root, input[i]);
    }

    return root;
}

void inorderTraversal(TreeNode* node) {
    if (node != nullptr) {
        inorderTraversal(node->left);
        cout << node->data << " ";
        inorderTraversal(node->right);
    }
}

void deleteTree(TreeNode* node) {
    if (node != nullptr) {
        deleteTree(node->left);
        deleteTree(node->right);
        delete node;
    }
}

TreeNode* deleteNode(TreeNode* root, int val) {
    if (root == nullptr) {
        return root;
    }

    // 一致するノードを見つける
    if (val < root->data) {
        root->left = deleteNode(root->left, val);
    } else if (val > root->data) {
        root->right = deleteNode(root->right, val);
    } else {
        // ノードに子がないか1つの子がある場合
        if (root->left == nullptr) {
            TreeNode* temp = root->right;
            delete root;
            return temp;
        } else if (root->right == nullptr) {
            TreeNode* temp = root->left;
            delete root;
            return temp;
        }

        // ノードに2つの子がある場合、右部分木の最小ノードを見つける
        TreeNode* minRight = root->right;
        while (minRight->left != nullptr) {
            minRight = minRight->left;
        }

        // 最小ノードの値を現在のノードにコピー
        root->data = minRight->data;

        // 右部分木から最小ノードを削除
        root->right = deleteNode(root->right, minRight->data);
    }

    return root;
}

// 単一ノード削除のインターフェース関数
TreeNode* deleteSingleNode(TreeNode* root, int val) {
    TreeNode* nodeToDelete = findNode(root, val);
    if (nodeToDelete != nullptr) {
        root = deleteNode(root, val);
    }
    return root;
}

struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

ソート済み二分木: 0 2 2 3 5 5 6 7 7 9 
ノード 3 を削除後のソート済み二分木: 0 2 2 5 5 6 7 7 9 
単一ノード 5 を削除後のソート済み二分木: 0 2 2 6 7 7 9 

#include <iostream>

using namespace std;

// 二分木ノードの定義
struct TreeNode {
    int data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

// ソート済み二分木にノードを挿入
TreeNode* insert(TreeNode* root, int val) {
    if (root == nullptr) {
        return new TreeNode(val);
    }

    if (val <= root->data) {
        root->left = insert(root->left, val);
    } else if (val > root->data) {
        root->right = insert(root->right, val);
    }

    return root;
}

// 中間順走査
void inorderTraversal(TreeNode* node) {
    if (node != nullptr) {
        inorderTraversal(node->left);
        cout << node->data << " ";
        inorderTraversal(node->right);
    }
}

// 木全体を削除
void deleteTree(TreeNode* node) {
    if (node != nullptr) {
        deleteTree(node->left);
        deleteTree(node->right);
        delete node;
    }
}

// 値がvalのノードを検索
TreeNode* findNode(TreeNode* root, int val) {
    if (root == nullptr || root->data == val) {
        return root;
    }

    if (val < root->data) {
        return findNode(root->left, val);
    } else {
        return findNode(root->right, val);
    }
}

// 単一ノードを削除
TreeNode* deleteNode(TreeNode* root, int val) {
    if (root == nullptr) {
        return root;
    }

    // 一致するノードを検索
    if (val < root->data) {
        root->left = deleteNode(root->left, val);
    } else if (val > root->data) {
        root->right = deleteNode(root->right, val);
    } else {
        // ノードが1つまたは子を持たない場合
        if (root->left == nullptr) {
            TreeNode* temp = root->right;
            delete root;
            return temp;
        } else if (root->right == nullptr) {
            TreeNode* temp = root->left;
            delete root;
            return temp;
        }

        // ノードが2つの子を持つ場合、右部分木の最小ノードを検索
        TreeNode* minRight = root->right;
        while (minRight->left != nullptr) {
            minRight = minRight->left;
        }

        // 最小ノードの値を現在のノードにコピー
        root->data = minRight->data;

        // 右部分木から最小ノードを削除
        root->right = deleteNode(root->right, minRight->data);
    }

    return root;
}

// 単一ノード削除のインターフェース関数
TreeNode* deleteSingleNode(TreeNode* root, int val) {
    TreeNode* nodeToDelete = findNode(root, val);
    if (nodeToDelete != nullptr) {
        root = deleteNode(root, val);
    }
    return root;
}

int main() {
    int input[] = {7, 5, 9, 2, 5, 2, 6, 3, 7, 0};
    TreeNode* root = nullptr;

    // ソート済み二分木を構築
    for (int i = 0; i < 10; ++i) {
        root = insert(root, input[i]);
    }

    // ソート済み二分木を表示
    cout << "ソート済み二分木: ";
    inorderTraversal(root);
    cout << endl;

    // ノード3を削除後のソート済み二分木
    int nodeToDelete = 3;
    root = deleteNode(root, nodeToDelete);
    cout << "ノード " << nodeToDelete << " を削除後のソート済み二分木: ";
    inorderTraversal(root);
    cout << endl;

    // 単一ノード5を削除後のソート済み二分木
    int singleNodeToDelete = 5;
    root = deleteSingleNode(root, singleNodeToDelete);
    cout << "単一ノード " << singleNodeToDelete << " を削除後のソート済み二分木: ";
    inorderTraversal(root);
    cout << endl;

    // 木全体を削除
    deleteTree(root);

    return 0;
}