Come risolvere efficacemente l'associazione dei dati

0

Dopo questa domanda , la soluzione per risolvere l'associazione dei dati è quella di utilizzare DFS e Ordinamento topologico . Non sono esattamente sicuro di cosa significhi. Ecco un'animazione che dimostra approssimativamente ciò che sto considerando.

Supponiamo di avere un modello di associazione dati come questo:

            ●
            ↓
● → ● → ● → ●   ● ← ●
        ↑       ↑   ↓
        ● → ● → ● ← ● → ●
        ↓       ↓   ↑
        ●       ● → ● ← ●
                ↓   ↓
                ●   ●
                    ↑
                    ●

E poi cambiamo un campo.

            ●
            ↓
● → ● → ● → ●   ● ← ●
        ↑       ↑   ↓
        ◌ → ● → ● ← ● → ●
        ↓       ↓   ↑
        ●       ● → ● ← ●
                ↓   ↓
                ●   ●
                    ↑
                    ●

Quindi si propaga:

            ●
            ↓
● → ● → ◌ → ●   ● ← ●
        ↑       ↑   ↓
        ○ → ◌ → ● ← ● → ●
        ↓       ↓   ↑
        ◌       ● → ● ← ●
                ↓   ↓
                ●   ●
                    ↑
                    ●

piu '...

            ●
            ↓
● → ● → ○ → ◌   ● ← ●
        ↑       ↑   ↓
        ○ → ○ → ◌ ← ● → ●
        ↓       ↓   ↑
        ○       ● → ● ← ●
                ↓   ↓
                ●   ●
                    ↑
                    ●

...

            ●
            ↓
● → ● → ○ → ○   ◌ ← ●
        ↑       ↑   ↓
        ○ → ○ → ○ ← ● → ●
        ↓       ↓   ↑
        ○       ◌ → ● ← ●
                ↓   ↓
                ●   ●
                    ↑
                    ●

            ●
            ↓
● → ● → ○ → ○   ○ ← ●
        ↑       ↑   ↓
        ○ → ○ → ○ ← ● → ●
        ↓       ↓   ↑
        ○       ○ → ◌ ← ●
                ↓   ↓
                ◌   ●
                    ↑
                    ●

            ●
            ↓
● → ● → ○ → ○   ○ ← ●
        ↑       ↑   ↓
        ○ → ○ → ○ ← ◌ → ●
        ↓       ↓   ↑
        ○       ○ → ○ ← ●
                ↓   ↓
                ○   ◌
                    ↑
                    ●

            ●
            ↓
● → ● → ○ → ○   ○ ← ●
        ↑       ↑   ↓
        ○ → ○ → ○ ← ☀ → ◌
        ↓       ↓   ↑
        ○       ○ → ○ ← ●
                ↓   ↓
                ○   ○
                    ↑
                    ●

A volte incontra un aggiornamento recente, come mostrato con ☀. Ma continua:

            ●
            ↓
● → ● → ○ → ○   ○ ← ●
        ↑       ↑   ↓
        ○ → ○ → ○ ← ○ → ○
        ↓       ↓   ↑
        ○       ○ → ○ ← ●
                ↓   ↓
                ○   ○
                    ↑
                    ●

Ora non ha più avuto cambiamenti, quindi torna allo stato invariato.

            ●
            ↓
● → ● → ● → ●   ● ← ●
        ↑       ↑   ↓
        ● → ● → ● ← ● → ●
        ↓       ↓   ↑
        ●       ● → ● ← ●
                ↓   ↓
                ●   ●
                    ↑
                    ●

Quindi, in questo processo, ci sono alcune cose:

  1. Tutti i nodi entrano in uno stato "modificato", fino a quando tutti i nodi sono stati modificati.
  2. In qualche modo si scopre che tutti i nodi che verranno modificati sono stati modificati. Ciò gli consente di tornare nello stato "invariato".

Questo grafico è abbastanza semplificato perché in realtà potrebbero esserci molti cicli complicati e molti altri collegamenti per nodo.

Tuttavia, dato che le frecce indicano la direzione in questo grafico ciclico orientato, mi chiedo come questo algoritmo possa eseguire efficientemente questa propagazione degli aggiornamenti.

L'approccio ingenuo dovrebbe scorrere tutti i nodi che hanno cambiato ogni passaggio, per vedere se c'è qualcosa da cambiare. Forse c'è un terzo stato, "cambiato e non più propagazione". Una volta che tutto è in quel terzo stato (controllando ogni nodo ogni passaggio), allora sarebbe fatto. Ti chiedi se esiste un modo efficace per farlo, quindi non ha bisogno di scorrere ogni nodo in ogni passaggio.

Inoltre, è possibile che più valori vengano modificati contemporaneamente, quindi dovrebbe essere in grado di gestirli ugualmente, cioè:

            ●
            ↓
● → ● → ● → ●   ● ← ◌
        ↑       ↑   ↓
        ◌ → ● → ● ← ● → ●
        ↓       ↓   ↑
        ●       ● → ● ← ●
                ↓   ↓
                ●   ◌
                    ↑
                    ●
    
posta Lance Pollard 02.07.2018 - 04:44
fonte

1 risposta

6

Questo è fondamentalmente privo di significato o hai omesso un dettaglio importante.

I diagrammi forniscono ciascuno stato del nodo 3:

● Invariato, non propagare
◌ Appena cambiato e bisognoso di propagazione
○ Vecchia modifica, non propagare

