ইনফিমার সাথে আংশিক অর্ডার দেওয়া অগ্রাধিকারগুলির জন্য অগ্রাধিকারের সারি

16

আমার কাছে অগ্রাধিকার সহ কিছু বস্তু রয়েছে যা যৌগিক ধরণের এবং কেবলমাত্র আংশিক অর্ডারযুক্ত । আমার এই অগ্রাধিকারের ক্রম অনুসারে অবজেক্টগুলি নির্বাচন করতে হবে (অর্থাত্ প্রতিবার ন্যূনতম আইটেমটি উত্পাদন করুন)। তবে ইচ্ছামতভাবে অর্ডারটি সম্পন্ন করার পরিবর্তে, আমি এই পছন্দটি পছন্দ করব যদি সারিটি এমন এক অর্থে স্থিতিশীল হয় যে যদি একাধিক ন্যূনতম উপাদান থাকে তবে এটি প্রথমে প্রাচীনতমটি ফিরিয়ে দেওয়া উচিত।

আংশিক ক্রম নিয়ে কাজ করবে এমন কোনও হিপ ডেটা কাঠামো আছে কি? বা এটির সাথে কাজ করার জন্য নিয়মিত অগ্রাধিকার সারির একটি পরিবর্তন? আমার প্রয়োজন অ্যালগরিদমের জন্য সাধারণ পছন্দ হ'ল সহজ বাইনারি বা 4-অ্যারি হিপ, তবে এটি আংশিক ক্রম দিয়ে কাজ করে না।

অগ্রাধিকার সমর্থন করে:

আংশিক ক্রম অপারেশন ব্যবহার $\preccurlyeq$ । এটা আংশিক ক্রম তাই এটা সম্ভব যে $a \preccurlyeq b$ মিথ্যা এবং $b \preccurlyeq a$ এছাড়াও মিথ্যা। আমি লিখি $a \not\lesseqgtr b$ যে ক্ষেত্রে।
$\inf(x_i)$ $y$ $y \preccurlyeq x_i$ $n$ $O(n)$
আংশিক অর্ডার করার জন্য একটি রৈখিক বর্ধন সংজ্ঞায়িত করা যেতে পারে। অগ্রাধিকার সারির জন্য এটি ব্যবহার করা সহজ উপায় যেমন অ্যালগরিদম সেভাবে কাজ করে। তবে আদেশটি কার্য সম্পাদনকে প্রভাবিত করে এবং সন্নিবেশয়ের ক্রমটি দেখে মনে হচ্ছে এটি সবচেয়ে খারাপ পরিস্থিতি এড়ানো সবচেয়ে ভাল be

অতিরিক্তভাবে আমি যে অ্যালগরিদমটি এটি ব্যবহার করতে চাই সেগুলি সারিতে থাকা সমস্ত অগ্রাধিকারের সর্বাধিক জানতে হবে।

অগ্রাধিকারগুলির কিছু বাস্তব-জগতের অর্থ রয়েছে তবে এটি পরিবর্তনের সাপেক্ষে, তাই তাদের থাকতে পারে এমন অন্যান্য সম্পত্তিগুলির উপর নির্ভর করা কার্যকর হবে বলে মনে হয় না।

দ্রষ্টব্য: বাইনারি হ্যাপগুলি আংশিক ক্রম দিয়ে কাজ করে না। , এবং দিয়ে বাইনারি হিপ ধরে নিন , যেখানে এবং এবং । তারা সেই ক্রমে অবস্থিত, তাই $a$ $b$ $c$ $a \preccurlyeq c$ $a \not\lesseqgtr b$ $a \not\lesseqgtr c$

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

এখন ডি isোকানো হয়। পরবর্তী বিনামূল্যে অবস্থান 3, বাম সন্তান $b$ , তাই আমরা পাই child

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

