セグメント木は、高速な区間クエリと更新操作を実現するための強力なデータ構造です。プログラミング競技やアルゴリズムの学習において、その理解と実装は重要です。本記事では、C言語を用いたセグメント木の実装方法を、基礎から応用まで詳しく説明します。セグメント木の基本概念から始まり、構築、クエリ処理、更新処理、さらには具体的な応用例や演習問題までを網羅します。これにより、読者はセグメント木を効果的に利用できるようになるでしょう。
セグメント木とは
セグメント木は、区間に対するクエリ（例えば、区間の合計、最小値、最大値など）を高速に処理するためのデータ構造です。バランスの取れた二分木であり、各ノードは特定の区間を表し、その区間に関する情報を保持します。セグメント木を使用すると、クエリの処理と区間の更新操作を効率的に行うことができます。具体的な利用例としては、範囲和の計算や区間の最小値/最大値の計算などが挙げられます。これらの操作を効率化することで、大規模なデータ処理を高速に行うことが可能となります。
セグメント木の構造
セグメント木は完全二分木の形をしており、各ノードは配列の区間を表しています。根ノードは配列全体の区間を表し、各内部ノードはその子ノードに分割された区間を表します。葉ノードは配列の個々の要素を表します。
ノードの構造
各ノードは、区間の開始位置と終了位置、およびその区間に関する情報（例えば、区間和や最小値、最大値）を保持します。これにより、セグメント木を構築してからは、特定の区間に対するクエリを対数時間で処理することができます。
配列による実装
セグメント木は、通常の二分木のようにポインタを使ってリンクリストで実装する方法もありますが、配列を使った実装が一般的です。配列を使うと、ノードの親子関係をインデックス操作だけで管理できるため、メモリアクセスの効率が向上します。具体的には、ノードiの左子ノードは2i+1、右子ノードは2i+2としてアクセスします。
以下はセグメント木の基本的な構造を示す例です：
typedef struct {
int start, end;
int value;
} SegmentTreeNode;
SegmentTreeNode tree[MAX_NODES];このようにして、セグメント木の各ノードが必要な情報を保持できるようにデータ構造を設計します。
セグメント木の構築
セグメント木の構築は、入力配列のデータを利用して、木の各ノードに区間情報を設定するプロセスです。これにより、後のクエリや更新操作が効率的に行えるようになります。以下にC言語でのセグメント木の構築手順を示します。
初期化とメモリ確保
セグメント木の構築には、まず必要なメモリを確保し、各ノードを初期化する必要があります。配列の長さをNとすると、セグメント木のノード数はおおよそ2*N程度になります。
#define MAX_NODES 200000 // 十分な大きさを確保
typedef struct {
int start, end;
int value;
} SegmentTreeNode;
SegmentTreeNode tree[MAX_NODES];
void buildTree(int node, int start, int end, int arr[]) {
tree[node].start = start;
tree[node].end = end;
if (start == end) {
// 葉ノードの場合
tree[node].value = arr[start];
} else {
// 内部ノードの場合
int mid = (start + end) / 2;
int leftChild = 2 * node + 1;
int rightChild = 2 * node + 2;
// 左右の子ノードを再帰的に構築
buildTree(leftChild, start, mid, arr);
buildTree(rightChild, mid + 1, end, arr);
// 左右の子ノードの情報を使って現在のノードの値を計算
tree[node].value = tree[leftChild].value + tree[rightChild].value;
}
}実装手順
- 配列
arrの各要素を基にセグメント木の各ノードを初期化します。 - 葉ノードでは、その位置の配列の値を設定します。
- 内部ノードでは、その区間を左右に分け、再帰的に子ノードを構築します。
- 子ノードの情報を基に、現在のノードの値（例えば、区間和）を計算します。
このようにしてセグメント木を構築することで、配列全体に対する区間クエリや更新操作を効率的に行えるようになります。
セグメント木のクエリ処理
セグメント木を使うと、特定の区間に対するクエリ（例えば、区間の合計、最小値、最大値など）を効率的に処理できます。ここでは、C言語での区間和クエリの実装方法を説明します。
クエリ関数の実装
クエリ処理は、指定された区間 [L, R] に対する情報を取得するために、再帰的に木を探索する方法です。以下は、その具体的な実装です：
int queryTree(int node, int start, int end, int L, int R) {
if (R < start || end < L) {
// クエリ範囲がノード範囲外の場合
return 0;
}
if (L <= start && end <= R) {
// ノード範囲がクエリ範囲内の場合
return tree[node].value;
}
// ノード範囲がクエリ範囲と部分的に重なる場合
int mid = (start + end) / 2;
int leftChild = 2 * node + 1;
int rightChild = 2 * node + 2;
int sumLeft = queryTree(leftChild, start, mid, L, R);
int sumRight = queryTree(rightChild, mid + 1, end, L, R);
return sumLeft + sumRight;
}実装手順
- クエリ範囲 [L, R] が現在のノード範囲と全く重ならない場合、結果は0を返します（ここでは区間和を扱うため、0を返します）。
- クエリ範囲が現在のノード範囲に完全に含まれる場合、そのノードの値を返します。
- クエリ範囲が現在のノード範囲と部分的に重なる場合、ノード範囲を左右に分け、再帰的に子ノードに対してクエリを行います。その結果を合計して返します。
利用例
以下は、セグメント木を用いて区間和を計算する例です：
int main() {
int arr[] = {1, 3, 5, 7, 9, 11};
int n = sizeof(arr) / sizeof(arr[0]);
buildTree(0, 0, n - 1, arr);
// クエリ [1, 3] に対する区間和を計算
int result = queryTree(0, 0, n - 1, 1, 3);
printf("Sum of values in given range: %d\n", result);
return 0;
}このようにして、セグメント木を用いた区間クエリの処理を効率的に実装することができます。これにより、配列の特定の区間に対する情報を迅速に取得することが可能となります。
セグメント木の更新処理
セグメント木を用いることで、特定の要素の値を更新し、それに伴う区間情報も効率的に更新することができます。以下にC言語でのセグメント木の更新処理の方法を説明します。
更新関数の実装
更新処理は、指定されたインデックスの値を新しい値に変更し、その影響を受けるノードの値を再帰的に更新する方法です。以下は、その具体的な実装です：
void updateTree(int node, int start, int end, int idx, int newValue) {
if (start == end) {
// 葉ノードの場合
tree[node].value = newValue;
} else {
int mid = (start + end) / 2;
int leftChild = 2 * node + 1;
int rightChild = 2 * node + 2;
if (idx <= mid) {
// 更新対象が左の子ノードにある場合
updateTree(leftChild, start, mid, idx, newValue);
} else {
// 更新対象が右の子ノードにある場合
updateTree(rightChild, mid + 1, end, idx, newValue);
}
// 子ノードの値を基に現在のノードの値を更新
tree[node].value = tree[leftChild].value + tree[rightChild].value;
}
}実装手順
- 更新対象のインデックスが現在のノード範囲内でない場合は何もせずリターンします。
- 葉ノードに到達した場合、その値を新しい値に更新します。
- 内部ノードの場合、更新対象のインデックスが左の子ノードの範囲にあるか、右の子ノードの範囲にあるかを判定し、適切な子ノードに対して再帰的に更新処理を行います。
- 子ノードの値を基に、現在のノードの値を更新します。
利用例
以下は、セグメント木を用いて特定の要素の値を更新し、その後区間和を計算する例です：
int main() {
int arr[] = {1, 3, 5, 7, 9, 11};
int n = sizeof(arr) / sizeof(arr[0]);
buildTree(0, 0, n - 1, arr);
// 配列のインデックス2の値を5から6に更新
updateTree(0, 0, n - 1, 2, 6);
// 更新後のクエリ [1, 3] に対する区間和を計算
int result = queryTree(0, 0, n - 1, 1, 3);
printf("Sum of values in given range after update: %d\n", result);
return 0;
}このようにして、セグメント木を用いることで、特定の要素の値を効率的に更新し、その影響を受ける区間情報も迅速に反映させることができます。これにより、動的なデータに対しても高効率なクエリ処理が可能となります。
応用例：範囲和の計算
セグメント木を利用することで、範囲和の計算を効率的に行うことができます。ここでは、具体的な応用例として、範囲和の計算方法とその実装例を紹介します。
範囲和の計算の概要
範囲和の計算は、指定された区間内の要素の合計を求める操作です。セグメント木を使用することで、この操作を対数時間で処理することが可能です。以下のコードでは、セグメント木を構築し、範囲和の計算を行う関数を実装します。
実装例
以下は、セグメント木を利用して範囲和の計算を行う具体的な例です：
#include <stdio.h>
#define MAX_NODES 200000 // 十分な大きさを確保
typedef struct {
int start, end;
int value;
} SegmentTreeNode;
SegmentTreeNode tree[MAX_NODES];
void buildTree(int node, int start, int end, int arr[]) {
tree[node].start = start;
tree[node].end = end;
if (start == end) {
// 葉ノードの場合
tree[node].value = arr[start];
} else {
// 内部ノードの場合
int mid = (start + end) / 2;
int leftChild = 2 * node + 1;
int rightChild = 2 * node + 2;
// 左右の子ノードを再帰的に構築
buildTree(leftChild, start, mid, arr);
buildTree(rightChild, mid + 1, end, arr);
// 左右の子ノードの情報を使って現在のノードの値を計算
tree[node].value = tree[leftChild].value + tree[rightChild].value;
}
}
int queryTree(int node, int start, int end, int L, int R) {
if (R < start || end < L) {
// クエリ範囲がノード範囲外の場合
return 0;
}
if (L <= start && end <= R) {
// ノード範囲がクエリ範囲内の場合
return tree[node].value;
}
// ノード範囲がクエリ範囲と部分的に重なる場合
int mid = (start + end) / 2;
int leftChild = 2 * node + 1;
int rightChild = 2 * node + 2;
int sumLeft = queryTree(leftChild, start, mid, L, R);
int sumRight = queryTree(rightChild, mid + 1, end, L, R);
return sumLeft + sumRight;
}
int main() {
int arr[] = {1, 3, 5, 7, 9, 11};
int n = sizeof(arr) / sizeof(arr[0]);
buildTree(0, 0, n - 1, arr);
// クエリ [1, 4] に対する範囲和を計算
int result = queryTree(0, 0, n - 1, 1, 4);
printf("Sum of values in given range [1, 4]: %d\n", result);
return 0;
}コードの説明
buildTree関数: 入力配列からセグメント木を構築します。各ノードは、その範囲の合計値を保持します。queryTree関数: 指定された範囲 [L, R] の合計を計算します。範囲外の部分は無視し、部分的に重なるノードは再帰的にクエリを行います。main関数: 入力配列を基にセグメント木を構築し、範囲 [1, 4] の範囲和を計算して結果を表示します。
このようにして、セグメント木を用いた範囲和の計算を効率的に行うことができます。この技術は、特に大規模なデータセットに対する迅速なクエリ処理が求められる場面で非常に有用です。
応用例：範囲の最小値/最大値の計算
セグメント木を利用することで、特定の区間における最小値や最大値を効率的に計算することができます。ここでは、その具体的な応用例として、範囲の最小値と最大値の計算方法と実装例を紹介します。
範囲最小値/最大値の計算の概要
範囲最小値/最大値の計算は、指定された区間内の要素のうち、最小値または最大値を求める操作です。セグメント木を使用すると、この操作を対数時間で処理することが可能です。以下のコードでは、セグメント木を構築し、範囲の最小値および最大値を計算する関数を実装します。
実装例
以下は、セグメント木を利用して範囲最小値および最大値を計算する具体的な例です：
#include <stdio.h>
#include <limits.h>
#define MAX_NODES 200000 // 十分な大きさを確保
typedef struct {
int start, end;
int min_value;
int max_value;
} SegmentTreeNode;
SegmentTreeNode tree[MAX_NODES];
void buildTree(int node, int start, int end, int arr[]) {
tree[node].start = start;
tree[node].end = end;
if (start == end) {
// 葉ノードの場合
tree[node].min_value = arr[start];
tree[node].max_value = arr[start];
} else {
// 内部ノードの場合
int mid = (start + end) / 2;
int leftChild = 2 * node + 1;
int rightChild = 2 * node + 2;
// 左右の子ノードを再帰的に構築
buildTree(leftChild, start, mid, arr);
buildTree(rightChild, mid + 1, end, arr);
// 左右の子ノードの情報を使って現在のノードの値を計算
tree[node].min_value = (tree[leftChild].min_value < tree[rightChild].min_value) ? tree[leftChild].min_value : tree[rightChild].min_value;
tree[node].max_value = (tree[leftChild].max_value > tree[rightChild].max_value) ? tree[leftChild].max_value : tree[rightChild].max_value;
}
}
int queryMinTree(int node, int start, int end, int L, int R) {
if (R < start || end < L) {
// クエリ範囲がノード範囲外の場合
return INT_MAX;
}
if (L <= start && end <= R) {
// ノード範囲がクエリ範囲内の場合
return tree[node].min_value;
}
// ノード範囲がクエリ範囲と部分的に重なる場合
int mid = (start + end) / 2;
int leftChild = 2 * node + 1;
int rightChild = 2 * node + 2;
int minLeft = queryMinTree(leftChild, start, mid, L, R);
int minRight = queryMinTree(rightChild, mid + 1, end, L, R);
return (minLeft < minRight) ? minLeft : minRight;
}
int queryMaxTree(int node, int start, int end, int L, int R) {
if (R < start || end < L) {
// クエリ範囲がノード範囲外の場合
return INT_MIN;
}
if (L <= start && end <= R) {
// ノード範囲がクエリ範囲内の場合
return tree[node].max_value;
}
// ノード範囲がクエリ範囲と部分的に重なる場合
int mid = (start + end) / 2;
int leftChild = 2 * node + 1;
int rightChild = 2 * node + 2;
int maxLeft = queryMaxTree(leftChild, start, mid, L, R);
int maxRight = queryMaxTree(rightChild, mid + 1, end, L, R);
return (maxLeft > maxRight) ? maxLeft : maxRight;
}
int main() {
int arr[] = {1, 3, 5, 7, 9, 11};
int n = sizeof(arr) / sizeof(arr[0]);
buildTree(0, 0, n - 1, arr);
// クエリ [1, 4] に対する範囲最小値を計算
int minResult = queryMinTree(0, 0, n - 1, 1, 4);
printf("Minimum value in given range [1, 4]: %d\n", minResult);
// クエリ [1, 4] に対する範囲最大値を計算
int maxResult = queryMaxTree(0, 0, n - 1, 1, 4);
printf("Maximum value in given range [1, 4]: %d\n", maxResult);
return 0;
}コードの説明
buildTree関数: 入力配列からセグメント木を構築します。各ノードは、その範囲の最小値および最大値を保持します。queryMinTree関数: 指定された範囲 [L, R] の最小値を計算します。範囲外の部分は無視し、部分的に重なるノードは再帰的にクエリを行います。queryMaxTree関数: 指定された範囲 [L, R] の最大値を計算します。範囲外の部分は無視し、部分的に重なるノードは再帰的にクエリを行います。main関数: 入力配列を基にセグメント木を構築し、範囲 [1, 4] の最小値および最大値を計算して結果を表示します。
このようにして、セグメント木を用いた範囲最小値および最大値の計算を効率的に行うことができます。この技術は、特に大規模なデータセットに対する迅速なクエリ処理が求められる場面で非常に有用です。
効率的なセグメント木の利用法
セグメント木は、特定のクエリや更新操作を高速に処理するための強力なデータ構造ですが、さらにその性能を最大限に引き出すためのテクニックやコツがあります。ここでは、効率的なセグメント木の利用方法について解説します。
セグメント木のメモリ効率化
セグメント木を配列で実装する際、メモリの効率化が重要です。木のノード数は、通常入力配列の要素数の約2倍程度で十分です。しかし、特定の問題やクエリの頻度に応じて、動的にメモリを割り当てることも有効です。
動的メモリ割り当ての例
SegmentTreeNode* tree = (SegmentTreeNode*)malloc(sizeof(SegmentTreeNode) * MAX_NODES);
if (tree == NULL) {
fprintf(stderr, "Memory allocation failed\n");
return 1;
}遅延伝播による更新の効率化
セグメント木の更新処理において、区間全体を一度に更新する場合、遅延伝播（Lazy Propagation）を用いることで、効率を大幅に向上させることができます。これは、更新情報を一時的に保持し、必要なときにのみ実際に更新を行う方法です。
遅延伝播の実装例
void updateRangeLazy(int node, int start, int end, int L, int R, int value) {
// 遅延情報があれば適用する
if (lazy[node] != 0) {
tree[node].value += (end - start + 1) * lazy[node];
if (start != end) {
lazy[node*2+1] += lazy[node];
lazy[node*2+2] += lazy[node];
}
lazy[node] = 0;
}
if (start > end || start > R || end < L) {
return;
}
if (start >= L && end <= R) {
tree[node].value += (end - start + 1) * value;
if (start != end) {
lazy[node*2+1] += value;
lazy[node*2+2] += value;
}
return;
}
int mid = (start + end) / 2;
updateRangeLazy(node*2+1, start, mid, L, R, value);
updateRangeLazy(node*2+2, mid+1, end, L, R, value);
tree[node].value = tree[node*2+1].value + tree[node*2+2].value;
}並列処理による性能向上
セグメント木のクエリや更新操作は、独立した部分に対して並列に実行できるため、並列処理を導入することで性能を向上させることが可能です。マルチスレッドプログラミングを用いることで、大規模なデータセットに対しても効率的に処理を行うことができます。
並列クエリ処理の例
#include <pthread.h>
typedef struct {
int node;
int start;
int end;
int L;
int R;
int result;
} QueryArgs;
void* queryTreeParallel(void* args) {
QueryArgs* qargs = (QueryArgs*)args;
qargs->result = queryTree(qargs->node, qargs->start, qargs->end, qargs->L, qargs->R);
return NULL;
}
int main() {
pthread_t threads[2];
QueryArgs args1 = {0, 0, n/2, 1, 3, 0};
QueryArgs args2 = {0, n/2+1, n-1, 1, 3, 0};
pthread_create(&threads[0], NULL, queryTreeParallel, (void*)&args1);
pthread_create(&threads[1], NULL, queryTreeParallel, (void*)&args2);
pthread_join(threads[0], NULL);
pthread_join(threads[1], NULL);
int result = args1.result + args2.result;
printf("Sum of values in given range [1, 3]: %d\n", result);
return 0;
}このようにして、セグメント木の性能を最大限に引き出すためのさまざまなテクニックを活用することで、大規模なデータセットに対する迅速で効率的なクエリおよび更新操作を実現できます。
演習問題
セグメント木の理解を深めるために、いくつかの演習問題を提供します。これらの問題を通じて、セグメント木の構築、クエリ、更新操作に関する実践的なスキルを身に付けましょう。
問題1: セグメント木の構築
以下の配列を基にセグメント木を構築し、その各ノードの値を出力してください。
int arr[] = {2, 4, 6, 8, 10, 12, 14, 16};問題2: 範囲和のクエリ
構築したセグメント木を用いて、以下の範囲の合計を計算してください。
- 範囲 [2, 5]
- 範囲 [0, 7]
問題3: 範囲の最小値クエリ
セグメント木を用いて、以下の範囲の最小値を計算してください。
- 範囲 [1, 4]
- 範囲 [3, 6]
問題4: 値の更新とクエリ
セグメント木を用いて、次の更新操作を行い、その後の範囲和を計算してください。
- インデックス3の値を9に更新
- 範囲 [2, 5] の合計を再計算
問題5: 遅延伝播を用いた範囲更新
遅延伝播（Lazy Propagation）を用いて、範囲 [2, 4] の全ての値に5を加算し、その後の範囲和を計算してください。
- 範囲 [0, 3] の合計を計算
コードの参考例
以下のコードを参考に、上記の演習問題に取り組んでください。
#include <stdio.h>
#include <limits.h>
#include <stdlib.h>
#define MAX_NODES 200000
typedef struct {
int start, end;
int value;
int min_value;
} SegmentTreeNode;
SegmentTreeNode tree[MAX_NODES];
int lazy[MAX_NODES] = {0};
void buildTree(int node, int start, int end, int arr[]) {
tree[node].start = start;
tree[node].end = end;
if (start == end) {
tree[node].value = arr[start];
tree[node].min_value = arr[start];
} else {
int mid = (start + end) / 2;
int leftChild = 2 * node + 1;
int rightChild = 2 * node + 2;
buildTree(leftChild, start, mid, arr);
buildTree(rightChild, mid + 1, end, arr);
tree[node].value = tree[leftChild].value + tree[rightChild].value;
tree[node].min_value = (tree[leftChild].min_value < tree[rightChild].min_value) ? tree[leftChild].min_value : tree[rightChild].min_value;
}
}
int queryTree(int node, int start, int end, int L, int R) {
if (R < start || end < L) {
return 0;
}
if (L <= start && end <= R) {
return tree[node].value;
}
int mid = (start + end) / 2;
int leftChild = 2 * node + 1;
int rightChild = 2 * node + 2;
int sumLeft = queryTree(leftChild, start, mid, L, R);
int sumRight = queryTree(rightChild, mid + 1, end, L, R);
return sumLeft + sumRight;
}
int queryMinTree(int node, int start, int end, int L, int R) {
if (R < start || end < L) {
return INT_MAX;
}
if (L <= start && end <= R) {
return tree[node].min_value;
}
int mid = (start + end) / 2;
int leftChild = 2 * node + 1;
int rightChild = 2 * node + 2;
int minLeft = queryMinTree(leftChild, start, mid, L, R);
int minRight = queryMinTree(rightChild, mid + 1, end, L, R);
return (minLeft < minRight) ? minLeft : minRight;
}
void updateTree(int node, int start, int end, int idx, int newValue) {
if (start == end) {
tree[node].value = newValue;
tree[node].min_value = newValue;
} else {
int mid = (start + end) / 2;
int leftChild = 2 * node + 1;
int rightChild = 2 * node + 2;
if (idx <= mid) {
updateTree(leftChild, start, mid, idx, newValue);
} else {
updateTree(rightChild, mid + 1, end, idx, newValue);
}
tree[node].value = tree[leftChild].value + tree[rightChild].value;
tree[node].min_value = (tree[leftChild].min_value < tree[rightChild].min_value) ? tree[leftChild].min_value : tree[rightChild].min_value;
}
}
void updateRangeLazy(int node, int start, int end, int L, int R, int value) {
if (lazy[node] != 0) {
tree[node].value += (end - start + 1) * lazy[node];
if (start != end) {
lazy[node*2+1] += lazy[node];
lazy[node*2+2] += lazy[node];
}
lazy[node] = 0;
}
if (start > end || start > R || end < L) {
return;
}
if (start >= L && end <= R) {
tree[node].value += (end - start + 1) * value;
if (start != end) {
lazy[node*2+1] += value;
lazy[node*2+2] += value;
}
return;
}
int mid = (start + end) / 2;
updateRangeLazy(node*2+1, start, mid, L, R, value);
updateRangeLazy(node*2+2, mid+1, end, L, R, value);
tree[node].value = tree[node*2+1].value + tree[node*2+2].value;
}
int main() {
int arr[] = {2, 4, 6, 8, 10, 12, 14, 16};
int n = sizeof(arr) / sizeof(arr[0]);
buildTree(0, 0, n - 1, arr);
// 問題2のクエリ [2, 5] に対する範囲和を計算
int result1 = queryTree(0, 0, n - 1, 2, 5);
printf("Sum of values in given range [2, 5]: %d\n", result1);
// 問題3のクエリ [1, 4] に対する範囲最小値を計算
int result2 = queryMinTree(0, 0, n - 1, 1, 4);
printf("Minimum value in given range [1, 4]: %d\n", result2);
// 問題4の更新後のクエリ [2, 5] に対する範囲和を計算
updateTree(0, 0, n - 1, 3, 9);
int result3 = queryTree(0, 0, n - 1, 2, 5);
printf("Sum of values in given range [2, 5] after update: %d\n", result3);
// 問題5の遅延伝播を用いた範囲更新後のクエリ [0, 3] に対する範囲和を計算
updateRangeLazy(0, 0, n - 1, 2, 4, 5);
int result4 = queryTree(0, 0, n - 1, 0, 3);
printf("Sum of values in given range [0, 3] after lazy propagation update: %d\n", result4);
return 0;
}これらの演習問題を通じて、セグメント木の基本的な操作から応用的な操作まで、実践的なスキルを習得してください。コードを書いて実行することで、セグメント木の動作や効果を体験し、理解を深めることができます。
まとめ
本記事では、C言語を用いたセグメント木の実装方法について、基礎から応用まで詳細に解説しました。セグメント木の基本概念から始まり、構造、構築方法、クエリ処理、更新処理、そして範囲和や最小値/最大値の計算といった応用例までを網羅しました。さらに、効率的な利用法や実践的な演習問題を通じて、理解を深めるための具体的な手法も提供しました。これらの知識を活用して、セグメント木を効果的に利用し、さまざまなアルゴリズムやデータ構造の問題を解決できるようになりましょう。
コメント