Ma alla fine torna ● a invariato. Quindi niente è appreso.

Il che mi fa pensare che non sia proprio lo stesso stato di partenza. È considerato lo stesso per quanto riguarda la propagazione.

Il che significa che ● e ○ sono in realtà lo stesso stato: non propagare.

Ma hai scelto di darci un 4 ° aggiornamento 4th recente che viene distrutto in questo esempio.

Tutto ciò mi fa pensare che i tuoi simboli siano solo incasinati.

Provalo in questo modo:

            0
            ↓
0 → 0 → 0 → 0   0 ← 0
        ↑       ↑   ↓
        0 → 0 → 0 ← 0 → 0
        ↓       ↓   ↑
        0       0 → 0 ← 0
                ↓   ↓
                0   0
                    ↑
                    0

E poi cambiamo un campo.

            0
            ↓
0 → 0 → 0 → 0   0 ← 0
        ↑       ↑   ↓
        1 → 0 → 0 ← 0 → 0
        ↓       ↓   ↑
        0       0 → 0 ← 0
                ↓   ↓
                0   0
                    ↑
                    0

Quindi si propaga:

            0
            ↓
0 → 0 → 1 → 0   0 ← 0
        ↑       ↑   ↓
        1 → 1 → 0 ← 0 → 0
        ↓       ↓   ↑
        1       0 → 0 ← 0
                ↓   ↓
                0   0
                    ↑
                    0

piu '...

            0
            ↓
0 → 0 → 1 → 1   0 ← 0
        ↑       ↑   ↓
        1 → 1 → 1 ← 0 → 0
        ↓       ↓   ↑
        1       0 → 0 ← 0
                ↓   ↓
                0   0
                    ↑
                    0

...

            0
            ↓
0 → 0 → 1 → 1   1 ← 0
        ↑       ↑   ↓
        1 → 1 → 1 ← 0 → 0
        ↓       ↓   ↑
        1       1 → 0 ← 0
                ↓   ↓
                0   0
                    ↑
                    0

            0
            ↓
0 → 0 → 1 → 1   1 ← 0
        ↑       ↑   ↓
        1 → 1 → 1 ← 0 → 0
        ↓       ↓   ↑
        1       1 → 1 ← 0
                ↓   ↓
                1   0
                    ↑
                    0

            0
            ↓
0 → 0 → 1 → 1   1 ← 0
        ↑       ↑   ↓
        1 → 1 → 1 ← 1 → 0
        ↓       ↓   ↑
        1       1 → 1 ← 0
                ↓   ↓
                1   1
                    ↑
                    0

A volte incontra un aggiornamento recente, come mostrato con 2.

            0
            ↓
0 → 0 → 1 → 1   1 ← 0
        ↑       ↑   ↓
        1 → 1 → 1 ← 2 → 1
        ↓       ↓   ↑
        1       1 → 1 ← 0
                ↓   ↓
                1   1
                    ↑
                    0

Ma continua:

            0
            ↓
0 → 0 → 1 → 1   1 ← 0
        ↑       ↑   ↓
        1 → 1 → 2 ← 2 → 2
        ↓       ↓   ↑
        1       1 → 1 ← 0
                ↓   ↓
                1   1
                    ↑
                    0

E alla fine entrambi gli aggiornamenti si sono diffusi il più possibile

            0
            ↓
0 → 0 → 1 → 1   2 ← 0
        ↑       ↑   ↓
        1 → 1 → 2 ← 2 → 2
        ↓       ↓   ↑
        1       2 → 2 ← 0
                ↓   ↓
                2   2
                    ↑
                    0

Ora non ha più avuto cambiamenti, quindi non fa nulla.

            0
            ↓
0 → 0 → 1 → 1   2 ← 0
        ↑       ↑   ↓
        1 → 1 → 2 ← 2 → 2
        ↓       ↓   ↑
        1       2 → 2 ← 0
                ↓   ↓
                2   2
                    ↑
                    0

Quindi l'unica cosa che devi controllare per determinare se dovresti propagare è quale aggiornamento è il più recente.

Also,itispossiblethatmultiplevaluesarechangedatonce,soitshouldbeabletohandlethataswell,i.e

0↓0→0→0→00←1b↑↑↓1a→0→0←0→0↓↓↑00→0←0↓↓01c↑0

Puògestirequesto,mahaicreatounarazzanondeterministica.Alcunivalorifinalisarannodeterminatinondaidatimadall'ordinedielaborazione.Nonesistealcunalgoritmoperrisolverequestoproblema.Unavoltachedecidichetuttietregliaggiornamenti"sono cambiati contemporaneamente" hanno tutti uguale validità.

            0
            ↓
0 → 0 → 1a→ 1a  1b← 1b
        ↑       ↑   ↓
        1a→ 1a→ 1?← 1b→ 1b
        ↓       ↓   ↑
        0       1?→ 1?← 0
                ↓   ↓
                1?  1c
                    ↑
                    0

E questa situazione provoca un buco in DFS perché non puoi emulare la vera propagazione, in questa situazione, in questo modo. La propagazione avviene prima per ampiezza.

Quindi se vuoi gestire gli aggiornamenti distribuiti hai bisogno di un modo per metterli in ordine e decidere quale vincerà, a meno che non ti dispiaccia lasciarli correre per questo.

    
risposta data 02.07.2018 - 06:25
fonte

Leggi altre domande sui tag