Como analisar um algoritmo recursivo randomizado?

Considere o seguinte algoritmo, em que é uma constante fixa. $c$

void partition(A[1..m], B[1..n])
{
   if m=1 or n=1
      return

   k = random(min(c,m,n));
   partition A into k sublists Asub[1..k] at k-1 distinct random indices
   partition B into k sublists Bsub[1..k] at k-1 distinct random indices

   for i = 1 to k
     for j = 1 to k
        partition(Asub[i], Bsub[j])

   Do something that takes O(n+m) time.
}

Qual é o tempo de execução esperado desse algoritmo? O tempo de execução parece ser , mas não consigo encontrar a prova disso. $O(mn)$

Se, em vez disso, particionássemos as listas de entrada em partes diferentes de igual comprimento, teríamos a recorrência com caso base ; não é difícil provar que . Mas o algoritmo particiona a entrada em um número aleatório de partes com tamanhos aleatórios . (Como sempre, "aleatório" é uma abreviação de "uniformemente aleatório".) Como alguém analisa esse algoritmo? $k$ $T(n,m) = k^2\,T(n/k,m/k) + O(n+m)$ $T(1,n) = T(m,1) = O(1)$ $T(n,m) = O(mn)$

— Saeed
fonte

Seu algoritmo chamado partição é do tipo lista -> lista -> nula, mas parece-me que em sua última chamada do algoritmo ela tem o tipo -> -> nula? Estou entendendo mal alguma coisa?

′a $'a$

— Gopi

A pergunta está mal escrita, mas por baixo dela há uma pergunta genuína sobre a análise de recorrências aleatórias.

— Suresh Venkat

Edição principal. Espero ter preservado o sentido da pergunta.

— Jeffε

@ Jɛ ff E agora você deve respondê-la :)

— Suresh Venkat

Você já olhou o artigo de Chaudhuri-Dubhashi sobre recorrências probabilísticas (isso desenvolve ainda mais o trabalho original de Karp sobre esse problema): sciencedirect.com/science/article/pii/S0304397596002617

— Suresh Venkat

Respostas:

Aqui está uma prova de que esse algoritmo é executado em tempo em expectativa e com alta probabilidade. $O(n\,m)$

Primeiro, considere o algoritmo modificado para que seja escolhido em vez de aleatoriamente em . $k$ $\{2,3,..,\min(c,n)\}$ $\{1,2,...,\min(c,n)\}$

Lema 1. Para este algoritmo modificado, independentemente das escolhas aleatórias do algoritmo, o tempo é sempre . $O(n\,m)$

Prova. Corrija uma entrada e e corrija arbitrariamente as escolhas aleatórias do algoritmo. Em cada chamada (possivelmente recursiva) para partição (), os dois argumentos correspondem, respectivamente, a dois subarrays: uma sub-disposição de e uma sub-disposição de . Identifique essa chamada com o retângulo . Portanto, a chamada de nível superior é , e cada chamada recursiva corresponde a um sub-retângulo nesse $A[1..n]$ $B[1..m]$ $A[i_1..i_2]$ $A$ $B[j_1..j_2]$ $B$ $[i_1-1,i_2] \times [j_1-1,j_2]$ $[0,n]\times[0,m]$ $n\times m$ retângulo. Esses retângulos formam uma árvore, onde o retângulo correspondente a uma chamada tem como filhos os retângulos que correspondem às chamadas feitas diretamente por essa chamada. Cada retângulo pai é particionado por seus retângulos filhos, que formam uma grade (de retângulos não uniformes) com pelo menos 2. É claro que os cantos de cada retângulo têm apenas coordenadas inteiras. $k\times k$ $k$

O tempo de execução do algoritmo é limitado por uma constante vezes a soma, sobre os retângulos, dos perímetros de todos esses retângulos. (Isso ocorre porque o tempo em cada chamada é O (n + m) e o perímetro do retângulo correspondente é .) $2(n+m)$

Afirmo que em qualquer conjunto de retângulos como descrito acima, a soma dos perímetros é no máximo . Se for verdade, isso prova o lema. $12 n\,m$

