Викиконспекты - Вклад участника [ru]

Оптимальный префиксный код с длиной кодового слова не более L бит

2014-12-23T17:42:54Z

Ruslan.tkhakokhov:

'''Оптимальный префиксный код с длиной кодового слова не более L бит''' — это код, в котором длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к [[Задача_о_рюкзаке | задаче о рюкзаке]].

==Пример.==
Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

{| class="wikitable"
! Символ || Частота || Код
|- align = "center"
| A || 1 || 1111
|- align = "center"
| B || 2 || 1110
|- align = "center"
| C || 4 || 110
|- align = "center"
| D || 8 || 10
|- align = "center"
| E || 16 || 0
|}

Самое длинное кодовое слово здесь имеет длину <tex>4</tex>. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

{| class="wikitable"
! Символ || Частота || Код
|- align = "center"
| A || 1 || 000
|- align = "center"
| B || 2 || 001
|- align = "center"
| C || 4 || 010
|- align = "center"
| D || 8 || 011
|- align = "center"
| E || 16 || 1
|}

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину <tex>L</tex> бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение задачи о рюкзаке к генерации оптимального префиксного кода с длиной кодового слова не более L бит ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}\dots2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <tex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации оптимального префиксного кода с длиной кодового слова не более L бит ==
Пусть <tex>A=\{A,B,C\}</tex> — алфавит из трех различных символов, <tex>P=\{1,2,3\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
{| class="wikitable"
! Символ || Частота || Предметы
|- align = "center"
| A || 1 || <tex> (2^{-1}; 1), (2^{-2}; 1) </tex>
|- align = "center"
| B || 2 || <tex>(2^{-1}; 2), (2^{-2}; 2)</tex>
|- align = "center"
| C || 3 || <tex> (2^{-1}; 3), (2^{-2}; 3)</tex>
|}

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
*[[Задача_о_рюкзаке | Задача о рюкзаке]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Алгоритмы сжатия ]]

Оптимальный префиксный код с длиной кодового слова не более L бит

2014-12-23T17:40:54Z

Ruslan.tkhakokhov:

'''Оптимальный префиксный код с длиной кодового слова не более L бит''' — это код, в котором длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к [[Задача_о_рюкзаке | задаче о рюкзаке]].

==Пример.==
Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

{| class="wikitable"
! Символ || Частота || Код
|- align = "center"
| A || 1 || 1111
|- align = "center"
| B || 2 || 1110
|- align = "center"
| C || 4 || 110
|- align = "center"
| D || 8 || 10
|- align = "center"
| E || 16 || 0
|}

Самое длинное кодовое слово здесь имеет длину <tex>4</tex>. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

{| class="wikitable"
! Символ || Частота || Код
|- align = "center"
| A || 1 || 000
|- align = "center"
| B || 2 || 001
|- align = "center"
| C || 4 || 010
|- align = "center"
| D || 8 || 011
|- align = "center"
| E || 16 || 1
|}

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину <tex>L</tex> бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение задачи о рюкзаке к генерации оптимального префиксного кода с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации оптимального префиксного кода с длиной кодового слова не более L бит ==
Пусть <tex>A=\{A,B,C\}</tex> — алфавит из трех различных символов, <tex>P=\{1,2,3\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
{| class="wikitable"
! Символ || Частота || Предметы
|- align = "center"
| A || 1 || <tex> (2^{-1}; 1), (2^{-2}; 1) </tex>
|- align = "center"
| B || 2 || <tex>(2^{-1}; 2), (2^{-2}; 2)</tex>
|- align = "center"
| C || 3 || <tex> (2^{-1}; 3), (2^{-2}; 3)</tex>
|}

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
*[[Задача_о_рюкзаке | Задача о рюкзаке]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Алгоритмы сжатия ]]

Оптимальный префиксный код с длиной кодового слова не более L бит

2014-12-23T17:39:52Z

Ruslan.tkhakokhov:

'''Оптимальный префиксный код с длиной кодового слова не более L бит''' — это код, в котором длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к [[Задача_о_рюкзаке | задаче о рюкзаке]].

