Berapa waktu berjalan dari algoritma rekursif ini?

Saya membuat program Haskell (ungolfed) berikut untuk tantangan kode golf untuk komputasi yang pertama $n$ nilai A229037 .

Ini adalah solusi yang saya usulkan untuk menghitung $n$ nilai th:

a n | n<1        = 0 
    | n<3        = 1
    | otherwise  = head (goods n)

goods n = [x | x <- [1..], isGood x n]

isGood x n = and [ x - a(n-k) /= a(n-k) - a(n-k-k) || a(n-k-k) == 0 | k <- [1..n] ]

Perhatikan bahwa Haskell tidak secara otomatis menyimpan atau mem-memo nilai-nilai ini.

Halaman OEIS untuk urutan memberikan fakta itu $a(n) \leq (n+1)/2$ , sehingga [1..]bisa diganti oleh [1..(n+1)/2], karena algoritme tidak akan pernah mencapai $x$ lebih besar dari $\frac{n+1}{2}$ .

Mencoba menghitung panggilan fungsi, saya menurunkan batas atas berikut $T(n)$ , jumlah fungsi yang dipanggil oleh algoritma untuk input $n$ :

\begin{aligned} T (n) & = \sum_{x = 1}^{(n + 1) / 2} \sum_{k = 1}^{n} 2 T (n - k) + 2 T (n - 2 k) \\ \leq \sum_{x = 1}^{(n + 1) / 2} \sum_{k = 1}^{n} T (n - k) \\ \leq \sum_{x = 1}^{(n + 1) / 2} \sum_{k = 1}^{n} 4 T (n - 1) \\ \leq \sum_{x = 1}^{(n + 1) / 2} 4 n T (n - 1) \\ \leq 4 n T (n - 1) \frac{n + 1}{2} \\ \leq 2 n (n + 1) T (n - 1)) \end{aligned}

$\begin{align} T(n) &= \sum_{x=1}^{(n+1)/{2}} \sum_{k=1}^{n} 2~T(n-k) + 2~T(n-2 k) \\ &\leq \sum_{x=1}^{(n+1)/{2}} \sum_{k=1}^{n} ~T(n-k)\\ &\leq \sum_{x=1}^{(n+1)/{2}} \sum_{k=1}^{n} 4~T(n-1)\\ &\leq \sum_{x=1}^{(n+1)/{2}} 4~n~T(n-1)\\ &\leq 4~n~T(n-1)~\frac{n+1}{2}\\ &\leq 2~n~(n+1)~T(n-1) ) \end{align}$

Saya memasukkan rumus terakhir ke dalam Mathematica:

RSolve[{T[n] == 2*T[n - 1]*n*(n + 1), T[1] == 1}, T[n], n]

Dan dapatkan, setelah sedikit penyederhanaan: $T(n) \leq ~2^n~n!~(n + 1)!$

Rasio rata-rata antara ini dan waktu pelaksanaan program Haskell, untuk $n \in [12,20]$ adalah $2.0 \cdot 10^{39}$ dan standar deviasi rasio sekitar $6.0 \cdot 10^{39}$ . (Cukup aneh, plot log rasio tampaknya menjadi garis lurus).

Rasio dengan baris pertama, menentukan $T(n)$ , memiliki mean dan standar deviasi $4.8 \cdot 10^6$ dan $1.8 \cdot 10^6$ , masing-masing, tetapi plotnya banyak melompat.

Bagaimana saya bisa mendapatkan keterikatan yang lebih baik pada kompleksitas waktu dari algoritma ini?

Berikut ini adalah algoritma dalam C yang valid (minus deklarasi maju), yang saya percaya kira-kira setara dengan kode Haskell:

int a(int n){
    if (n < 1) {
        return 0;
    } else if (n < 3) {
        return 1;
    } else {
        return lowestValid(n);
    }
}

int lowestValid(int n){
    int possible = 1; // Without checking, we know that this will not exceed (n+1)/2

    while (notGood(possible, n)) {
        possible++;
    }
    return possible;
}

int notGood(int possible, int n){
    int k = 1;

    while (k <= n) {
        if ( ((possible - a(n-k)) == (a(n-k) - a(n-2*k))) && (a(n-2*k) != 0) ) {
            return 1;
        } else {
            k++;
        }
    }
    return 0;
}

