Жанр: Учеба
Программирование в теоремах и задачах
...).
Количество действий не должно превосходить константы, умноженной
на суммарную длину всех слов (из списка и того, в котором
происходит поиск).
Решение. Очевидный способ состоит в том, чтобы каждое слово
из списка проверять отдельно (с помощью одного из рассмотренных
алгоритмов). Однако при этом мы не укладываемся в заданное число
действий (из-за умножения k на длину слова Y).
Посмотрим на дело с другой стороны. Каждому образцу из
списка соответствует конечный автомат с некоторым множество состояний.
Их можно объединить в один автомат, множеством состояний
которого будет произведение множеств состояний всех тех автоматов.
Это - очень большое множество. Однако на самом деле
большинство его элементов недоступны (не могут появиться при
чтении входного слова) и за счет этого получается экономия. Примерно
эту идею (но в измененном виде) мы и будем использовать.
Вспомним алгоритм Кнута - Морриса - Пратта. В нем, читая
входное слово, мы хранили наибольшее начало образца, являющееся
концом прочитанной части. Теперь нам следует хранить для каждого
из образцов наибольшее его начало, являющееся концом прочитанной
части. Решающим оказывается такое замечание: достаточно хранить
самое длинное из них - все остальные по нему восстанавливаются
(как наибольшие начала образцов, являющиеся его концами).
Склеим все образцы в дерево, объединив их совпадающие начальные
участки. Например, набору образцов
{aaa, aab, abab}
соответствует дерево
a/ *
a a / b
* --- * --- * --- *
\b a b
\ * --- * --- *
Формально говоря, вершинами дерева являются все начала всех образцов,
а сыновья вершины получаются приписыванием буквы.
Читая входное слово, мы двигаемся по этому дереву: текущая вершина
- это наибольшая (самая правая) из вершин, являющихся концом
прочитанной части (=наибольший конец прочитанной части, являющийся
началом одного из образцов).
Определим функцию n, аргументами и значениями которой являются
вершины дерева. Именно, n(P) = наибольшая вершина дерева, являющаяся
концом P. (Напомним, вершины дерева - это слова.) Нам понадобится
такое утверждение:
10.7.4. Пусть P - вершина дерева. Докажите, что множество
всех вершин, являющихся концами P, равно {n(P), n(n(P)),...}
Решение. См. доказательство аналогичного утверждения для
алгоритма Кнута - Морриса - Пратта.
Теперь ясно, что нужно делать, находясь в вершине P и читая
букву y входного слова. Надо просматривать последовательно вершины
P, n(P), n(n(P)) и т.д., пока не обнаружится такая, из которой
выходит стрелка с буквой y. Та вершина, в которую эта
стрелка ведет, и будет нашим следующим положением.
Остается понять, как для каждой вершины дерева вычислить
указатель на значение функции n в этой вершине. Это делается как
раньше, при этом значения n для более коротких слов используются
при вычислении очередного значения функции n. Это означает, что
вершины дерева следует просматривать в порядке возрастания их
длины. Нетрудно понять, что все это можно уложить в требуемое
число действий (хотя константа зависит от числа букв в алфавите).
Относящиеся к этому подробности см. в главе об алгоритмах
на графах.
Можно поинтересоваться, какие свойства слов можно распознавать
с помощью конечных автоматов. Оказывается, что существует
просто описываемый класс образцов, задающий все такие свойства -
класс регулярных выражений.
Определение. Пусть фикисирован конечный алфавит Г, не содержащий
символов 'l', 'e', '(', ')', '*' и '|' (они будут использоваться
для построения регулярных выражений и не должны перемешиваться
с буквами). Регулярные выражения строятся по таким
правилам:
(а) буква алфавита Г - регулярное выражение;
(б) символы 'l', 'e' - регулярные выражения;
(в) если A,B,C,..,E - регулярные выражения, то (ABC...E) -
регулярное выражение.
(г) если A,B,C,..,E - регулярные выражения, то
(A|B|C|...|E) - регулярное выражение.
(д) если A - регулярное выражение, то A* - регулярное выра-
жение.
Каждое регулярное выражение задает множество слов в алфавите Г
по таким правилам:
(а) букве соответствует одноэлементное множество, состоящее
из однобуквенного слова, состоящего из этой буквы;
(б) символу 'e' соответствует пустое множество, а символу
'l' - одноэлементное множество, единственным элементом
которого является пустое слово;
(в) регулярному выражению (ABC...E) соответствует множество
всех слов, которые можно получить, если к слову из A
приписать слово из B, затем из C,..., затем из E ("кон-
катенация" множеств);
(г) регулярному выражению (A|B|C|...|E) соответствует
объединение множеств, соответствующих выражениям
A,B,C,..,E;
(д) регулярному выражению A* соответствует "итерация" мно-
жества, соответствующего выражению A, то есть множество
всех слов, которые можно так разрезать на куски, что
каждый кусок принадлежит множеству, соответствующему
выражению A. (В частности, пустое слово всегда содер-
жится в A*.)
Примеры
Выражение Множество
(a|b)* все слова из букв a и b
(aa)* все слова из четного числа букв a
(l|a|b|aa|ab|ba|bb) любое слово из не более чем 2 букв a,b
10.7.5. Написать регулярное выражение, которому соответствует
множество всех слов из букв a и b, в которых число
букв a четно.
Решение. Выражение b* задает все слова без a, а выражение
(b* a b* a b*)
- все слова ровно с двумя буквами a. Остается объединить эти
множества, а потом применить итерацию:
((b* a b* a b*) | b*)*
10.7.6. Написать регулярное выражение, которое задает множество
всех слов из букв a,b,c, в которых слово bac является
подсловом.
Решение. ((a|b|c)* bac (a|b|c)*)
Теперь задачу о поиске образца в слове можно переформулировать
так: проверить, принадлежит ли слово множеству, соответствующему
данному регулярному выражению.
10.7.7. Какие выражения соответствуют образцам a?b и ab*cd,
рассмотренным ранее? (В образце '*' используется не в том смысле,
что в регулярных выражениях!) Предполается, что алфавит содержит
буквы a,b,c,d,e.
Решение. ((a|b|c|d|e)* a (a|b|c|d|e) b (a|b|c|d|e)*) и
((a|b|c|d|e)* ab (a|b|c|d|e)* cd (a|b|c|d|e)*).
10.7.8. Доказать, что для всякого регулярного выражения
можно построить конечный автомат, который распознает соответствующее
этому выражению множество слов.
Решение. Нам потребуется новое понятие - понятие источника
(или недетерминированного конечного автомата). Представим себе
ориентированный граф - картинку из нескольких точек (вершин) и
некоторых стрелок, соединяющих эти точки (ребер). Пусть на некоторых
ребрах написаны буквы (не обязательно на всех). Пусть также
среди вершин выбраны две - начальная Н и конечная К. Такая
картинка называется источником.
Будем двигаться различными способами из Н в К, читая буквы
по дороге (на тех стрелках, где они есть). Каждому пути из Н в
К, таким образом, соответствует некоторое слово. А источнику в
целом соответствует множество слов - тех слов, которые можно
прочесть на путях из Н в К.
Замечание. Если нарисовать состояния конечного автомата в
виде точек, а переходы при чтении букв изобразить в виде стрелок,
то станет ясно, что конечный автомат - это частный случай
источника.
Мы будем строить конечный автомат по регулярному выражению
в два приема. Сначала мы построим источник, которому соответствует
то же самое множество слов. Затем для произвольного
источника построим автомат, который проверяет, принадлежит ли
слово соответствующему множеству.
10.7.9. По регулярному выражению построить источник, задающий
то же множество.
Решение. Индукция по построению регулярного выражения. Буквам
соответствуют графы из одной стрелки. Объединение реализуется
так:
|---------|
----"|*Н1 К1*|-"---
/ |---------| \
/ |---------| \
* ---------"|*Н2 К2*|---"-----* К
Н \ |---------| /
\ |---------| /
---"|*Н3 К3*|---"--
|---------|
Нарисована картинка для объединения трех множеств, прямоугольники
- это источники, соответствующие им; указаны начальные
и конечные вершины. На новых стрелках (их 6) букв не написано.
Конкатенации соответствует картинка
|--------| |--------| |--------|
Н*---"|*Н1 К1*|----"----|*Н2 К2*| ----"----|*Н3 К3*|--"--*К
|--------| |--------| |--------|
Наконец, итерации соответствует картинка
Н*---------"----------*-----------"----------*К
/ \
/ \
| |
V ^
| |
-------------
| *Н1 К1* |
-------------
10.7.10. Дан источник. Построить конечный автомат, проверяющий,
принадлежит ли входное слово множеству, соответствующему
источнику (т.е. можно ли прочесть это слово, идя из Н в К).
Решение. Состояниями автомата будут множества вершин источника.
Именно, прочтя некоторое начало X входного слова, мы будем
помнить множество всех вершин источника, в которые можно пройти
из начальной, прочитав на пути слово X.
Оказывается, что регулярные выражения, автоматы и источники
распознают одни и те же множества. Чтобы убедиться в этом, нам
осталось решить такую задачу:
10.7.11. Дан источник. Построить регулярное выражение, задающее
то же множество, что и этот источник.
Решение. (Сообщено участниками просеминара по логике.)
Пусть источник имеет вершины 1..k. Будем считать, что 1 - это
начало, а k - конец. Через D[i,j, s] обозначим множество всех
слов, которые можно прочесть на пути из i в j, если в качестве
промежуточных пунктов разрешается использовать только вершины
1,...,s. Согласно определению, источнику соответствует множество
D[1,k,k].
Индукцией по s будем доказывать регулярность всех множеств
D[i,j,s] при всех i и j. При s=0 это очевидно (промежуточные
вершины запрещены, поэтому каждое из множеств состоит только из
букв).
Из чего состоит множество D[i,j,s+1]? Отметим на пути моменты,
в которых он заходит в s+1-ую вершину. При этом путь разбивается
на части, каждая из которых уже не заходит в нее. Поэтому
легко сообразить, что
D[i,j,s+1] = (D[i,j,s]| (D[i,s+1,s] D[s+1,s+1,s]* D[s+1,j,s]))
(вольность записи: мы используем для операций над множествами
обозначения как для регулярных выражений). Остается воспользоваться
предположением индукции.
10.7.12. Где еще используется то же самое рассуждение?
Ответ. В алгоритме Флойда вычисления цены кратчайшего пути,
см. главу 9 (Некоторые алгоритмы на графах).
10.7.13. Доказать, что класс множеств, задаваемых регулярными
выражениями, не изменился бы, если бы мы разрешили использовать
не только объединение, но и отрицание (а следовательно,
и пересечение - оно выражается через объединение и отрицание).
Решение. Для автоматов переход к отрицанию очевиден.
Замечание. На практике важную роль играет число состояний
автомата. Оказывается, что тут все не так просто, и переход о
источника к автомату требует экспоненциального роста числа состояний.
Подробное рассмотрение связанных с этим теоретических и
практических вопросов - дело особое.
Глава 11. Представление множеств. Хеширование.
11.1. Хеширование с открытой адресацией
В предыдущей главе было несколько представлений для множеств,
элементами которых являются целые числа произвольной величины.
Однако в любом из них хотя бы одна из операций проверки
принадлежности, добавления и удаления элемента требовала количества
действий, пропорционального числу элементов множества. На
практике это бывает слишком много. Существуют способы, позволяющие
получить для всех трех упомянутых операций оценку C*log n.
Один из таких способов мы рассмотрим в следующей главе. В этой
главе мы разберем способ, которые хотя и приводит к C*n действиям
в худшем случае, но зато "в среднем" требует значительно
меньшего их числа. (Мы не будем уточнять слов "в среднем", хотя
это и можно сделать.) Этот способ называется хешированием.
Пусть нам необходимо представлять множества элементов типа
T, причем число элементов заведомо меньше n. Выберем некоторую
функцию h, определенную на значениях типа T и принимающую значения
0..(n-1). Было бы хорошо, чтобы эта функция принимала на
элементах будущего множества по возможности более разнообразные
значения. Худший случай - это когда ее значения на всех элементах
хранимого множества одинаковы. Эту функцию будем называть
хеш-функцией.
Введем два массива
val: array [0..n-1] of T;
used: array [0..n-1] of boolean;
(мы позволяем себе писать n-1 в качестве границы в определении
типа, хотя в паскале это не разрешается). В этих массивах будут
храниться элементы множества: оно равно множеству всех val [i]
для тех i, для которых used [i], причем все эти val [i] различны.
По возможности мы будем хранить элемент t на месте h(t),
считая это место "исконным" для элемента t. Однако может случиться
так, что новый элемент, который мы хотим добавить, претендует
на уже занятое место (для которого used истинно). В этом
случае мы отыщем ближайшее справа свободное место и запишем элемент
туда. ("Справа" значит "в сторону увеличения индексов";
дойдя до края, мы перескакиваем в начало.) По предположению,
число элементов всегда меньше n, так что пустые места гарантированно
будут.
Формально говоря, в любой момент должно соблюдаться такое
требование: для любого элемента множества участок справа от его
исконного места до его фактического места полностью заполнен.
Благодаря этому проверка принадлежности заданного элемента
t осуществляется легко: встав на h(t), двигаемся направо, пока
не дойдем до пустого места или до элемента t. В первом случае
элемент t отсутствует в множестве, во втором присутствует. Если
элемент отсутствует, то его можно добавить на найденное пустое
место. Если присутствует, то можно его удалить (положив used =
false).
11.1.1. В предыдущем абзаце есть ошибка. Найдите ее и
исправьте.
Решение. Дело в том, что при удалении требуемое свойство
"отсутствия пустот" может нарушиться. Поэтому будем делать так.
Создав дыру, будем двигаться направо, пока не натолкнемся на еще
одно пустое место (тогда на этом можно успокоиться) или на элемент,
стоящий не на исконном месте. Во втором случае посмотрим,
не нужно ли этот элемент поставить на место дыры. Если нет, то
продолжаем поиск, если да, то затыкаем им старую дыру. При этом
образуется новая дыра, с которой делаем все то же самое.
11.1.2. Написать программы проверки принадлежности, добавления
и удаления.
Решение.
function принадлежит (t: T): boolean;
| var i: integer;
begin
| i := h (t);
| while used [i] and (val [i] "" t) do begin
| | i := (i + 1) mod n;
| end; {not used [i] or (val [i] = t)}
| belong := used [i] and (val [i] = t);
end;
procedure добавить (t: T);
| var i: integer;
begin
| i := h (t);
| while used [i] and (val [i] "" t) do begin
| | i := (i + 1) mod n;
| end; {not used [i] or (val [i] = t)}
| if not used [i] then begin
| | used [i] := true;
| | val [i] := t;
| end;
end;
procedure исключить (t: T);
| var i, gap: integer;
begin
| i := h (t);
| while used [i] and (val [i] "" t) do begin
| | i := (i + 1) mod n;
| end; {not used [i] or (val [i] = t)}
| if used [i] and (val [i] = t) then begin
| | used [i] := false;
| | gap := i;
| | i := (i + 1) mod n;
| | while used [i] do begin
| | | if i = h (val[i]) then begin
| | | | i := (i + 1) mod n;
| | | end else if dist(h(val[i]),i) " dist(gap,i) then begin
| | | | i := (i + 1) mod n;
| | | end else begin
| | | | used [gap] := true;
| | | | val [gap] := val [i];
| | | | used [i] := false;
| | | | gap := i;
| | | | i := i + 1;
| | | end;
| | end;
| end;
end;
Здесь dist (a, b) - измеренное по часовой стрелке (слева
направо) расстояние от a до b, т.е.
dist (a,b) = (b - a + n) mod n.
(Мы прибавили n, так как функция mod правильно работает только
при положительном делимом.)
11.1.3. Существует много вариантов хеширования. Один из них
таков: обнаружив, что исконное место (обозначим его i) занято,
будем искать свободное не среди i+1, i+2,..., а среди r(i),
r(r(i)), r(r(r(i))),..., где r - некоторое отображение 0..n-1 в
себя. Какие при этом будут трудности?
Ответ. (1) Не гарантируется, что если пустые места есть, то
мы их найдем. (2) При удалении неясно, как заполнять дыры. (На
практике во многих случаях удаление не нужно, так что такой способ
также применяется. Считается, что удачный подбор r может
предотвратить образование "скоплений" занятых ячеек.)
11.1.4. Пусть для хранения множества всех правильных
русских слов в программе орфографии используется хеширование.
Что нужно добавить, чтобы к тому же уметь находить английский
перевод любого правильного слова?
Решение. Помимо массива val, элементы которого являются
русскими словами, нужен параллельный массив их английских переводов.
11.2. Хеширование со списками
На хеш-функцию с m значениями можно смотреть как на способ
свести вопрос о хранении одного большого множества к вопросу о
хранении нескольких меньшим. Именно, если у нас есть хеш-функция
с m значениями, то любое множество разбивается на m подмножеств
(возможно, пустых), соответствующих возможных значениям
хэш-функции. Вопрос о проверке принадлежности, добавлении или
удалении для большого множества сводится к такому же вопросу для
одного из меньших (чтобы узнать, для какого, надо посмотреть на
значение хеш-функции).
В принципе, эти меньшие множества могут храниться любым
способом (раз они малы, это не очень важно), но удобно их хранить
с помощью ссылок, поскольку нам известен их суммарный размер
(равный числу элементов хешируемого множества). Следующая
задача предлагает реализовать этот план.
11.2.1. Пусть хеш-функция принимает значения 1..k. Для каждого
значения хеш-функции рассмотрим список всех элементов множества
с данным значением хеш-функции. Будем хранить эти k списков
с помощью переменныхтак же, как мы это делали для k стеков ограниченной суммарной
длины. Напишите соответствующие программы. (Теперь с удалением
будет меньше проблем.)
Решение. Перед началом работы надо положить Вершина[i]=0
для всех i=1..k, и связать все места в список свободного
пространства, положив ПервСвоб=1 и Следующий[i]=i+1 для
i=1..n-1, а также Следующий[n]=0.
function принадлежит (t: T): boolean;
| var i: integer;
begin
| | i := Вершина[h(t)];
| i := Вершина[h(t)];
| {осталось искать в списке, начиная с i}
| while (i "" 0) and (Содержание[i] "" t) do begin
| | i := Следующий[i];
| end; {(i=0) or (Содержание [i] = t)}
| belong := Содержание[i]=t;
end;
procedure добавить (t: T);
| var i: integer;
begin
| if not принадлежит(t) then begin
| | i := ПервСвоб;
| | {ПервСвоб "" 0 - считаем, что не переполняется}
| | ПервСвоб := Следующий[ПервСвоб]
| | Содержание[i]:=t;
| | Следующий[i]:=Вершина[h(t)];
| | Вершина[h(t)]:=i;
| end;
end;
procedure исключить (t: T);
| var i, pred: integer;
begin
| i := Вершина[h(t)]; pred := 0;
| {осталось искать в списке, начиная с i; pred -
| предыдущий. если он есть, и 0, если нет}
| while (i "" 0) and (Содержание[i] "" t) do begin
| | pred := i; i := Следующий[i];
| end; {(i=0) or (Содержание [i] = t)}
| if Содержание[i]=t then begin
| | {элемент есть, надо удалить}
| | if pred = 0 then begin
| | | {элемент оказался первым в списке}
| | | Вершина[h(t)] := Следующий[i];
| | end else begin
| | | Следующий[pred] := Следующий[i]
| | end;
| | {осталось вернуть i в список свободных}
| | Следующий[i] := ПервСвоб;
| | ПервСвоб:=i;
| end;
end;
11.2.2. (Для знакомых с теорией вероятностей.) Пусть
хеш-функция с m значениями используется для хранения множества,
в котором в данный момент n элементов. Доказать, что математическое
ожидание числа действий в предыдущей задаче не превосходит
С*(1+n/m), если добавляемый (удаляемый, искомый) элемент t
выбран случайно, причем все значения h(t) имеют равные вероятности
(равные 1/m).
Решение. Если l(i) - длина списка, соответствующего
хеш-значению i, то число операцией не превосходит C*(1+l(h(i)));
усредняя, получаем искомый ответ, так как сумма всех l(i) равна
n.
Эта оценка основана на предположении о равных вероятностях.
Однако в конкретной ситуации всё может быть совсем не так, и
значения хеш-функции могут "скучиваться": для каждой конкретной
хеш-функции есть "неудачные" ситуации, когда число действий оказывается
большим. Приём, называемый "универсальным хешированием",
позволяет обойти эту проблему. Идея состоит в том, что берётся
семейство хеш-функций, причем любая ситуация оказывается
неудачной лишь для небольшой части этого семества.
Пусть H - семейство функций, каждая из которых отображает
множество T в множество из n элементов (например, 0..n-1). Говорят,
что H - универсальное семейство хеш-функций, если для любых
двух различных значений s и t из множества T вероятность события
"h(s)=h(t)" для случайной функции h из семейства H равна 1/n.
(Другими словами, те функции из H, для которых h(s)=h(t), составляют
1/n-ую часть всех функций в H.)
Замечание. Более сильное требование к семейству H могло бы
состоять в том, чтобы для любых двух различных элементов s и t
множества T значения h(s) и h(t) случайной функции h являются
независимыми случайными величинами, равномерно распределенными
на 0..n-1.
11.2.3. Пусть t[1]..t[u] - произвольная последовательность
различных элементов множества T. Рассмотрим количество действий,
происходящих при помещении элементов t[1]..t[u] в множество, хешируемое
с помощью функции h из универсального семейства H. Доказать,
что среднее количество действий (усреднение - по всем h
из H) не превосходит C*u*(1+u/n).
Решение. Обозначим через m[i] количество элементов последовательности,
для которых хеш-функция равна i. (Числа
m[0]..m[n-1] зависят, конечно, от выбора хеш-функции.) Количество
действий, которое мы хотим оценить, с точностью до постоянного
множителя равно сумме квадратов чисел m[0]..m[n-1]. (Если
k чисел попадают в одну хеш-ячейку, то для этого требуется примерно
1+2+...+k действий.) Эту же сумму квадратов можно записать
как число пар "p,q", для которых h[t[p]]=h[t[q]]. Последнее равенство,
если его рассматривать как событие при фиксированных p
и q, имеет вероятность 1/n при p""q, поэтому среднее значение
соответствующего члена суммы равно 1/n, а для всей суммы получаем
оценку порядка u*u/n, а точнее u*u/n + u, если учесть члены с
p=q.
Оценка этой задачи показывает, что в на каждый добавляемый
элемент приходится в среднем C*(1+u/n) операций. В этой оценке
дробь u/n имеет смысл "коэффициента заполнения" хеш-таблицы.
11.2.4. Доказать аналогичное утверждение для произвольной
последовательности операций добавления, поиска и удаления (а не
только для добавления, как в предыдущей задаче).
Указание. Будем представлять себе, что в ходе поиска, добавления
и удаления элемент проталкивается по списку своих коллег
с тем же хеш-значением, пока не найдет своего двойника или
не дойдет до конца списка. Будем называть i-j-столкновением
столкновение t[i] с t[j]. Общее число действий примерно равно
числу всех столкновений плюс число элементов. При t[i]""t[j] вероятность
i-j-столкновения равна 1/n. Осталось проследить за
столкновениями между равными элементами. Фиксируем некоторое
значение x из множества T и посмотрим на связанные с ним операции.
Они идут по циклу: добавление - проверки - удаление - добавление
- проверки - удаление - ... Столкновения между ними
происходят между добавляемым элементом и следующими за ним проверками
(до удаления включительно), поэтому общее их число не
превосходит числа элементов, равных x.
Теперь приведем примеры универсальных семейств. Очевидно,
для любых конечных множеств A и B семейство всех функций, отображающих
A в B, является универсальным. Однако этот пример с
практической точки зрения бесполезен: для запоминания случайной
функции из этого семейства нужен массив, число элементов в котором
равно числу элементов в множестве A. (А если мы можем себе
позволить такой массив, то никакого хеширования нам не требуется!)
Более практичные примеры универсальных семейств могут быть
построены с помощью несложных алгебраических конструкций. Через
Z[p] мы обозначаем множество вычетов по простому модулю p, т.е.
{0,1,...,p-1}; арифметические операции в этом множестве выполняются
по модулю p. Универсальное семейство образуют все линейные
функционалы на Z[p] в степени n со значениями в Z[p]. Более подробно,
пусть a[1],...,a[n] - произвольные элементы Z[p];
рассмотрим отображение
h: "x[1]...x[n]" |-" a[1]x{1]+...+a{n]z[n]
Мы получаем семейство из (p в степени n) отображений, параметризованное
наборами a[1]...a[n].
11.2.5. Доказать, что это семейство является универсальным.
Указание. Пусть x и y - различные точки пространства Z[p] в
степени n. Какова вероятность того, что случайный функционал
принимает на них одинаковые значения? Другими словами, какова
вероятность того, что он равен нулю на их разности x-y? Ответ
дается таким утверждением: пусть u - ненулевой вектор; тогда все
значения случайного функционала на нем равновероятны.
В следующей задаче множество B={0,1} рассматривается как
м
...Закладка в соц.сетях