==Пример.==
Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

{| class="wikitable"
! Символ || Частота || Код
|- align = "center"
| A || 1 || 1111
|- align = "center"
| B || 2 || 1110
|- align = "center"
| C || 4 || 110
|- align = "center"
| D || 8 || 10
|- align = "center"
| E || 16 || 0
|}

Самое длинное кодовое слово здесь имеет длину <tex>4</tex>. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

{| class="wikitable"
! Символ || Частота || Код
|- align = "center"
| A || 1 || 000
|- align = "center"
| B || 2 || 001
|- align = "center"
| C || 4 || 010
|- align = "center"
| D || 8 || 011
|- align = "center"
| E || 16 || 1
|}

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение задачи о рюкзаке к генерации оптимального префиксного кода с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации оптимального префиксного кода с длиной кодового слова не более L бит ==
Пусть <tex>A=\{A,B,C\}</tex> — алфавит из трех различных символов, <tex>P=\{1,2,3\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
{| class="wikitable"
! Символ || Частота || Предметы
|- align = "center"
| A || 1 || <tex> (2^{-1}; 1), (2^{-2}; 1) </tex>
|- align = "center"
| B || 2 || <tex>(2^{-1}; 2), (2^{-2}; 2)</tex>
|- align = "center"
| C || 3 || <tex> (2^{-1}; 3), (2^{-2}; 3)</tex>
|}

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
*[[Задача_о_рюкзаке | Задача о рюкзаке]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Алгоритмы сжатия ]]

Оптимальный префиксный код с длиной кодового слова не более L бит

2014-12-23T17:38:15Z

Ruslan.tkhakokhov:

'''Оптимальный префиксный код с длиной кодового слова не более L бит''' — это код, в котором длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к [[Задача_о_рюкзаке | задаче о рюкзаке]].

==Пример.==
Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

{| class="wikitable"
! Символ || Частота || Код
|- align = "center"
| A || 1 || 1111
|- align = "center"
| B || 2 || 1110
|- align = "center"
| C || 4 || 110
|- align = "center"
| D || 8 || 10
|- align = "center"
| E || 16 || 0
|}

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

{| class="wikitable"
! Символ || Частота || Код
|- align = "center"
| A || 1 || 000
|- align = "center"
| B || 2 || 001
|- align = "center"
| C || 4 || 010
|- align = "center"
| D || 8 || 011
|- align = "center"
| E || 16 || 1
|}

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение задачи о рюкзаке к генерации оптимального префиксного кода с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации оптимального префиксного кода с длиной кодового слова не более L бит ==
Пусть <tex>A=\{A,B,C\}</tex> — алфавит из трех различных символов, <tex>P=\{1,2,3\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
{| class="wikitable"
! Символ || Частота || Предметы
|- align = "center"
| A || 1 || <tex> (2^{-1}; 1), (2^{-2}; 1) </tex>
|- align = "center"
| B || 2 || <tex>(2^{-1}; 2), (2^{-2}; 2)</tex>
|- align = "center"
| C || 3 || <tex> (2^{-1}; 3), (2^{-2}; 3)</tex>
|}

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
*[[Задача_о_рюкзаке | Задача о рюкзаке]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Алгоритмы сжатия ]]

Оптимальный префиксный код с длиной кодового слова не более L бит

2014-12-23T17:34:23Z

Ruslan.tkhakokhov:

'''Оптимальный префиксный код с длиной кодового слова не более L бит''' — это код, в котором длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к [[Задача_о_рюкзаке | задаче о рюкзаке]].

==Пример.==
Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 1 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение задачи о рюкзаке к генерации оптимального префиксного кода с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации оптимального префиксного кода с длиной кодового слова не более L бит ==
Пусть <tex>A=\{A,B,C\}</tex> — алфавит из трех различных символов, <tex>P=\{1,2,3\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
{| class="wikitable"
! Символ || Частота || Предметы
|- align = "center"
| A || 1 || <tex> (2^{-1}; 1), (2^{-2}; 1) </tex>
|- align = "center"
| B || 2 || <tex>(2^{-1}; 2), (2^{-2}; 2)</tex>
|- align = "center"
| C || 3 || <tex> (2^{-1}; 3), (2^{-2}; 3)</tex>
|}

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
*[[Задача_о_рюкзаке | Задача о рюкзаке]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Алгоритмы сжатия ]]

