Come viene risolto il "Problema di raccolta della pizza" usando tecniche di programmazione dinamica?

Winkler's pizza picking problem:

• Una torta di pizza circolare a nfette, in cui la fetta iha un'area S_i, ovvero l'area è diversa per ogni pezzo di torta.
• I mangiatori Alice e Bob a turno raccolgono le fette, ma è scortese creare più spazi vuoti nella torta (consideralo non permesso).
  • Pertanto, ogni mangiatore è limitato a prendere una delle due fette adiacenti alla regione aperta. Alice inizia per prima, ed entrambi i mangiatori cercano più torta possibile.

In che modo un algoritmo di programmazione dinamica determinerebbe quanta torta mangia Alice se sia Alice che Bob giocano perfettamente per massimizzare il consumo di pizza?

La mia comprensione:

In un problema di DP generale, andiamo avanti con la ricerca di sotto-problemi che possono essere visualizzati usando l'albero di ricorsione o, più strettamente, usando un DAG. Qui, non sto trovando alcun indizio per trovare i sotto-problemi qui.

Qui, per un dato set di S, dobbiamo massimizzare l'area delle fette consumate da Alice. Ciò dipenderà dalla scelta di una permutazione delle fette di Pizza su (n-1) permutazioni. Scegliere una sezione massima dell'area tra due opzioni disponibili in ogni n \ 2 giri che Alice ottiene ci darà l'area totale della sezione per una permutazione. Dobbiamo trovare un'area di taglio per tutte queste permutazioni. E poi il massimo di questi.

Qualcuno può darmi una mano su come andare avanti?

Inizia considerando le fette appena posizionate su una riga e puoi scegliere da una delle due estremità. In questo caso supponendo che sia il tuo turno di scegliere, è chiaro che lo pizzaAmount(slices)è

1. Se non è rimasta pizza il risultato è 0
2. Se c'è un solo risultato della fetta è quella fetta
3. Se ci sono almeno due sezioni, il risultato è:

(usando la sintassi di Python)

max(slices[0] + sum(slices[1:]) - pizzaAmount(slices[1:]),
    slices[-1] + sum(slices[:-1]) - pizzaAmount(slices[:-1]))

in altre parole dovresti considerare entrambe le alternative e che dopo aver preso la tua fetta otterrai tutta la pizza rimanente tranne il risultato della chiamata ricorsiva (perché il tuo amico utilizzerà la stessa strategia).

Puoi implementarlo con DP (o memoizing) perché l'array è effettivamente fisso e puoi considerare come parametri il primo e l'ultimo indice di slice.

Per risolvere il problema completo originale devi solo provare tutte le sezioni come fetta iniziale e scegliere quella che massimizza il risultato.

Per parte della pizza definisci F(i,j)come massimo quanta persona può mangiare per prima la fetta. Le fette di parte di pizza (i,j)sono:

if i <= j than slices i, i+1, ..., j-1, j
if i > j than slices i, i+1, ..., n-1, n, 1, 2, ..., j-1, j
and we don't define it for whole pizza, abs(i-j) < n-1

Definisci R(i,j)(quanto rimane per la seconda persona) come sum(S_x, x in slices(i,j)) - F(i,j).

Con:

F(i,i) = S_i,
F(i,j) = max( S_i + R(i+1,j), S_j + R(i,j-1) ),

il massimo che Alice può mangiare è calcolato da:

max( S_i + F(i+1, (i-1) if i > 1 else n) ).