যদি (যা বোঝায় তবে এবং সম্পর্কে কিছু না বলে ) এবং , তবে সাথে অদলবদল করে না , কারণ এটি কম নয়। কিন্তু এটি আসলে কম , কিন্তু তা সঙ্গে তুলনা না, তাই এখন প্রধান গাদা পরিবর্তিত না রাখা; শীর্ষটি ন্যূনতম নয়। $d \preccurlyeq a$ $d \preccurlyeq c$ $d$ $b$ $d \not\lesseqgtr b$ $d$ $b$ $a$

আমি সন্দেহ করি যে দ্বি-স্তরের স্তূপে কিছুটা স্তরের স্তূপ কাজ করতে পারে work মূলত সর্বদা মূলের সাথে নতুন মানগুলির তুলনা করা এবং তুলনীয় উপাদানগুলির সাথে কেবল লিঙ্ক করা গুরুত্বপূর্ণ important এটি বনের গাছগুলিকে এলোমেলো আকারের করে তুলবে এবং এইভাবে গর্তের মধ্যে পারস্পরিক অতুলনীয় সেটগুলির সংখ্যার উপর জটিলতা নির্ভর করবে। আমি কিছুটা সন্দেহ করি যে জটিলতা ঠিক করা যায় না (আমরা তুলনামূলক উপাদানটিকে আঘাত না করা পর্যন্ত আমাদের তুলনা চালিয়ে যেতে হবে) আমি কিছু মিস করেছি, তাই আমি এই উন্মুক্ত রেখে যাচ্ছি।

