Побитовые операции — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
(Побитовые сдвиги)
Строка 65: Строка 65:
 
==Применение==
 
==Применение==
 
===Сложные операции===
 
===Сложные операции===
====Нахождение старшего единичного бита====
+
====Определение знака числа====
Пусть дано число <tex>x</tex> и необходимо узнать его старший единичный бит. Рассмотрим два способа, с помощью которых можно решить эту задачу.
+
Пусть дано число <tex>x</tex>. Поскольку при сдвиге вправо на освобождающиеся позиции устанавливается бит знака, знак числа <tex>x</tex> можно определить, выполнив сдвиг вправо на всю длину переменной:
 +
<code>
 +
<font color = green>// n {{---}} разрядность числа</font>
 +
 +
'''if''' x != 0
 +
    mask = 1
 +
'''else'''
 +
    mask = 0
 +
 +
sign = mask | (x >> (n - 1))    <font color = green>// результатом будет -1, 0, или +1
 +
                                                      // для отрицательного, равного нулю и положительного числа x соответственно</font>
 +
</code>
 +
Используя побитовые операции можно также узнать, различны ли знаки двух переменных <tex>x</tex> и <tex>y</tex>. Если числа имеют различный знак, то результат операции XOR, произведенной над их знаковыми битами, будет единицей. Поэтому неравенство <tex>((x \oplus y) < 0</tex> будет верно в том случае, если числа <tex>x</tex> и <tex>y</tex> разного знака.
  
'''Способ 1'''
+
====Вычисление модуля числа без использования условного оператора====
 
+
Пусть дано число <tex>x</tex>. Если <tex>x</tex> положительно, то <tex>mask = 0</tex>, и <tex>(x + mask) \oplus mask = x</tex>. В случае, если <tex>x</tex> отрицательно, <tex>mask = -1</tex>. Тогда получается, что мы работаем с числом <tex>x</tex> так, как будто оно представлено в [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код #Код со сдвигом |
Рассмотрим некоторое число, представим его как <tex>0\dots01b \dots b</tex>, где <tex>b</tex> {{---}} любое значение бита. Тогда, если совершить битовый сдвиг этого числа вправо на <tex>1</tex> и произвести побитовое ИЛИ результата сдвига и исходного числа, мы получим результат <tex>0\dots011b \dots b</tex>. Если мы повторим эту последовательность действий над полученным числом, но устроим сдвиг на <tex>2</tex>, то получим <tex>0\dots01111b \dots b</tex>. При каждой следующей операции будем увеличивать модуль сдвига до следующей степени двойки. После некоторого количества таких операций (зависит от разрядности числа) мы получим число вида <tex>0\dots01\dots1</tex>. Тогда результатом выполнения действий <tex>x - (x \texttt{ >> }1)</tex> будет число, состоящее только из старшего бита исходного числа.
+
коде со сдвигом]] с тем отличием, что у нас знаковый бит принимает значение <tex>1</tex> для отрицательных чисел, а <tex>0</tex> {{---}} для положительных.
 
<code>
 
<code>
  '''int''' power = 1
+
  <font color = green>// n {{---}} разрядность числа</font>
'''for''' i = 1..<tex>\log_2{n}</tex>:    <font color = green>// n {{---}} разрядность числа</font>
+
mask = x >> n - 1
    x |= x >> power
+
    power <<= 1
+
abs = (x + mask) <tex>\oplus</tex> mask
  result = x - (x >> 1)
+
<font color = green>// другой способ сделать то же самое:</font>
 +
  abs = (x <tex>\oplus</tex> mask) - mask
 
</code>
 
</code>
  
'''Способ 2'''
+
====Нахождение минимума и максимума из двух чисел без использования условного оператора====
 
+
Этот способ корректен только если можно утверждать, что величина <tex>(x - y)</tex> лежит между граничными значениями типа int.
Способ основан на [[Целочисленный двоичный поиск | бинпоиске]]. Будем искать максимальную степень двойки, меньшую числа <tex>x</tex>.
 
  
 +