Оптимальный префиксный код с длиной кодового слова не более L бит

2014-12-18T17:03:31Z

Ruslan.tkhakokhov: Новая страница: «'''Оптимальный префиксный код с длиной кодового слова не более L бит''' — это код, в которо...»

'''Оптимальный префиксный код с длиной кодового слова не более L бит''' — это код, в котором длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к [[Задача_о_рюкзаке | задаче о рюкзаке]].

Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение задачи о рюкзаке к генерации оптимального префиксного кода с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации оптимального префиксного кода с длиной кодового слова не более L бит ==
Пусть <tex>A=\{A,B,C\}</tex> — алфавит из трех различных символов, <tex>P=\{1,2,3\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
{| class="wikitable"
! Символ || Частота || Предметы
|- align = "center"
| A || 1 || <tex> (2^{-1}; 1), (2^{-2}; 1) </tex>
|- align = "center"
| B || 2 || <tex>(2^{-1}; 2), (2^{-2}; 2)</tex>
|- align = "center"
| C || 3 || <tex> (2^{-1}; 3), (2^{-2}; 3)</tex>
|}

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
*[[Задача_о_рюкзаке | Задача о рюкзаке]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Алгоритмы сжатия ]]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T17:02:33Z

Ruslan.tkhakokhov:

