Il modo più efficiente di conoscere gli ordini

Prendi in considerazione due array 2D $B_{ij}$ (l'array di acquisto) e $S_{ij}$ (l'array di vendita) dove ciascuno $i^{th}$ L'elemento è associato a una matrice di valori in virgola mobile e ciascuno dei valori in virgola mobile, a sua volta, è associato a una matrice di numeri interi.

Per esempio

B = [ 
  0001 => [ 32.5 => {10, 15, 20}, 
            45.2 => {48, 16, 19}, 
            ...,
            k1
          ], 
  0002 => [ 35.6 => {17, 35, 89}, 
            68.7 => {18, 43, 74}, 
            ...,
            k2
          ] 
]

e in modo simile per l'array sell.

Questo è simile a un sistema di associazione ordini di uno scambio di azioni / merci

BuyOrderBook = [
                 CompanyName => [
                                 Price1 => [Qty1, Qty2...],
                                 Price2 => [Qty1, Qty2...]
                                ]
                 SecondCompany = [...]
               ]

Qual è il modo più veloce noto per risolvere il seguente problema:

Input: Acquista array $B$ , Vendi array $S$
Problema: decidere se ci sono $(c_1 \Rightarrow p_1 \Rightarrow q_1) \in B$ e $(c_2 \Rightarrow p_2 \Rightarrow q_2) \in S$ con $q_1, q_2 > 0$ e $p_2 \geq p_1$ .

In breve, qual è il modo più difficile di abbinare gli ordini per uno scambio?

Aggiornamento in risposta ai commenti

Diciamo, MSFT ha 25 azioni @ $ 60 da vendere e c'è un acquirente che è disposto a offrire $ 61 per 10 azioni di MSFT. Quindi l'acquirente ottiene 10 azioni a $ 60 e il book degli ordini di acquisto si svuota mentre il book degli ordini di vendita ora viene aggiornato con una nuova quantità: 15 azioni a $ 60.

Ora prendi il caso contrario, MSFT ha 25 azioni da $ 60 da acquistare e c'è un venditore che è disposto a ricevere $ 61 per 10 azioni di MSFT. Quindi lo scambio non verrà eseguito perché il venditore richiede un minimo di $ 61 e l'acquirente offre un massimo di $ 60. Gli ordini vengono ora archiviati e attendono fino alla ricezione di nuovi ordini.

(Questo è il principio dell'ordine limite , in cui il venditore specifica il prezzo minimo al quale è disposto a vendere e l'acquirente specifica il prezzo massimo al quale è disposto ad acquistare).

Dopo l'esecuzione, il registro ordini di vendita sarà (25-10 )=15@86.5 mentre il portafoglio ordini di acquisto sarà vuoto (10-10) = 0.

algorithms

— check123
fonte

Ho curato pesantemente; si prega di verificare che il significato sia ancora quello desiderato. "Stack" è davvero la parola che vuoi usare qui? Immagino che la struttura dei dati non sia uno stack, quindi è un'espressione di dominio? Per quanto riguarda la domanda, nota che il problema decisionale che affermi e che trovi tutti gli abbinamenti non è necessariamente altrettanto difficile; in particolare, gli abbinamenti possono essere in conflitto.

— Raffaello

@Raphael Ha apportato una piccola modifica alla dichiarazione del problema in merito a

q_{1}, q_{2}

$q_1, q_2$ . La struttura è una pila in quanto i nuovi ordini vengono "inseriti" nel book di negoziazione. Tuttavia, l'associazione tra azienda, prezzo e quantità è importante. Modifica la struttura come richiesto.

— check123

@Raphael 'Le corrispondenze possono essere in conflitto' Un esempio?

— check123

1) Le pile in genere non consentono di accedere ad alcun elemento tranne quello più in alto. Vuoi un accesso casuale, vero? 2) Potrebbero esserci due ordini di acquisto che si adattano entrambi allo stesso ordine di vendita ma non possono essere entrambi soddisfatti.

— Raffaello

@Raphael 1) Oh! Sì, forse Array è una parola migliore 2) Se ci sono conflitti di corrispondenza, questi vengono risolti in base al principio FIFO, l'ordine più vecchio ottiene la preferenza (La maggior parte degli scambi segue questo principio)

— controlla123

Mantieni il tuo libro degli ordini d'acquisto come una serie di aziende. Per ogni azienda, mantenere una priorità dei prezzi (massimo per acquisto e minimo per vendita). Per ogni prezzo, mantieni una coda di ordini.

Per verificare la corrispondenza degli ordini, per ciascuna società, chiamare find-min()e find-max()sull'azienda nell'array di vendita e acquistare l'array per trovare i migliori prezzi di acquisto / vendita. Se max> min, prova a evadere l'ordine. Per evadere l'ordine, togli gli elementi dal tuo acquisto e vendi le code per quella società e il prezzo, fino a quando una delle tue code dei prezzi è vuota. Quando la coda dei prezzi è vuota, eliminare l'elemento corrispondente dalla sua coda prioritaria ed eseguire nuovamente il controllo.

Questa strategia costa tempo costante per ordine e $O(\log p_i)$ per variazione di prezzo, dove $p_i$ è il numero di prezzi per azienda $i$ .

— Joe
fonte