Пусть даны числа <tex>x</tex> и <tex>y</tex>. Тогда, если <tex>x < y</tex>, то <tex>((x - y) \texttt{>>} (n - 1)) = -1</tex> а если <tex>x \geqslant y</tex>, то <tex>((x - y) \texttt{>>} (n - 1)) = 0</tex>. Выражение <tex>((x - y) \& ((x - y) \texttt{>>} (n - 1))</tex> принимает значение <tex>0</tex>, если <tex>x \geqslant y</tex> и <tex>(x - y)</tex>, если <tex>x < y</tex>.
 
<code>
 
<code>
  '''int''' x, m    <font color = green>// x {{---}} исходное число</font>
+
  <font color = green>// n {{---}} разрядность чисел</font>
  '''int''' l = n    <font color = green>// n {{---}} разрядность числа</font>
+
  min = y + ((x - y) & ((x - y) >> (n - 1)))
'''int''' r = -1
+
  max = x - ((x - y) & ((x - y) >> (n - 1)))
  '''while''' r < l - 1:
 
    m = (l + r) / 2
 
    '''if''' (1 << m) <tex>\leqslant</tex> x:
 
        r = m
 
    '''else''':
 
        l = m
 
result = r
 
 
</code>
 
</code>
 +
 +
====Проверка на то, является ли число степенью двойки====
 +
Пусть дано число <tex>x</tex>. Тогда, если результатом выражения <tex>(x\ \&\&\ !(x\ \&\ (x - 1)))</tex> является единица, то число <tex>x</tex> {{---}} степень двойки.
 +
 +
Правая часть выражения <tex>(!(x\ \&\ (x - 1)))</tex> будет равна единице только если число <tex>x</tex> равно <tex>0</tex> или является степенью двойки. Если число <tex>x</tex> является степенью двойки, то в двоичной системе счисления оно представляется следующим образом: <tex>1\underbrace{0\dots0}_{n}</tex>, где <tex>n</tex> {{---}} показатель степени. Соответственно, выражение <tex>(x - 1)</tex> будет иметь вид <tex>\underbrace{1\dots1}_{n}</tex>, и <tex>x\ \&\ (x - 1)</tex> равно <tex>0</tex>.
 +
 +
Операция логического И в данном выражении отсекает тот случай, когда <tex>(x = 0)</tex> и не является степенью двойки, но при этом правая часть <tex>(!(x\ \&\ (x - 1)))</tex> равна единице.
  
 
====Нахождение младшего единичного бита====
 
====Нахождение младшего единичного бита====
Пусть дано число <tex>x</tex> и необходимо узнать его младший единичный бит. Задачу можно решить несколькими способами.
+
Пусть дано число <tex>x</tex> и необходимо узнать его младший единичный бит.
 
 
'''Способ 1'''
 
  
 
Применим к числу <tex>x</tex> побитовое отрицание, чтобы инвертировать значения всех его бит, а затем прибавим к полученному числу единицу. У результата первая часть (до младшего единичного бита) не совпадает с исходным числом <tex>x</tex>, а вторая часть совпадает. Применив побитовое И к этим двум числам, получим степень двойки, соответствующую младшему единичному биту исходного числа <tex>(x\ \&\ (\sim x + 1))</tex>.
 
Применим к числу <tex>x</tex> побитовое отрицание, чтобы инвертировать значения всех его бит, а затем прибавим к полученному числу единицу. У результата первая часть (до младшего единичного бита) не совпадает с исходным числом <tex>x</tex>, а вторая часть совпадает. Применив побитовое И к этим двум числам, получим степень двойки, соответствующую младшему единичному биту исходного числа <tex>(x\ \&\ (\sim x + 1))</tex>.
Строка 105: Строка 116:
 
К такому же результату можно прийти, если сначала отнять от числа <tex>x</tex> единицу, чтобы обнулить его младший единичный бит, а все последующие разряды обратить в <tex>1</tex>, затем инвертировать результат и применить побитовое И с исходным числом <tex>(x\ \&\ \sim (x - 1))</tex>.
 
К такому же результату можно прийти, если сначала отнять от числа <tex>x</tex> единицу, чтобы обнулить его младший единичный бит, а все последующие разряды обратить в <tex>1</tex>, затем инвертировать результат и применить побитовое И с исходным числом <tex>(x\ \&\ \sim (x - 1))</tex>.
  
'''Способ 2'''
+
====Нахождение старшего единичного бита====
 
+
Пусть дано число <tex>x</tex> и необходимо узнать его старший единичный бит.
Алгоритм аналогичен описанному выше способу нахождения старшего единичного бита и также основан на [[Целочисленный двоичный поиск | бинпоиске]]. Будем искать максимальное число вида <tex>0\dots01\dots1</tex> такое, что его побитовое И с числом <tex>x</tex> дает <tex>0</tex>.
 
  
 +
Рассмотрим некоторое число, представим его как <tex>0\dots01b \dots b</tex>, где <tex>b</tex> {{---}} любое значение бита. Тогда, если совершить битовый сдвиг этого числа вправо на <tex>1</tex> и произвести побитовое ИЛИ результата сдвига и исходного числа, мы получим результат <tex>0\dots011b \dots b</tex>. Если мы повторим эту последовательность действий над полученным числом, но устроим сдвиг на <tex>2</tex>, то получим <tex>0\dots01111b \dots b</tex>. При каждой следующей операции будем увеличивать модуль сдвига до следующей степени двойки. После некоторого количества таких операций (зависит от разрядности числа) мы получим число вида <tex>0\dots01\dots1</tex>. Тогда результатом выполнения действий <tex>x - (x \texttt{ >> }1)</tex> будет число, состоящее только из старшего бита исходного числа.
 
<code>
 
<code>
  '''int''' x, m    <font color = green>// x {{---}} исходное число</font>
+
  '''int''' power = 1
  '''int''' l = n    <font color = green>// n {{---}} разрядность числа</font>
+
  '''for''' i = 1..<tex>\log_2{n}</tex>:   <font color = green>// n {{---}} разрядность числа</font>
'''int''' r = -1
+
     x |= x >> power
'''while''' r < l - 1:
+
     power <<= 1
     m = (l + r) / 2
+
  result = x - (x >> 1)
     '''if''' ((1 << m) - 1) & x == 0:
 
        r = m
 
    '''else''':
 
        l = m
 
  result = r
 
 
</code>
 
</code>
  
Строка 168: Строка 174:
 
     position >>= 1
 
     position >>= 1
 
     x >>= 1
 
     x >>= 1
</code>
 
 
====Проверка на то, является ли число степенью двойки====
 
Пусть дано число <tex>x</tex>. Тогда, если результатом выражения <tex>(x\ \&\&\ !(x\ \&\ (x - 1)))</tex> является единица, то число <tex>x</tex> {{---}} степень двойки.
 
 
Правая часть выражения <tex>(!(x\ \&\ (x - 1)))</tex> будет равна единице только если число <tex>x</tex> равно <tex>0</tex> или является степенью двойки. Если число <tex>x</tex> является степенью двойки, то в двоичной системе счисления оно представляется следующим образом: <tex>1\underbrace{0\dots0}_{n}</tex>, где <tex>n</tex> {{---}} показатель степени. Соответственно, выражение <tex>(x - 1)</tex> будет иметь вид <tex>\underbrace{1\dots1}_{n}</tex>, и <tex>x\ \&\ (x - 1)</tex> равно <tex>0</tex>.
 
 
Операция логического И в данном выражении отсекает тот случай, когда <tex>(x = 0)</tex> и не является степенью двойки, но при этом правая часть <tex>(!(x\ \&\ (x - 1)))</tex> равна единице.
 
 
====Определение знака числа====
 
Пусть дано число <tex>x</tex>. Поскольку при сдвиге вправо на освобождающиеся позиции устанавливается бит знака, знак числа <tex>x</tex> можно определить, выполнив сдвиг вправо на всю длину переменной:
 
<code>
 
<font color = green>// n {{---}} разрядность числа</font>
 
 
'''if''' x != 0
 
    mask = 1
 
'''else'''
 
    mask = 0
 
 
sign = mask | (x >> (n - 1))    <font color = green>// результатом будет -1, 0, или +1
 
                                                      // для отрицательного, равного нулю и положительного числа x соответственно</font>
 
</code>
 
Используя побитовые операции можно также узнать, различны ли знаки двух переменных <tex>x</tex> и <tex>y</tex>. Если числа имеют различный знак, то результат операции XOR, произведенной над их знаковыми битами, будет единицей. Поэтому неравенство <tex>((x \oplus y) < 0</tex> будет верно в том случае, если числа <tex>x</tex> и <tex>y</tex> разного знака.
 
 
====Вычисление модуля числа без использования условного оператора====
 
Пусть дано число <tex>x</tex>. Если <tex>x</tex> положительно, то <tex>mask = 0</tex>, и <tex>(x + mask) \oplus mask = x</tex>. В случае, если <tex>x</tex> отрицательно, <tex>mask = -1</tex>. Тогда получается, что мы работаем с числом <tex>x</tex> так, как будто оно представлено в [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код #Код со сдвигом |
 
коде со сдвигом]] с тем отличием, что у нас знаковый бит принимает значение <tex>1</tex> для отрицательных чисел, а <tex>0</tex> {{---}} для положительных.
 
<code>
 
<font color = green>// n {{---}} разрядность числа</font>
 
mask = x >> n - 1
 
 
abs = (x + mask) <tex>\oplus</tex> mask
 
<font color = green>// другой способ сделать то же самое:</font>
 
abs = (x <tex>\oplus</tex> mask) - mask
 
</code>
 
 
====Нахождение минимума и максимума из двух чисел без использования условного оператора====
 
Этот способ корректен только если можно утверждать, что величина <tex>(x - y)</tex> лежит между граничными значениями типа int.
 
 
Пусть даны числа <tex>x</tex> и <tex>y</tex>. Тогда, если <tex>x < y</tex>, то <tex>((x - y) \texttt{>>} (n - 1)) = -1</tex> а если <tex>x \geqslant y</tex>, то <tex>((x - y) \texttt{>>} (n - 1)) = 0</tex>. Выражение <tex>((x - y) \& ((x - y) \texttt{>>} (n - 1))</tex> принимает значение <tex>0</tex>, если <tex>x \geqslant y</tex> и <tex>(x - y)</tex>, если <tex>x < y</tex>.
 
<code>
 
<font color = green>// n {{---}} разрядность чисел</font>
 
min = y + ((x - y) & ((x - y) >> (n - 1)))
 
max = x - ((x - y) & ((x - y) >> (n - 1)))
 
 
</code>
 
</code>
  

Версия 21:14, 13 марта 2016

Побитовые операции (англ. bitwise operations) — операции, производимые над цепочками битов. Выделяют два типа побитовых операций: логические операции и побитовые сдвиги.

Принцип работы

Логические побитовые операции

Битовые операторы И [math](AND,\ \&)[/math], ИЛИ [math](OR,\ \mid)[/math], НЕ [math](NOT,\ \sim)[/math] и исключающее ИЛИ [math](XOR,\ $\textasciicircum$,\ \oplus)[/math] используют те же таблицы истинности, что и их логические эквиваленты.

Побитовое И

Побитовое И используется для выключения битов. Любой бит, установленный в [math]0[/math], вызывает установку соответствующего бита результата также в [math]0[/math].

&
11001010
11100010
11000010

Побитовое ИЛИ

Побитовое ИЛИ используется для включения битов. Любой бит, установленный в [math]1[/math], вызывает установку соответствующего бита результата также в [math]1[/math].

|
11001010
11100010
11101010

Побитовое НЕ

Побитовое НЕ инвертирует состояние каждого бита исходной переменной.

~
11001010
00110101

Побитовое исключающее ИЛИ

Исключающее ИЛИ устанавливает значение бита результата в [math]1[/math], если значения в соответствующих битах исходных переменных различны.

^
11001010
11100010
00101000

Побитовые сдвиги

Операторы сдвига [math]\texttt{\lt \lt }[/math] и [math]\texttt{\gt \gt }[/math] сдвигают биты в переменной влево или вправо на указанное число. При этом на освободившиеся позиции устанавливаются нули (кроме сдвига вправо отрицательного числа, в этом случае на свободные позиции устанавливаются единицы, так как числа представляются в двоичном дополнительном коде и необходимо поддерживать знаковый бит).

Сдвиг влево может применяться для умножения числа на два, сдвиг вправо — для деления.

x = 7         // 00000111 (7)
x = x >> 1    // 00000011 (3)
x = x << 1    // 00000110 (6)
x = x << 5    // 11000000 (-64)
x = x >> 2    // 11110000 (-16)

В языке программирования Java существует также оператор беззнакового битового сдвига вправо [math]\texttt{\gt \gt \gt }[/math]. При использовании этого оператора на освободившиеся позиции всегда устанавливаются нули.

x = 7          // 00000111 (7)
x = x << 5     // 11100000 (-32)
x = x >>> 2    // 00111000 (56)

Применение

Сложные операции

Определение знака числа

Пусть дано число [math]x[/math]. Поскольку при сдвиге вправо на освобождающиеся позиции устанавливается бит знака, знак числа [math]x[/math] можно определить, выполнив сдвиг вправо на всю длину переменной:

// n — разрядность числа

if x != 0
    mask = 1
else
    mask = 0

sign = mask | (x >> (n - 1))    // результатом будет -1, 0, или +1 
                                                     // для отрицательного, равного нулю и положительного числа x соответственно

Используя побитовые операции можно также узнать, различны ли знаки двух переменных [math]x[/math] и [math]y[/math]. Если числа имеют различный знак, то результат операции XOR, произведенной над их знаковыми битами, будет единицей. Поэтому неравенство [math]((x \oplus y) \lt 0[/math] будет верно в том случае, если числа [math]x[/math] и [math]y[/math] разного знака.

Вычисление модуля числа без использования условного оператора

Пусть дано число [math]x[/math]. Если [math]x[/math] положительно, то [math]mask = 0[/math], и [math](x + mask) \oplus mask = x[/math]. В случае, если [math]x[/math] отрицательно, [math]mask = -1[/math]. Тогда получается, что мы работаем с числом [math]x[/math] так, как будто оно представлено в коде со сдвигом с тем отличием, что у нас знаковый бит принимает значение [math]1[/math] для отрицательных чисел, а [math]0[/math] — для положительных.

// n — разрядность числа
mask = x >> n - 1

abs = (x + mask) [math]\oplus[/math] mask
// другой способ сделать то же самое:
abs = (x [math]\oplus[/math] mask) - mask

Нахождение минимума и максимума из двух чисел без использования условного оператора

Этот способ корректен только если можно утверждать, что величина [math](x - y)[/math] лежит между граничными значениями типа int.

Пусть даны числа [math]x[/math] и [math]y[/math]. Тогда, если [math]x \lt y[/math], то [math]((x - y) \texttt{\gt \gt } (n - 1)) = -1[/math] а если [math]x \geqslant y[/math], то [math]((x - y) \texttt{\gt \gt } (n - 1)) = 0[/math]. Выражение [math]((x - y) \& ((x - y) \texttt{\gt \gt } (n - 1))[/math] принимает значение [math]0[/math], если [math]x \geqslant y[/math] и [math](x - y)[/math], если [math]x \lt y[/math].

// n — разрядность чисел
min = y + ((x - y) & ((x - y) >> (n - 1)))
max = x - ((x - y) & ((x - y) >> (n - 1)))

Проверка на то, является ли число степенью двойки

Пусть дано число [math]x[/math]. Тогда, если результатом выражения [math](x\ \&\&\ !(x\ \&\ (x - 1)))[/math] является единица, то число [math]x[/math] — степень двойки.

Правая часть выражения [math](!(x\ \&\ (x - 1)))[/math] будет равна единице только если число [math]x[/math] равно [math]0[/math] или является степенью двойки. Если число [math]x[/math] является степенью двойки, то в двоичной системе счисления оно представляется следующим образом: [math]1\underbrace{0\dots0}_{n}[/math], где [math]n[/math] — показатель степени. Соответственно, выражение [math](x - 1)[/math] будет иметь вид [math]\underbrace{1\dots1}_{n}[/math], и [math]x\ \&\ (x - 1)[/math] равно [math]0[/math].

Операция логического И в данном выражении отсекает тот случай, когда [math](x = 0)[/math] и не является степенью двойки, но при этом правая часть [math](!(x\ \&\ (x - 1)))[/math] равна единице.

Нахождение младшего единичного бита

Пусть дано число [math]x[/math] и необходимо узнать его младший единичный бит.

Применим к числу [math]x[/math] побитовое отрицание, чтобы инвертировать значения всех его бит, а затем прибавим к полученному числу единицу. У результата первая часть (до младшего единичного бита) не совпадает с исходным числом [math]x[/math], а вторая часть совпадает. Применив побитовое И к этим двум числам, получим степень двойки, соответствующую младшему единичному биту исходного числа [math](x\ \&\ (\sim x + 1))[/math].

К такому же результату можно прийти, если сначала отнять от числа [math]x[/math] единицу, чтобы обнулить его младший единичный бит, а все последующие разряды обратить в [math]1[/math], затем инвертировать результат и применить побитовое И с исходным числом [math](x\ \&\ \sim (x - 1))[/math].

Нахождение старшего единичного бита

Пусть дано число [math]x[/math] и необходимо узнать его старший единичный бит.

Рассмотрим некоторое число, представим его как [math]0\dots01b \dots b[/math], где [math]b[/math] — любое значение бита. Тогда, если совершить битовый сдвиг этого числа вправо на [math]1[/math] и произвести побитовое ИЛИ результата сдвига и исходного числа, мы получим результат [math]0\dots011b \dots b[/math]. Если мы повторим эту последовательность действий над полученным числом, но устроим сдвиг на [math]2[/math], то получим [math]0\dots01111b \dots b[/math]. При каждой следующей операции будем увеличивать модуль сдвига до следующей степени двойки. После некоторого количества таких операций (зависит от разрядности числа) мы получим число вида [math]0\dots01\dots1[/math]. Тогда результатом выполнения действий [math]x - (x \texttt{ \gt \gt }1)[/math] будет число, состоящее только из старшего бита исходного числа.

int power = 1
for i = 1..[math]\log_2{n}[/math]:    // n — разрядность числа
    x |= x >> power
    power <<= 1
result = x - (x >> 1)

Подсчет количества единичных битов

Способ 1

Самый простой способ посчитать количество единичных битов в числе [math]x[/math] — сдвигать его на [math]1[/math] вправо до тех пор, пока оно не станет равно нулю и в процессе смотреть на последний бит.

int answer = 0
while x != 0:
    answer += x & 1
    x >> 1

Способ 2

Пусть мы хотим посчитать количество единичных битов в числе [math]x[/math]. Если вычесть из [math]x[/math] единицу, то его младший единичный бит обнулится, а все последующие за ним биты примут значение [math]1[/math]. Если произвести операцию побитового И между [math]x[/math] и [math](x - 1)[/math], то мы получим число, побитово равное [math]x[/math] во всех позициях, кроме младшего единичного бита [math]x[/math] (в результирующем числе он будет нулевым). Таким образом, количество совершенных операций до того момента, как исходное число обратится в ноль, будет равно количеству единичных битов в нём.

int answer = 0
while x != 0:
    x &= x - 1
    answer++

Циклический сдвиг влево

Пусть дано число [math]x[/math] и надо совершить циклический сдвиг его битов влево. Желаемый результат можно получить, если объединить числа, полученные при выполнении обычного битового сдвига влево на необходимую величину и вправо на разность между разрядностью числа и величиной сдвига. Таким образом, мы сможем поменять местами начальную и конечную части числа.

int head, tail
head = x << a          // x — изменяемое число
                       // a — число позиций, на которое хотим выполнить сдвиг
if a != 0:
    tail = x >> (n - a)    // n — разрядность числа x
else:
    tail = 0
result = head | tail

Разворот битов

Чтобы получить биты числа [math]x[/math], записанные в обратном порядке, будем снимать значение младшего бита, умножать его на старшую незаписанную степень двойки и сдвигать число вправо на единицу для обработки следующих бит.

result = 0
position = 1 << (n - 1)    // n — разрядность числа x
while x != 0:
    result += (x & 1) * position
    position >>= 1
    x >>= 1

Применение для решения задач

Работа с битовыми масками

Для работы с подмножествами удобно использовать битовые маски. Применяя побитовые операции легко сделать следующее: найти дополнение [math](\sim mask)[/math], пересечение [math](mask_1\ \&\ mask_2)[/math], объединение [math](mask_1 \mid mask_2)[/math] множеств, установить бит по номеру [math](mask \mid (1\ \texttt{\lt \lt }\ x))[/math], снять бит по номеру [math](mask\ \&\ \sim(1\ \texttt{\lt \lt }\ x))[/math].

Битовые маски используются, например, при решении некоторых задач[1] динамического программирования.

Алгоритм Флойда

Основная статья: Алгоритм Флойда

Дерево Фенвика

Основная статья: Дерево Фенвика

Примечания

Источники информации