'''Оптимальный префиксный код с длиной кодового слова не более L бит''' — это код, в котором длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к [[Задача_о_рюкзаке | задаче о рюкзаке]].

Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение задачи о рюкзаке к генерации оптимального префиксного кода с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации оптимального префиксного кода с длиной кодового слова не более L бит ==
Пусть <tex>A=\{A,B,C\}</tex> — алфавит из трех различных символов, <tex>P=\{1,2,3\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
{| class="wikitable"
! Символ || Частота || Предметы
|- align = "center"
| A || 1 || <tex> (2^{-1}; 1), (2^{-2}; 1) </tex>
|- align = "center"
| B || 2 || <tex>(2^{-1}; 2), (2^{-2}; 2)</tex>
|- align = "center"
| C || 3 || <tex> (2^{-1}; 3), (2^{-2}; 3)</tex>
|}

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
*[[Задача_о_рюкзаке | Задача о рюкзаке]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Алгоритмы сжатия ]]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T16:58:32Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' — это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к [[Задача_о_рюкзаке | задаче о рюкзаке]].

Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{A,B,C\}</tex> — алфавит из трех различных символов, <tex>P=\{1,2,3\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
{| class="wikitable"
! Символ || Частота || Предметы
|- align = "center"
| A || 1 || <tex> (2^{-1}; 1), (2^{-2}; 1) </tex>
|- align = "center"
| B || 2 || <tex>(2^{-1}; 2), (2^{-2}; 2)</tex>
|- align = "center"
| C || 3 || <tex> (2^{-1}; 3), (2^{-2}; 3)</tex>
|}

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
*[[Задача_о_рюкзаке | Задача о рюкзаке]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Алгоритмы сжатия ]]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T16:57:56Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' — это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к [[Задача_о_рюкзаке | задаче о рюкзаке]].

Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{A,B,C\}</tex> — алфавит из трех различных символов, <tex>P=\{1,2,3\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
{| class="wikitable"
! Символ || Частота || Предметы
|- align = "center"
| A || 1 || <tex> (2^{-1}; 1), (2^{-2}; 1) </tex>
|- align = "center"
| B || 2 || <tex>(2^{-1}; 2), (2^{-2}; 2)</tex>
|- align = "center"
| C || 3 || <tex> (2^{-1}; 3), (2^{-2}; 3)</tex>
|}
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
*[[Задача_о_рюкзаке | Задача о рюкзаке]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Алгоритмы сжатия ]]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T16:57:12Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' — это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к [[Задача_о_рюкзаке | задаче о рюкзаке]].

Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{A,B,C\}</tex> — алфавит из трех различных символов, <tex>P=\{1,2,3\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
{| class="wikitable"
! Символ || Частота || Предметы
|- align = "center"
| A || 1 || (2^{-1}; 1), (2^{-2}; 1)
|- align = "center"
| B || 2 || (2^{-1}; 2), (2^{-2}; 2)
|- align = "center"
| C || 3 || (2^{-1}; 3), (2^{-2}; 3)
|}
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
*[[Задача_о_рюкзаке | Задача о рюкзаке]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Алгоритмы сжатия ]]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T16:55:46Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' — это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к [[Задача_о_рюкзаке | задаче о рюкзаке]].

Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{A,B,C\}</tex> — алфавит из трех различных символов, <tex>P=\{1,2,3\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
{| class="wikitable"
! Символ || Частота || Предметы
|-
| A || 1 ||
|- align = "center"
| B || 2 ||
|- align = "center"
| C || 3 ||
|}
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
*[[Задача_о_рюкзаке | Задача о рюкзаке]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Алгоритмы сжатия ]]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T16:53:35Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' — это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к [[Задача_о_рюкзаке | задаче о рюкзаке]].

Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{A,B,C\}</tex> — алфавит из трех различных символов, <tex>P=\{1,2,3\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
{| class="wikitable"
! Символ || Частота || Предметы
|-
| A || 1 ||
|-
| B || 2 ||
|-
| C || 3 ||
|}
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
*[[Задача_о_рюкзаке | Задача о рюкзаке]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Алгоритмы сжатия ]]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T16:49:58Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' — это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к [[Задача_о_рюкзаке | задаче о рюкзаке]].

Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из <tex>n</tex> различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
{| class="wikitable"
! Символ || Частота || Предметы
|-
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
*[[Задача_о_рюкзаке | Задача о рюкзаке]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Алгоритмы сжатия ]]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T16:45:52Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' — это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к [[Задача_о_рюкзаке | задаче о рюкзаке]].

Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из <tex>n</tex> различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
*[[Задача_о_рюкзаке | Задача о рюкзаке]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Алгоритмы сжатия ]]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T16:44:51Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' — это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к [[Задача_о_рюкзаке | задаче о рюкзаке]].

Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из <tex>n</tex> различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
*[[Задача_о_рюкзаке | Задача о рюкзаке]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T16:44:24Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' — это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к [[Задача_о_рюкзаке | задача о рюкзаке]].

Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из <tex>n</tex> различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
*[[Задача_о_рюкзаке | Задача о рюкзаке]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T16:42:56Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' — это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к задаче о рюкзаке.

Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из <tex>n</tex> различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
*[[Задача_о_рюкзаке | Задача о рюкзаке]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T16:41:19Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' — это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к задаче о рюкзаке.

Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из <tex>n</tex> различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==См. также==
*[[Алгоритм_Хаффмана | Алгоритм Хаффмана]]

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T16:38:02Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' — это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к задаче о рюкзаке.

Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из <tex>n</tex> различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T16:35:00Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' — это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к задаче о рюкзаке.

Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита. Алгоритм генерации кода будет следующим:

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T16:31:53Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' — это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к задаче о рюкзаке.

Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}</tex>, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T16:29:51Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' — это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> — максимальная длина кодового слова, <tex>n</tex> — размер алфавита, c помощью сведения задачи к задаче о рюкзаке.

Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> — ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> предметов ценностью <tex>2^{-1}..2^{-L}, каждый из которых имеет вес <tex>p_{i}</tex>.
# С помощью задачи о рюкзаке выберем набор предметов суммарной ценностью <ex>n - 1</tex> (<tex>n</tex> — размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> — количество предметов ценностью <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> — это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин — в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> — ограничение на длину кодового слова.

Сначала создадим необходимый набор предметов;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Решим задачу о рюкзаке для заданного набора и выберем предметы суммарной ценностью <tex> n - 1 = 2 </tex> с минимальным суммарным весом. В нашем случае в оптимальный набор попадут следующие предметы:

<tex>(2^{-1}; 1), (2^{-1}; 2), (2^{-1}; 3), (2^{-2}; 1), (2^{-2}; 2) </tex>

Посчитаем массив <tex> H </tex>:

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> — соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T14:00:44Z

Ruslan.tkhakokhov:

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T13:59:43Z

Ruslan.tkhakokhov:

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T13:51:30Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.
Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Самое длинное кодовое слово здесь имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

Важно заметить следующий факт. В худшем случае все кодовые слова будут иметь длину L бит. Тогда мы можем закодировать <tex> 2^L </tex> символов. Таким образом, нельзя получить описанный выше код, если <tex> n > 2^L </tex>.

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{0} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex>
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> - соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T13:43:38Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.
Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Заметим, что самое длинное кодовое слово имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

При этом очевидно, что если <tex> n > 2^L </tex>, то перефиксного кода с длиной слова не более <tex> L </tex> бит не существует.

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

Заметим, что при генерации каждого следующего кодового слова, в качестве его префикса выступает последовательность, лексикографически большая, чем предыдущее кодовое слово (т.к. мы берем следующее двоичное число), а значит ни для каких двух кодовых слов одно не может быть префиксом другого. Т.е. код, сгенерированный таким образом является префиксным.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{0} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex>
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> - соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T05:26:37Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.
Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Заметим, что самое длинное кодовое слово имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

При этом очевидно, что если <tex> n > 2^L </tex>, то перефиксного кода с длиной слова не более <tex> L </tex> бит не существует.

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{0} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex>
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> - соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T05:23:39Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.
Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Заметим, что самое длинное кодовое слово имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

При этом очевидно, что если <tex> n > 2^L </tex>, то перекидного кода с длиной слова не более <tex> L </tex> бит не существует.

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{0} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex>
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> - соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-18T05:22:14Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.
Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Заметим, что самое длинное кодовое слово имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{0} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex>
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> - соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Источники информации==
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T17:27:18Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.
Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>

<tex> B = 1110 </tex>

<tex> C = 110 </tex>

<tex> D = 10 </tex>

<tex> E = 0 </tex>

Заметим, что самое длинное кодовое слово имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>

<tex> B = 001 </tex>

<tex> C = 010 </tex>

<tex> D = 011 </tex>

<tex> E = 100 </tex>

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{0} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex>
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> - соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Ссылки==
*[http://en.wikipedia.org/wiki/Huffman_coding Huffman Coding]
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T17:26:45Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.
Данный алгоритм бывает полезен, когда нам нужно ограничить максимальную длину кодового слова, а при использовании алгоритма Хаффмана самому редко встречающемуся символу соответствует слишком длинное кодовое слово. Например, пусть дан алфавит из 5 символов <tex>A=\{A,B,C, C, D\}</tex>, а частоты символов являются степенями двойки: <tex>P=\{1,2,4, 8, 16\}</tex>. Тогда классический код Хоффмана будет выглядеть следующим образом:

<tex> A = 1111 </tex>
<tex> B = 1110 </tex>
<tex> C = 110 </tex>
<tex> D = 10 </tex>
<tex> E = 0 </tex>

Заметим, что самое длинное кодовое слово имеет длину 4. Пусть мы хотим, чтобы слова в нашем коде были не длиннее трех бит. Тогда алгоритм, который будет описан ниже, генерирует такой код:

<tex> A = 000 </tex>
<tex> B = 001 </tex>
<tex> C = 010 </tex>
<tex> D = 011 </tex>
<tex> E = 100 </tex>

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{0} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex>
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> - соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Ссылки==
*[http://en.wikipedia.org/wiki/Huffman_coding Huffman Coding]
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:44:47Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{0} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex>
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{A,B,C\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> - соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Ссылки==
*[http://en.wikipedia.org/wiki/Huffman_coding Huffman Coding]
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:40:20Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{0} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex>
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> - соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 0 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Ссылки==
*[http://en.wikipedia.org/wiki/Huffman_coding Huffman Coding]
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:37:11Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{0} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex>
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> - соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 00 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Ссылки==
*[http://en.wikipedia.org/wiki/Huffman_coding Huffman Coding]
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:36:18Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex>
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> - соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 00 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Ссылки==
*[http://en.wikipedia.org/wiki/Huffman_coding Huffman Coding]
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:35:30Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || X || X || X
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex> || X || X
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> - соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 00 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Ссылки==
*[http://en.wikipedia.org/wiki/Huffman_coding Huffman Coding]
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:34:41Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex> || ||
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> - соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 00 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Ссылки==
*[http://en.wikipedia.org/wiki/Huffman_coding Huffman Coding]
*[http://en.wikipedia.org/wiki/Package-merge_algorithm Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:33:51Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex> || ||
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> - соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 00 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

==Ссылки==
*[http://en.wikipedia.org/wiki/Huffman_coding — Huffman Coding]
*[http://en.wikipedia.org/wiki/Package-merge_algorithm - Package-merge algorithm]
*[http://en.wikipedia.org/wiki/Canonical_Huffman_code - Canonical Huffman code]

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:29:01Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex> || ||
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> - соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:

<tex> C = 00 </tex>

Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:

<tex> B = 10 </tex>

Сопоставим следующему символу следующее двоичное число.

<tex> A = 11 </tex>

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:28:28Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex> || ||
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, а также <tex>H=\{2,2,1\}</tex> - соответсвующие длины кодовых слов. Отсортируем символы в соответсвии с этими длинами.

Сопоставим первому символу код, состоящий из 1 нуля:
<tex> C = 00 </tex>
Сопоставим следующему символу следующее двоичное число. Т.к. длина кода увеличилась на один, то припишем справа ноль:
<tex> B = 10 </tex>
Сопоставим следующему символу следующее двоичное число.
<tex> A = 11 </tex>

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:24:29Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор частот. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex> || ||
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{2,2,1\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Итак, у нас есть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{1, 2, 3\}</tex> — соответствующий ему набор частот, а также <tex>H=\{2,2,1\}</tex> - соответсвующие длины кодовых слов

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:21:39Z

Ruslan.tkhakokhov:

'''Код Хаффмана с длиной слова не более L бит''' - это вариация классического кода Хоффмана с дополнительным ограничением: длина каждого кодового слова не должна превышать заданной константы. Здесь будет приведен алгоритм, решающий эту задачу за время <tex> O(nL) </tex>, где <tex>L</tex> - максимальная длина кодового слова, <tex>n</tex> - размер алфавита, c помощью сведения задачи к одной из вариаций '''задачи о банкомате'''.

== Задача о банкомате. ==
В вариации задаче о банкомате, которую мы рассмотрим, у вас имеется <tex>N</tex> монет. Каждая монета характеризуется двумя параметрами: номиналом и весом. При этом все номиналы являются степенями двойки и не превышают <tex>2^0</tex>. Необходимо выбрать из имеющихся монет некоторый набор так, чтобы их суммарный номинал был равен <tex>S</tex> (натуральное число), а суммарный вес минимален.

== Алгоритм решения задачи о банкомате. ==
Рассмотрим алгоритм решения приведенной выше вариации задачи о банкомате, считая, что решение существует.
# Разделим имеющиеся у нас монеты на списки по номиналу (свой список для каждого номинала) и упорядочим монеты по возрастанию весов внутри списков, а списки в порядке возрастания номиналов.
# Рассмотрим первый список (с монетами самого низкого номинала). Разобьем в нем все монеты на пары (1 и 2, 3 и 4 и т. д.) Заменим каждую пару монет одной новой монетой, номинал и вес которой равен сумме номиналов и весов старых. Если число монет было нечетно, то последнюю монету, которая не имеет пары, исключим из рассмотрения.
# Объединим первый список со вторым так, чтобы монеты в получившемся списке остались упорядочены по весу.
# Будем повторять шаги 2-3 до тех пор, пока у нас не останется один список, в котором содержатся монеты номинала 1 (<tex>2^0</tex>), упорядоченные по весу. Возьмем первые <tex>S</tex> монет из списка. Это и будет ответ к задаче.

== Сведение к генерации кода Хоффмана с длиной кодового слова не более L бит. ==
Пусть <tex>L</tex> - ограничение на длину кодового слова, а <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> - частоты символов алфавита.

# Отсортируем символы алфавита в порядке возрастания их частот.
# Для каждого символа создадим <tex>L</tex> монет номиналами <tex>2^{-1}..2^{-L}, каждая из которых имеет вес <tex>p_{i}</tex>.
# С помощью описанного выше алгоритма выберем набор монет суммарным номиналом <tex>n - 1</tex> (<tex>n</tex> - размер алфавита) с минимальным суммарным весом.
# Посчитаем массив <tex>H=\{h_{1},h_{2},...,h_{n}\}</tex>, где <tex>h_{i}</tex> - количество монет номинала <tex>p_{i}</tex>, которые попали в наш набор.

При этом <tex>h_{i}</tex> - это длина кодового слова для <tex>i</tex>-го символа.Зная длины кодовых слов, легко восстановить и сам код.

== Восстановление ответа. ==
# Отсортируем все символы по возрастанию длины кодового слова, которое им соответствует, а при равенстве длин - в алфавитном порядке.
# Первому символу сопоставим код, состоящий из нулей, соответствующей длины.
# Каждому следующему символу сопоставим следующее двоичное число. При этом если его длина меньше необходимой, то допишем нули справа.

== Пример работы алгоритма генерации кода Хоффмана с длиной кодового слова не более L бит ==
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из n различных символов, <tex>P=\{p_{1},p_{2},...,p_{n}\}</tex> — соответствующий ему набор положительных целых весов. Пусть <tex>L = 2</tex> - ограничение на длину кодового слова.

Сначала создадим необходимый набор монет;
<tex>(2^{-1}; 1), (2^{-2}; 1), (2^{-1}; 2), (2^{-2}; 2), (2^{-1}; 3), (2^{-2}; 3) </tex>

Распределим их по спискам:
{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-2}; 1)</tex> || <tex>(2^{-2}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Выполним объединение первого списка по парам и исключим последний элемент, т.к. для него нет пары:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || <tex>(2^{-1}; 3)</tex> || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-2}; 3)</tex>
|}

Объединим первый список со вторым:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{-1}; 1)</tex> || <tex>(2^{-1}; 2)</tex> || <tex>(2^{-1}; 3)</tex> || <tex>(2^{-1}; 3)</tex>
|}

Выполним объединение второго списка по парам:

{| class="wikitable"
| Номинал = <tex> 2^{-2} </tex> || || ||
|-
| Номинал = <tex> 2^{-1} </tex> || <tex>(2^{0}; 3)</tex> || <tex>(2^{0}; 6)</tex> || ||
|}

Теперь нам нужно набрать монеты суммарным номиналом <tex> n - 1 = 2 </tex> с минимальным суммарным весом, т.е. просто возьмем первые две монеты из итогового списка. Посчитаем массив <tex> H </tex>. Обратите внимание, что при подсчете количества монет определенного веса мы учитываем монеты, которые были даны изначально, а не те, которые получились путем слияния исходных.

<tex>H=\{1,2,2\}</tex>

Итак, мы получили длины кодовых слов для символов. Осталось восстановить ответ.

== Пример восстановления ответа. ==

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:20:39Z

Ruslan.tkhakokhov:

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:18:03Z

Ruslan.tkhakokhov:

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:16:27Z

Ruslan.tkhakokhov:

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:14:53Z

Ruslan.tkhakokhov:

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:13:15Z

Ruslan.tkhakokhov:

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:12:00Z

Ruslan.tkhakokhov:

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:08:46Z

Ruslan.tkhakokhov:

Код Хаффмана с длиной кодового слова не более L бит

2014-12-17T16:07:07Z

Ruslan.tkhakokhov: