Il modo più veloce per trovare un prodotto minimo di 2 elementi dell'array contenenti oltre 200000 elementi

Ho un array a[n]. Il numero nè stato inserito da noi. Devo trovare il prodotto minimo di a[i]e a[j]se:

1) abs(i - j) > k

2) a[i] * a[j]è ridotto a icona

Ecco la mia soluzione (molto ingenua):

#include <iostream>
using namespace std;
#define ll long long
int main() {
    ll n,k; cin >> n >> k;

    ll a[n]; for(ll i=0;i<n;i++) cin >> a[i];

    ll mn; bool first = true;

    for(ll i=0;i<n;i++) {
        for(ll j=0;j<n;j++) {
            if(i!=j)
            if(abs(i-j) > k) {
                if(first) {
                    mn = a[i]*a[j];
                    first = false;
                } else if(a[i]*a[j] < mn) mn = a[i]*a[j];
            }
        }
    }
    cout << mn << endl;
}

Ma voglio sapere se esiste un modo più veloce per trovare un prodotto minimo a distanza?

Supponendo che vi sia almeno una coppia di elementi che soddisfi le condizioni e che non vi sia una moltiplicazione di due elementi in esso trabocca, ciò può essere fatto nel Theta(n-k)tempo e Theta(1)nello spazio peggiori e nel migliore dei casi, con qualcosa del genere:

auto back_max = a[0];
auto back_min = a[0];
auto best = a[0]*a[k+1];

for(std::size_t i=1; i<n-(k+1); ++i) {
    back_max = std::max(back_max, a[i]);
    back_min = std::min(back_min, a[i]);
    best = std::min(best, std::min(a[i+k+1]*back_max, a[i+k+1]*back_min));
}

return best;

Questo è ottimale in termini di complessità asintotica nel caso peggiore sia per il tempo che per lo spazio perché il prodotto ottimale può essere almeno a[0]con uno qualsiasi degli n-(k+1)elementi in lontananza k+1, quindi almeno gli n-(k+1)interi devono essere letti da qualsiasi algoritmo che risolva il problema.

L'idea alla base dell'algoritmo è la seguente:

Il prodotto ottimale utilizza due elementi di a, supponiamo che siano a[r]e a[s]. Senza perdita di generalità possiamo supporre che s > rdal momento che il prodotto è commutativo.

A causa delle restrizioni abs(s-r) > kquesto implica che s >= k+1. Ora, sciascuno degli indici potrebbe soddisfare questa condizione, quindi ripetiamo questi indici. Questa è l'iterazione inel codice mostrato, ma viene spostata k+1per comodità (non importa davvero). Per ogni iterazione dobbiamo trovare il prodotto ottimale che coinvolge i+k+1come indice più grande e confrontarlo con la migliore ipotesi precedente.

I possibili indici da abbinare i+k+1sono tutti gli indici più piccoli o uguali a icausa della distanza richiesta. Dovremmo iterare anche su tutti questi, ma ciò non è necessario perché il minimo di a[i+k+1]*a[j]over ja fixed iè uguale a min(a[i+k+1]*max(a[j]), a[i+k+1]*min(a[j]))causa della monotonicità del prodotto (prendendo il minimo rispetto a entrambi i a[j]conti di minimo e massimo per i due possibili segni a[i+k+1]o equivalenti delle due possibili direzioni della monotonicità.)

Poiché l'insieme di a[j]valori su cui ottimizziamo qui è giusto {a[0], ..., a[i]}, che semplicemente aumenta di un elemento ( a[i]) in ogni iterazione di i, possiamo semplicemente tenere traccia di max(a[j])e min(a[j])con singole variabili aggiornandole se a[i]è maggiore o minore dei precedenti valori ottimali. Questo viene fatto con back_maxe back_minnell'esempio di codice.

Il primo passaggio dell'iterazione ( i=0) viene ignorato nel ciclo e invece eseguito come inizializzazione delle variabili.

Non sono sicuro del più veloce .

Per il problema più semplice senza i <j - k , il prodotto minimo è tra i prodotti di coppie dei due elementi più piccoli e più grandi.

Quindi, (quanto segue è troppo complicato, vedi la risposta di noce )
(• balk se k ≤ n
  • inizializza minProdotto in uno [0] * a [k + 1])

• mantenere fino a due strutture dati minmax dinamiche e oltre IplusK a
  partire da {} e {a [ j ] | k ≤ j }
• per ogni i da 0 a n - k - 1
  • aggiungi un [ i ] a upToI
  • rimuovi un [ i + k ] da beyondIplusK
  • verifica la presenza di un nuovo prodotto minimo tra
    min ( upToI ) × min ( beyondIplusK ), min ( upToI ) × max ( beyondIplusK ),
    max ( upToI ) × min ( beyondIplusK ) e max ( upToI ) × max ( beyondIplusK )

Per "magnitudo minima"

Trova i 2 elementi di "grandezza minima", quindi (dopo aver trovato due zeri o aver cercato l'intero array), moltiplicali.

Per "valore più basso" senza il abs(i - j) > k parte

Vi sono 3 possibilità:

• i due numeri negativi più alti (di minima grandezza)

• i due numeri non negativi (magnitudo minima) più bassi

• il numero negativo più basso (magnitudine maggiore) e il numero non negativo più grande (magnitudine maggiore)

Puoi cercare tutti e 6 i valori e capire i prodotti e quale è il migliore alla fine.

Però; appena vedi uno zero sai di non aver bisogno di sapere di più sulle prime 2 possibilità; e appena vedi un numero negativo e un numero non negativo, sai che ti importa solo della terza possibilità.

Questo porta a una macchina a stati finiti con 3 stati: "preoccuparsi di tutte e 3 le possibilità", "la risposta è zero a meno che non si veda un numero negativo" e "preoccuparsi solo dell'ultima possibilità". Questo può essere implementato come un insieme di 3 loop, in cui 2 dei loop saltano in ( goto) al centro di un altro loop quando lo stato (della macchina a stati finiti) cambia.

In particolare, potrebbe apparire qualcosa di vagamente simile (non testato):

   // It could be any possibility

   for(ll i=0;i<n;i++) {
       if(a[i] >= 0) {
            if(a[i] < lowestNonNegative1) {
                lowestNonNegative2 = lowestNonNegative1;
                lowestNonNegative1 = a[i];
            }
            if(lowestNonNegative2 == 0) {
                goto state2;
            }
       } else {
            if(a[i] > highestNegative1) {
                highestNegative2 = highestNegative1;
                highestNegative1= a[i];
            }
            if(lowestNonNegative1 < LONG_MAX) {
                goto state3;
            }
       }
   }
   if(lowestNonNegative2 * lowestNonNegative1 < highestNegative2 * highestNegative1) {
       cout << lowestNonNegative2 * lowestNonNegative1;
   } else {
       cout << highestNegative2 * highestNegative1;
   }
   return;

   // It will be zero, or a negative and a non-negative

   for(ll i=0;i<n;i++) {
state2:
       if(a[i] < 0) {
           goto state3;
       }
   }
   cout << "0";
   return;

   // It will be a negative and a non-negative

   for(ll i=0;i<n;i++) {
state3:
       if(a[i] < lowestNegative) {
           lowestNegative = a[i];
       } else if(a[i] > highestNonNegative) {
           highestNonNegative = a[i];
       }
    }
    cout << lowestNegative * highestNonNegative;
    return;

Per "valore più basso" con la abs(i - j) > kparte

In questo caso hai ancora le 3 possibilità; e potrebbe farlo funzionare con lo stesso approccio "3 loop con macchina a stati finiti" ma diventa troppo disordinato / brutto. In questo caso è probabile che un'alternativa migliore esegua la scansione preliminare dell'array per determinare se vi sono zeri e se sono tutti negativi o tutti positivi; in modo che dopo la pre-scansione sia possibile sapere che la risposta è zero o selezionare un loop progettato solo per la specifica possibilità.