Versi C membutuhkan waktu sekitar 5 menit untuk menghitung $a(17)$ dan versi Haskell membutuhkan waktu yang hampir sama untuk $a(19)$ .

Kali pertama versi:

Haskell: [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0e-2,3.0e-2,9.0e-2,0.34,1.42,11.77,71.68,184.37,1815.91]
C:       [2.0e-6, 1.0e-6, 1.0e-6, 2.0e-6, 1.0e-6, 6.0e-6, 0.00003,0.00027, 0.002209, 0.005127, 0.016665, 0.080549, 0.243611, 0.821537, 4.56265, 24.2044, 272.212]

— Michael Klein
sumber

Saya telah mengubah tag dan judul untuk memperjelas bahwa ini adalah analisis algoritma, bukan pertanyaan teori kompleksitas. "Dengan asumsi bahwa multiplikasi dan penambahan dapat diabaikan" - bisakah Anda ? Benarkah ? Masih lebih baik untuk mengatakan apa yang Anda hitung, karena kemungkinan besar Anda tidak menghitung banyak hal. Lihat juga pertanyaan referensi kami .

— Raphael

Sudahkah Anda mencoba memplot hasil Anda (dengan beberapa faktor konstan) terhadap waktu berjalan ukuran aktual? (Sering kali lebih informatif untuk merencanakan rasio dan menebak jika konvergen ke sesuatu masuk

O (1)

$O(1)$ .) Yang mengatakan, saya merasa sulit untuk membantu di sini sejak ansatz untuk

T

$T$ tergantung pada keterangan dari Haskell, yang tidak semua orang di sini berbicara. Secara khusus, bagaimana pemahaman set ini dievaluasi? Apakah ayang memoized? Anda mungkin mendapatkan jawaban yang lebih baik (atau ada, sungguh!) Jika Anda memasukkan versi pseudo-code yang memaparkan apa yang sebenarnya terjadi sebagaimana diperlukan untuk analisis yang ketat.

— Raphael

Akhirnya, menggunakan metode pas untuk mendapatkan batas Landau mungkin sia-sia. Setiap fungsi seperti itu hanya dapat cocok dengan satu set fungsi tetap; Saya menduga bahwa Mathematica digunakan pada model eksponensial terburuk di sana, sehingga melakukan pekerjaan yang buruk menangkap pertumbuhan super-eksponensial.

— Raphael

@Raphael Komentar Anda sangat membantu. Saya akan melihat lebih dalam ketika saya punya waktu. Juga

O (n^{2} 2)

$O(n^22)$ datang dari menyesuaikan logaritma nilai ke garis, yang lebih merupakan bidikan dalam kegelapan daripada yang lain.

— Michael Klein

Anda dapat menuliskan perulangan Anda sebagai

T (n) = (n + 1) (T (n - 1) + 2 T (n - 2) + T (n - 3) + 2 T (n - 4) + \dots) .

$T(n) = (n+1)(T(n-1) + 2T(n-2) + T(n-3) + 2T(n-4) + \cdots).$ Khususnya,

T (n) \geq (n + 1) T (n - 1)

$T(n) \geq (n+1) T(n-1)$ . Ini artinya urutan

T (n)

$T(n)$ tumbuh sangat cepat, dan khususnya

T (n - 1) + 2 T (n - 2) + \dots \leq T (n - 1) [1 + \frac{2}{n} + \frac{1}{n (n - 1)} + \frac{2}{n (n - 1) (n - 2)} + \dots] = (1 + O (1 / n)) T (n - 1) .

$T(n-1) + 2T(n-2) + \cdots \leq T(n-1) \left[ 1 + \frac{2}{n} + \frac{1}{n(n-1)} + \frac{2}{n(n-1)(n-2)} + \cdots \right] = (1+O(1/n)) T(n-1).$ Karena itu

T (n) \leq (n + O (1)) T (n - 1) .

$T(n) \leq (n+O(1)) T(n-1).$ Ini artinya

T (n) = O ((n + O (1))!),

$T(n) = O((n+O(1))!),$ dan sebagainya

T (n) = O (n^{O (1)} (n / e)^{n}) .

$T(n) = O\left(n^{O(1)} (n/e)^n\right).$ Ini meningkatkan Anda terikat oleh akar kuadrat.

— Yuval Filmus
sumber