দ্রষ্টব্য: অর্ডারিং আংশিক এবং এর জন্য লিনিয়ার এক্সটেনশানগুলি সংজ্ঞায়িত করার উপায় রয়েছে, টাইমস্ট্যাম্প যুক্ত করা এবং এটি মাধ্যমিক মানদণ্ড হিসাবে ব্যবহার করা এর মধ্যে একটি নয় । ধরা যাক আমরা প্রতিটি জন্য টাইমস্ট্যাম্প বরাদ্দ করেছি এবং ক্রম কে iff বা ( এবং হিসাবে সংজ্ঞায়িত করেছি । তারপর ধরুন আমরা স্বতন্ত্র আছে , , , যেমন যে এবং । তারপর এবং $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$

সম্পাদনা: আমি বুঝতে পেরেছি যে সংজ্ঞায়িত যে কোনও সেটই সর্বাধিক নয়, তবে বর্তমানে কাতারে কার্যকরভাবে দক্ষতার সাথে সর্বাধিক উপাদান পেতে আমার সক্ষম হওয়া দরকার। সুতরাং আমি এখন বিবেচনা করছি যে কিছু সাধারণ গাদা কাঠামোতে সাবট্রিজের ইনফিমাযুক্ত বিশেষ নোড যুক্ত করা সাহায্য করবে কিনা।

data-structures priority-queues

— জান হুডেক
সূত্র

আপনি কি একটি সূচিযুক্ত অগ্রাধিকার সারি বিবেচনা করেছেন?

@ হুল্কমিস্টার: আপনি কি দয়া করে ব্যাখ্যা করতে পারেন যে কীভাবে সূচিযুক্ত সারিটি আংশিক ক্রম দিয়ে কাজ করে (না, সরল বাইনারি হিপ আংশিক ক্রম দিয়ে কাজ করে না)?

1

আমার ধারণা ছিল যখন দুটি আইটেম অতুলনীয় হয়, আপনি প্রবেশের ক্রমটি সন্ধান করতে সূচকটি ব্যবহার করতে পারেন। সুতরাং সূচকের সাথে অগ্রাধিকারটি রচনা করুন, এবং আপনার কাছে অনন্য কী রয়েছে যা অগ্রাধিকার না থাকলেও তুলনীয়। আপনি যদি যা চান তা যদি মনে হয় তবে আমি এটি একটি সম্পূর্ণ উত্তরে রাখতে পারি।

1

@ হুল্কমিস্টার: ঠিক আছে, সমস্যাটি তার থেকে অনেক গভীর। যখন কোনও নতুন আইটেম সন্নিবেশ করা হয়, তখন অগ্রাধিকারের সারিটি সাধারণত কোনও উপাদান দিয়ে তুলনা করে। তবে যদি তারা তুলনাহীন হয় তবে এটি কোথায় সন্নিবেশ করা উচিত তা সহজেই জানে না। এবং সূচকের সাথে দ্ব্যর্থহীনতা কাজ করবে না, কারণ সূচী পরিবর্তন হয় এবং কারণ সম্ভবত এটি অগ্রাধিকারের সাথে সামঞ্জস্য রেখে মোট অর্ডারিং দেয় না।

আপনি কি এই যৌগিক ধরণের কিছু উদাহরণ দিতে পারেন, এবং যখন এটি অনুপম হয়? এই 'অতুলনীয়' মানগুলি কি সমান বিবেচনা করা সম্ভব? যদি তা হয় তবে সন্নিবেশের জন্য আপনি সেগুলি একই নোডে রাখতে পারেন।

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

What's wrong with making your partial ordering complete?

But rather than arbitrarily completing the order, I would prefer if the queue was stable in a sense that if there is more than one minimal element, it should return the oldest first.

If you prefer 'oldest first', then your order is effectively complete; 'incomparable' items are comparable by age.

Add a timestamp (or any other monotonously growing integer) to each item and use it if 'real' comparison is impossible.

3

That would be great if it could be made a linear extension of the partial ordering. But it isn't. Let's have 3 distinct values, inserted in order a, b, c, such that c ≤ a and b is incomparable with either. The extension with timestamp fills in a ≤' b and b ≤' c, so from transitivity now a should be less than c, but that contradicts the actual ordering.

Perhaps you confused it with weak ordering. In weak ordering the incomparable elements form equivalence classes, so you can add arbitrary additional criteria. For partial ordering you can't.

1

EDIT: this seems to be an interesting problem, and I had a little research about it. I suggest you read the following:

Darell Raymond. Partial order databases, PhD Thesis, University of Waterloo.

I suggest you read this paper: Daskalakis, Constantinos, et al. "Sorting and selection in posets." SIAM Journal on Computing 40.3 (2011): 597-622.

The authors presents here a data structure called ChainMerge that accepts a poset and a chain decomposition of the poset into $q$ chains. The size of the data structure is $O(n q)$ . The authors presents an algorithm for finding the minimas that runs in $O(w n)$ where $w$ is an upper bound on the width of the poset. .. I thought maybe this is interesting.

Note: I deleted a previous naive answer. Please click on edit to see it.

— AJed
সূত্র

0

My use of terminology may be incorrect. Please edit my answer directly to fix any problems you find.

First, mutually incomparable sets need to be detected from the inputs.

For example, there may be 5 objects, a, b, c, d, e, but their partial ordering form two disconnected graphs:

a ≤ b ≤ c
d ≤ e
but any of {a, b, c} is incomparable with any of {d, e}.

These mutually incomparable sets need to be detected first, before the objects can be stored into an appropriate data structure. This can be done with a Union find algorithm

For efficiency, the insertion of a new object needs to have an efficient way of finding "the list of existing objects which are comparable with this new object".

Now, within each subset (respectively {a, b, c} and {d, e}), the minima should be well-defined. (For each subset there can be one or more minima, due to partial ordering.)

I see this as a directed acyclic graph. Trying to fit it into a heap seems disastrous.

To extract the minima from this composite data structure, the next step is to get the list of all minima from all subsets, pick the one with the earliest timestamp, and remove and return this object.

— rwong
সূত্র

Unfortunately I don't see way to efficiently find the list of comparable objects.

Partially ordered set can indeed be viewed as directed acyclic graph. But one given by adjacency table (function, actually) rather than adjacency list. Finding minima of poset given by adjacency list is easy, but for adjacency table it's a problem.

Minima are well-defined in the original set as well. I don't see how finding the connected components could help, since they are not complete graphs.

1

You seem to assume that the Hasse diagram is a forest of unary trees (equivalently path graphs), but the question already states that it's a product order, so a multi-dimensional lattice.

— Peter Taylor

0

A project I'm working on involves a similar problem (incidentally I'm also using the partial order of vectors). We already had a quadratic time algorithm for sorting a randomly ordered list, and I developed an insertion algorithm by observing its behaviour when only one object was out of order. We don't know whether or not this is the fastest possible implementation.