Para provar a afirmação, observe primeiro que, como , para qualquer retângulo pai, o perímetro do pai é no máximo 2/3 vezes o perímetro total dos filhos. (O perímetro do pai é . O perímetro total das crianças é , e ). $k \ge 2$ $2(n+m)$ $(1+k)(n+m)$ $k >= 2$

Segue-se por um argumento de cobrança padrão que o perimitro total de todos os retângulos é no máximo vezes o perimitro apenas dos retângulos foliares . (A observação implica que , onde é o perímetro total dos retângulos que não são folhas e é o perímetro total de todos os retângulos. Isso implica , e é o perímetro total dos retângulos foliares.) $(1 + 2/3 + (2/3)^2 + \ldots ) = 3$ $P_N \le (2/3) P_T$ $P_N$ $P_T$ $P_T \le 3(P_T-P_N)$ $P_T-P_N$

Em seguida, observe que os retângulos de folhas particionam o retângulo . O perímetro máximo possível das folhas é obtido quando as folhas correspondem aos quadrados da unidade com pontos finais inteiros; nesse caso, o perímetro total das folhas é . Assim, a soma dos perímetros é no máximo , ou seja, no máximo . $n\times m$ $4\,n\,m$ $3\cdot 4\,n\,m$ $12 n\,m$

Isso prova o lema 1.

Corolário: O algoritmo original é executado em no tempo esperado. $O(n\,m)$

Prova. Se a partição escolher , apenas duplicará o retângulo. Como , a probabilidade de que seja no máximo 1/2. Assim, o número esperado de vezes que cada retângulo é duplicado é no máximo 1 (e o número esperado de cópias de cada retângulo é no máximo 2). Assim, para o algoritmo original, a soma esperada dos perimitros de todos os retângulos é no máximo duas vezes a do algoritmo modificado, ou seja, no máximo . Assim como na análise desse algoritmo, o tempo de execução é proporcional a essa soma, assim como . QED $k=1$ $n>1$ $k=1$ $24 n\,m$ $O(n\,m)$

Corolário. O limite também se mantém com alta probabilidade (assumindo que e tendem ao infinito). $n$ $m$

Esboço de prova. Corrigindo todas as opções aleatórias, exceto o número de duplicatas de cada retângulo, o tempo é proporcional a onde é o conjunto de retângulos gerados, é o número de vezes que é duplicado (isto é, quando para esse retângulo) eé o perímetro de .

\sum r \in R (1 + X r) | r |

$\sum_{r\in R} (1+X_r) |r|$

R $R$

Xr $X_r$

r $r$

k=1 $k=1$

|r| $|r|$

r $r$

