Очередь приоритетов для частично упорядоченных приоритетов с информацией

16

У меня есть несколько объектов с приоритетом, который является составным типом и только частично упорядочен . Мне нужно выбрать объекты в порядке приоритета (т.е. каждый раз приносить минимальный предмет). Но вместо того, чтобы произвольно завершать порядок, я бы предпочел, чтобы очередь была стабильной в том смысле, что если имеется более одного минимального элемента, она должна возвращать самый старый в первую очередь.

Есть ли какая-либо структура данных кучи, которая будет работать с частичным упорядочением? Или модификация обычной очереди приоритетов для работы с ней? Обычный выбор для нужного мне алгоритма - простая двоичная или 4-х разрядная куча, но это не работает с частичным упорядочением.

Поддержка значений приоритета:

$\preccurlyeq$ $a \preccurlyeq b$ $b \preccurlyeq a$ $a \not\lesseqgtr b$
Поиск Infima (GLB) и супремумы (LuB). $\inf(x_i)$ - максимальный $y$ такой, что $y \preccurlyeq x_i$ . Вычисление инфимума из $n$ значений занимает время $O(n)$ . Infimum (и supremum) каждого множества существует.
Можно определить линейное расширение для частичного упорядочения. Использование его для очереди приоритетов - самый простой выход, поскольку алгоритм работает именно так. Но порядок влияет на производительность, и порядок вставки выглядит так, как будто лучше избегать наихудших случаев.

Кроме того, алгоритм, в котором я хочу использовать это, должен знать минимум всех приоритетов в очереди.

Приоритеты имеют некоторое реальное значение, но могут быть изменены, поэтому не представляется возможным полагаться на другие свойства, которые они могут иметь.

Примечание: двоичные кучи не работают с частичным упорядочением. Предположим, двоичная куча с $a$ , $b$ и $c$ , где $a \preccurlyeq c$ и $a \not\lesseqgtr b$ и $a \not\lesseqgtr c$ . Они расположены в таком порядке, поэтому

     a (0)
   /   \
 b (1)   c (2)

теперь d вставлен. Следующая свободная позиция - 3, левый потомок $b$ , поэтому мы получаем

        a (0)
      /   \
    b (1)   c (2)
  /
d (3)

Если (что подразумевает из транзитивности, но ничего не говорит о и ) и , то не местами с , потому что оно не меньше. Но на самом деле оно меньше, чем , но не сравнивается с ним, поэтому теперь основной инвариант кучи не выполняется; верх не минимален. $d \preccurlyeq a$ $d \preccurlyeq c$ $d$ $b$ $d \not\lesseqgtr b$ $d$ $b$ $a$

Я подозреваю, что лес куч, в стиле биномиальной кучи, может работать. По сути, важно всегда сравнивать новые значения с корнем и связывать только сопоставимые элементы. Это сделало бы деревья в лесу случайным размером и, таким образом, сделало сложность зависимой от количества взаимно несопоставимых множеств в куче. Я несколько подозреваю, что сложность не может быть исправлена (мы должны продолжать сравнивать, пока не найдем сопоставимый элемент), возможно, я что-то упустил, поэтому я оставляю это открытым.