Here is some pseudocode.

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)

— Jeremy List
সূত্র

-1

Usual heap behaviour is to append the new value to the back, and then sift up while it compares greater than its parent.

If you write a comparison which returns the same for the parent and child are not comparable case as for parent is greater than child, sift up should still terminate at the right point.

Does that count as a sufficiently stable ordering for your purposes?

To clarify, take the example from your comment: a > b, and c is not comparable to a or b:

a then b then c => a, b, c ... this is in heap order already, and nothing ever moves in sift-up
b, a, c => a, b, c ... a is sifted up to its correct place, and again we're in correct heap order
a, c, b => a, c, b ... b can't sift up because it is not comparable with c, but this leaves them in FIFO order as you asked
c, b, a => c, a, b ... a and b are in the correct relative order, but neither can get ahead of c because they can't be compared with it

so, the result depends on the order of insertion - this seems to match what you ask for, but I'm not sure whether it's really what you want. If it isn't, could you show the result you hoped to see?

OK, so from your comment (and the edit to your question), you do want "comparable" elements to leapfrog "non-comparable" ones and find the correct place under the ordering, if there is one. I asked about this because I wasn't sure how to interpret

if some elements are incomparable, it returns them in the order they were inserted

(d and b are pairwise incomparable in your edit, but you don't want them in the order they were inserted).

My next question would have been about the relationship between the "comparable" and "non-comparable" elements, but I see you've revealed now that they're vectors in product order (it wasn't clear whether some elements were pairwise-incomparable with everything, like NaN, or what).

So, if I take your new example and assign vector values, is it correct that this is an example where b is not comparable to anything else:

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

and it should sort to this:

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

?

— Useless
সূত্র

I explicitly mentioned in the question that it won't work, because I thought I have a counter-example, but I am not so sure with it now. Can you prove that such queue would be sound (for deletemin, insert and update too)? And remember, that it's possible that a ≤ b, but c is not comparable (and would therefore compare "equal" with the above rule) to either of them.

Well, that's not proof yet. Don't care for the order yet and proof that such heap always has minimal element at the top (note: (more) common convention and the actual need of the algorithm is minimal at the top, so if a > b, b comes first).

Actually I suspect there is counter-example. Suppose a, b and c are in the heap, a ≤ b and a ≤ c, a is top, b is left child, c is right child. Now d comes that d ≤ c and incomparable with a and b. It is inserted as child of b, is not less and stays there. Now comes e that is c ≤ e (thus also a ≤ e) and incomparable to b. So e goes in as right child of b and stays. Now extract a (OK, a is minimal), e gets swapped in it's place and sifted down. It is incomparable to b, but less than c, so swaps with c. Now extract c, WRONG, d ≤ c.

If you find a mistake in the previous comment (which would need to have a form of inequality that has to hold because of transitivity and I missed it), you'd still have a chance. Otherwise it won't work.

1

Ok, even simpler counter-example. Suppose a, b and c are in the heap, a ≤ c, b is incomparable with either. a is top, b is left child, c is right child. d comes in so that d ≤ a (thus d ≤ c) and incomparable with b. Next free slot is as left child of b and d is incomparable, so it stays there. Now extract a, WRONG, d ≤ a. Note that whether a ≤ c or not does not matter, the situation is the same if they were incomparable.