As variáveis são independentes e cadaé ; portanto, por um limite Chernoff padrão, a probabilidade de que a soma exceda o dobro de sua expectativa é . (Mais especificamente, pegue e aplique Chernoff à soma dos 's.) QED $\{X_r : r \in R\}$ $|r|$ $O(n+m) = o(n m)$ $o(1)$ $Y_r = (1+X_r) |r|/2(n+m)$ $Y_{r}$

Como um aparte: se o algoritmo escolher aleatoriamente até vez de e, em seguida, funcionará em cada chamada (em vez de ), o tempo total ainda seria na expectativa. $k$ $\min(n,m)$ $\min(c,n)$ $O(m n)$ $O(m+n)$ $O(mn)$

Prova. Primeiro, observe que o tempo total seria proporcional à soma das áreas de todos os retângulos. Essa soma é igual à soma, sobre as coordenadas inteiras , do número de retângulos nos quais ocorre. Esse é na expectativa porque, na expectativa, qualquer dado no retângulo original ocorre em retângulos . $(i,j)$ $(i,j)$ $O(nm)$ $(i,j)$ $O(1)$

Para ver isso, suponha que esteja contido em um retângulo e considere a chamada para particionar em . Seja . Seja o retângulo que é o filho (contendo ) de . Com probabilidade de pelo menos , é escolhido para ser pelo menos . Com essa condição, , portanto, com probabilidade constante é no máximo 1. Se isso acontecer, então é uma folha (não tem filhos). Daqui resulta que o número esperado de retângulos que $(i,j)$ $r$ $r$ $q(r) = \min(n_r,m_r)$ $r'$ $(i,j)$ $r$ $1/3$ $k$ $(2/3)q(r)$ $E[q(r')] \le 3/2$ $q(r')$ $r'$ $(i,j)$ está em é . QED $O(1)$

(Se o limite de se manteria com alta probabilidade é uma questão interessante. Eu acho que sim. Certamente suportaria whp) $O(nm)$ $O(nm\log(nm))$

— Neal Young
fonte

Muito obrigado, essa é uma idéia realmente interessante e inteligente. Apenas para uma observação, podemos usar sua ideia para particionar um array tridimensional. Quase na parte que você disse que as crianças estão fazendo , na verdade elas dividem o pai em parte dos retângulos, não são necessárias partes do mesmo tamanho, então elas não fazem uma grade, mas ainda assim o seu argumento é sobre perímetros dos pais sobre o total de filhos. Também não consegui entender como, se substituirmos por como custo extra de cada execução, ainda temos o tempo total de execução de . Mais uma vez, muito obrigado pela idéia muito inteligente.

K×K $K\times K$

K2 $K^2$

2/3 $2/3$

O(m+n) $O(m+n)$

O(mn) $O(mn)$

— Saeed

De nada! Vou editar a prova para esclarecer os pontos que você levanta ..

— Neal Young

Bom esclarecimento e boa pergunta no final, muito obrigado.

— Saeed

A abordagem típica é analisar o valor esperado dos tempos de execução do algoritmo. Nesse caso, o valor esperado do tempo de execução, em qualquer problema com , é algo como vezes o tempo de execução esperado da partição de subproblemas [ ]. Para cada o tamanho do subproblema é uma variável aleatória. $m,n$ $k^2$ $A_i,B_j$ $i,j$

O comprimento da lista é a diferença entre o th e th estatísticas de ordem quando elementos são elaborados a partir de uar . Isso é essencialmente (isto é, vezes um desvio de uma variável aleatória ). Por isso, temos $A_i$ $i$ $i+1$ $k$ $\{1, ..., m \}$ $m \beta(k,m+k+1)$ $m$ $\beta(1,m+k+1)$

T [m, n | k] = C (m + n) + k 2 \int x, y T (m x, n y) x k - 1 y k - 1 ( 1 - x ) m + k - 1 ( 1 - y ) n + k - 1 β ( k , n + k + 1 ) β ( k , m + k + 1 ) d x d y

$T[m,n | k] = C (m + n) + k^2 \int_{x,y} T(m x, n y) \frac{x^{k-1} y^{k-1} (1-x)^{m+k-1} (1-y)^{n+k-1}}{\beta(k,n+k+1) \beta(k,m+k+1)} dx dy$

Há algum erro de arredondamento aqui, pois deveríamos realmente ter no integrando. $T(\lceil mx \rceil, \lceil ny \rceil)$

Infelizmente, é uma variável aleatória, portanto, é preciso também integrar sobre ela. Eu não acho que exista motivo para exigir , como se você simplesmente particionasse os dados em sub-listas que podem estar vazias. Digamos que seja escolhido uniformemente aleatoriamente entre . Então você obtém $k$ $k \leq n$ $k \geq n$ $k$ $1,\dots, c$

T [m, n] = C (m + n) + \sum k = 1 c k 2 c \int x, y T (m x, n y) x k - 1 y k - 1 ( 1 - x ) m + k - 1 ( 1 - y ) n + k - 1 β ( k , n + k + 1 ) β ( k , m + k + 1 ) d x d y

$T[m,n] = C (m + n) + \sum_{k=1}^c \frac{k^2}{c} \int_{x,y} T(m x, n y) \frac{x^{k-1} y^{k-1} (1-x)^{m+k-1} (1-y)^{n+k-1}}{\beta(k,n+k+1) \beta(k,m+k+1)} dx dy$

Essa recorrência é bastante horrível, mas se você adivinhar um limite para (suponho que ) você pode conectá-lo e verificá-lo. $T[m,n]$ $T(m,n) = O( (\log m + \log n) (m+n) )$

— David Harris
fonte