Примечание. Порядок является частичным, и, хотя существуют способы определения линейных расширений для него, добавление временной метки и использование ее в качестве вторичного критерия не является одним из них. Предположим, что мы присвоили метку времени для каждого и определили порядок как если или ( и . Тогда предположим, что у нас есть различные , , , такие что и . Тогда и $t(a)$ $a$ $\preccurlyeq'$ $a \preccurlyeq' b$ $a \preccurlyeq b$ $b \not\preccurlyeq a$ $t(a) \le t(b)$ $a$ $b$ $c$ $t(a) \le t(b) \le t(c)$ $c \le a$ $a \preccurlyeq' b$ $b \preccurlyeq' c$ , но , поэтому отношение не транзитивно и, следовательно, не является порядком. Этот вид расширения работает только для слабых упорядочений, но не для частичных. $c \preccurlyeq' a$

Изменить: я понял, что не только является infimum любого определенного набора, но я на самом деле должен быть в состоянии эффективно получить infimum элементов в очереди. Итак, я сейчас размышляю, поможет ли добавление специальных узлов, содержащих инфу поддеревьев, в какую-то общую структуру кучи.

data-structures priority-queues

— Ян Худек
источник

Рассматривали ли вы индексированную приоритетную очередь?

@hulkmeister: Не могли бы вы объяснить, как индексированная очередь позволяет работать с частичным упорядочением (нет, обычная двоичная куча не работает с частичным упорядочением)?

1

Я думал, что когда два элемента несопоставимы, вы можете использовать индекс для отслеживания порядка вставки. Так что составьте приоритет с индексом, и у вас есть уникальные ключи, которые сопоставимы, даже если приоритет не равен. Если это звучит как то, что вы хотите, я могу дать полный ответ.

1

@hulkmeister: Ну, проблема гораздо глубже. Когда новый элемент вставлен, приоритетная очередь обычно сравнивает его с некоторым элементом. Но если они несравнимы, он просто не знает, куда его вставить. И устранение неоднозначности с индексом не сработает, потому что индекс меняется и потому, что он, вероятно, не даст общего порядка в соответствии с приоритетом в любом случае.

Можете ли вы привести пример этого составного типа, и когда он несравненный? Можно ли считать эти «несопоставимые» значения равными? Если это так, вы можете хранить их в том же узле в порядке вставки.

3

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

По сути, идея состоит в том, чтобы найти топологическое упорядочение частично упорядоченного множества. То есть общий порядок « » такой, что $\le_T$ . Для векторов, использующих заказ продукта, это довольно просто: просто используйте лексикографический порядок « », где первый «компонент» представляет собой сумму всех компонентов, используемых для заказа продукта (остальные компоненты по существу произвольны, так что вы также можете придерживаться слабого порядка). Затем мы можем видеть, что $\mathbf{a}\le\mathbf{b}\implies \mathbf{a}\le_T\mathbf{b}$ $\le_S$ и

a < b ⟹ \forall_{i} (a_{i} \leq b_{i}) and \exists_{i} (a_{i} < b_{i}) ⟹ (\sum_{i} a_{i}) < (\sum_{i} b_{i}) ⟹ a \leq_{S} b

$\mathbf{a}<\mathbf{b}\implies \forall_i(a_i\le b_i)\text{ and }\exists_i(a_i<b_i)\implies(\sum_i a_i)<(\sum_i b_i)\implies\mathbf{a}\le_S\mathbf{b}$

и, следовательно,

a = b ⟹ \forall_{i} (a_{i} = b_{i}) ⟹ (\sum_{i} a_{i}) = (\sum_{i} b_{i}) ⟹ a \leq_{S} b,

$\mathbf{a}=\mathbf{b}\implies \forall_i(a_i=b_i)\implies(\sum_i a_i)=(\sum_i b_i)\implies\mathbf{a}\le_S\mathbf{b},$

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

a \leq b ⟹ a \leq_{S} b

$\mathbf{a}\le\mathbf{b}\implies\mathbf{a}\le_S\mathbf{b}$

— Джаспер
источник

Есть еще много вариантов. Используя один из компонентов, минимум, максимум, любую линейную комбинацию с неотрицательными коэффициентами как минимум. Выбор расширения влияет на скорость наложения алгоритма.

— Ян Худек

2

Что не так с выполнением вашего частичного заказа?

Но вместо того, чтобы произвольно завершать порядок, я бы предпочел, чтобы очередь была стабильной в том смысле, что если имеется более одного минимального элемента, она должна возвращать самый старый в первую очередь.

Если вы предпочитаете «сначала самый старый», то ваш заказ фактически выполнен; «несопоставимые» предметы сопоставимы по возрасту.

Добавьте временную метку (или любое другое монотонно растущее целое число) к каждому элементу и используйте ее, если «реальное» сравнение невозможно.

3

Было бы здорово, если бы можно было сделать линейное продолжение частичного упорядочения. Но это не так. Давайте иметь 3 различных значения, вставленных в порядке a , b , c , так что c ≤ a и b несопоставимы ни с одним из них. Расширение с меткой времени заполняет a ≤ 'b и b ≤' c , поэтому из транзитивности теперь a должно быть меньше c , но это противоречит фактическому упорядочению.

Возможно, вы спутали это со слабым порядком. При слабом упорядочении несопоставимые элементы образуют классы эквивалентности, поэтому вы можете добавлять произвольные дополнительные критерии. Для частичного заказа вы не можете.

1

РЕДАКТИРОВАТЬ: это, кажется, интересная проблема, и у меня было небольшое исследование об этом. Я предлагаю вам прочитать следующее:

Дарелл Рэймонд. Частичные базы данных заказов, кандидатская диссертация, Университет Ватерлоо.

Я предлагаю вам прочитать эту статью: Daskalakis, Constantinos, et al. «Сортировка и отбор в позах». Журнал SIAM по вычислительной технике 40.3 (2011): 597-622.

$q$ $O(n q)$ $O(w n)$ $w$

Примечание: я удалил предыдущий наивный ответ. Пожалуйста, нажмите на правку, чтобы увидеть его.

— AJed
источник

0

Мое использование терминологии может быть неправильным. Пожалуйста, отредактируйте мой ответ напрямую, чтобы исправить любые проблемы, которые вы найдете.

Во-первых, взаимно несопоставимые множества должны быть обнаружены на входах.

Например, может быть 5 объектов a, b, c, d, e, но их частичное упорядочение образует два несвязных графа:

a ≤ b ≤ c
d ≤ e
но любой из {a, b, c}несопоставим с любым из {d, e}.

Эти взаимно несопоставимые наборы должны быть обнаружены в первую очередь, прежде чем объекты могут быть сохранены в соответствующей структуре данных. Это можно сделать с помощью алгоритма поиска Union.

Для эффективности вставка нового объекта должна иметь эффективный способ поиска «списка существующих объектов, которые сопоставимы с этим новым объектом».

Теперь в каждом подмножестве (соответственно {a, b, c}и {d, e}) минимумы должны быть четко определены. (Для каждого подмножества может быть один или несколько минимумов из-за частичного упорядочения.)

Я вижу это как ориентированный ациклический граф . Попытка поместить это в кучу кажется катастрофической.

Чтобы извлечь минимумы из этой составной структуры данных, следующим шагом будет получение списка всех минимумов из всех подмножеств, выбор одного из них с самой ранней отметкой времени, удаление и возврат этого объекта.

— rwong
источник

К сожалению, я не вижу способа эффективно найти список сопоставимых объектов.

Частично упорядоченное множество действительно можно рассматривать как ориентированный ациклический граф. Но один определяется таблицей смежности (на самом деле, функцией), а не списком смежности. Найти минимумы poset, заданные списком смежности, легко, но для таблицы смежности это проблема.

Минимумы четко определены и в оригинальном наборе. Я не понимаю, как может помочь поиск подключенных компонентов, поскольку они не являются полными графиками.

1

Похоже, вы предполагаете, что диаграмма Хассе - это лес унарных деревьев (эквивалентно графов путей), но вопрос уже гласит, что это порядок продуктов, поэтому многомерная решетка.

— Питер Тейлор

0

Проект, над которым я работаю, связан с аналогичной проблемой (кстати, я также использую частичный порядок векторов). У нас уже был алгоритм квадратичного времени для сортировки случайно упорядоченного списка, и я разработал алгоритм вставки, наблюдая за его поведением, когда только один объект вышел из строя. Мы не знаем, является ли это самой быстрой реализацией.

Вот какой-то псевдокод.

class PartialOrderPriorityQueue
   q <- empty list
   method insert (n):
     for i <- 0 to (q.length - 1):
       if q[i] <= n:
         t <- q[i]
         q[i] <- n
         n <- t
     q.append(n)

   method pop():
     return q.remove(0)

— Джереми Лист
источник

-1

Обычное поведение кучи - добавить новое значение в конец, а затем просеять его, пока оно сравнивается больше, чем его родитель.

Если вы пишете сравнение, которое возвращает то же самое для родителя и ребенка, несопоставимые случаи, так как для родителя больше, чем ребенок элемента, процесс sift up должен завершиться в нужной точке.

Это считается достаточно стабильным заказом для ваших целей?

Для пояснения возьмем пример из вашего комментария: a> b , а c не сопоставим с a или b :

а потом б то с => а, б, в ... это уже в порядке кучи, и ничто никогда не перемещается в ускоренном режиме
б, а, в => а, б, в ... a просеян на правильное место, и снова мы находимся в правильном порядке кучи
a, c, b => a, c, b ... b не может просеять, потому что это несопоставимо с c, но это оставляет их в порядке FIFO, как вы и просили
c, b, a => c, a, b ... a и b находятся в правильном относительном порядке, но ни один из них не может опередить c, поскольку их нельзя сравнивать с ним

итак, результат зависит от порядка вставки - кажется, это соответствует тому, что вы просите, но я не уверен, действительно ли это то, что вы хотите. Если это не так, не могли бы вы показать результат, который вы надеялись увидеть?

Итак, из вашего комментария (и правки к вашему вопросу) вы хотите, чтобы «сопоставимые» элементы перепрыгнули «несопоставимые» и нашли правильное место под порядком, если он есть. Я спросил об этом, потому что я не был уверен, как интерпретировать

если некоторые элементы несопоставимы, он возвращает их в том порядке, в котором они были вставлены

(d и b попарно несопоставимы в вашем редактировании, но вы не хотите, чтобы они были в том порядке, в котором они были вставлены).

Мой следующий вопрос был бы о связи между «сопоставимыми» и «несопоставимыми» элементами, но я вижу, что вы обнаружили, что теперь они являются векторами в порядке продуктов (не было ясно, были ли некоторые элементы попарно- несравненный со всем , как NaN, или что).

Итак, если я возьму ваш новый пример и назначу векторные значения, верно ли, что это пример, где b несопоставимо с чем-либо еще:

        a (1,1)
      /      \
    b (0,4)   c (3,3)
  /
d (2,2)

и это должно сортировать к этому:

        a (1,1)
      /      \
    d (2,2)   c (3,3)
  /
b (0,4)

?

— Бесполезный
источник

Я прямо упомянул в вопросе, что это не сработает, потому что я думал, что у меня есть контрпример, но сейчас я не уверен в этом. Можете ли вы доказать, что такая очередь будет исправной (для deletemin, вставьте и обновите тоже)? И помните, что вполне возможно, что a ≤ b , но с не сравнимо (и поэтому будет сравнивать «равно» с вышеупомянутым правилом) ни с одним из них.

Ну, это еще не доказательство. Пока не обращайте внимания на порядок и доказательство того, что такая куча всегда имеет минимальный элемент в верхней части (примечание: (более) общее соглашение и фактическая потребность в алгоритме минимальна в верхней части, поэтому, если a> b , b стоит первым ).

На самом деле я подозреваю, что есть контрпример. Предположим, что a , b и c находятся в куче, a ≤ b и a ≤ c , a - вершина, b - левый потомок, c - правый потомок. Теперь приходит d, что d ≤ c и несопоставимо с a и b . Он вставляется как потомок от b , не меньше и остается там. Теперь прибывает e, которое является c ≤ e (таким образом также a ≤ e ) и несопоставимо с b . Так е идет как правый ребенок би остается. Теперь извлеките a (хорошо, a минимально), e поменяется местами и отфильтровано. Это несопоставимо с b , но меньше, чем c , поэтому меняет местами с c . Теперь извлеките c , НЕПРАВИЛЬНО , d ≤ c,

Если вы обнаружите ошибку в предыдущем комментарии (которая должна иметь форму неравенства, которая должна сохраняться из-за транзитивности, а я ее упустил), у вас все равно будет шанс. Иначе это не сработает.

1

Хорошо, еще более простой контрпример. Предположим, что a , b и c находятся в куче, a ≤ c , b несопоставимо ни с одним из них. a - вершина, b - левый ребенок, c - правый ребенок. d входит так, что d ≤ a (то есть d ≤ c ) и несопоставимо с b . Следующий свободный слот - это левый потомок b, а d несопоставим, поэтому он остается там. Теперь извлечь a , НЕПРАВИЛЬНО , d ≤ a . Обратите внимание, что ли ≤ с или нет не имеет значения, ситуация такая же, если они были несопоставимы.