Bir çift özyinelemeli işlevin çalışma zamanını nasıl belirlerim?

Herhangi bir keyfi olarak çift özyinelemeli işlev verildiğinde, çalışma süresi nasıl hesaplanır?

Örneğin (sözde kodda):

int a(int x){
  if (x < = 0)
    return 1010;
  else
    return b(x-1) + a(x-1);
}
int b(int y){
  if (y <= -5)
    return -2;
  else
    return b(a(y-1));
}

Ya da bu çizgiler boyunca bir şey.

Böyle bir şeyi belirlemek için hangi yöntemler kullanılabilir veya kullanılmalıdır?

Siz işlevinizi değiştirmeye devam edersiniz. Ama dönüşüm olmadan sonsuza dek çalışacakları seçmeye devam et

Özyineleme karmaşık ve hızlı hale gelir. Önerilen iki kat özyinelemeli işlevi analiz etmenin ilk adımı, onu bazı örnek değerler üzerinde izlemeye çalışmak ve ne yaptığını görmek. Hesaplamanız sonsuz bir döngüye girerse, işlev iyi tanımlanmamıştır. Hesaplamanız daha büyük rakamlar almaya devam eden bir sarmal haline gelirse (ki bu çok kolay olur), muhtemelen iyi tanımlanmamıştır.

Eğer onu takip etmek bir cevap verirse, cevaplar arasında bir örüntü veya tekrarlama ilişkisi bulmaya çalışırsınız. Bunu yaptıktan sonra, çalışma zamanını anlamaya çalışabilirsiniz. Bunu anlamak çok, çok karmaşık olabilir, ancak birçok durumda cevabı bulmamızı sağlayan Master teoremi gibi sonuçlarımız var .

Tek özyineleme ile bile, çalışma zamanını nasıl hesaplayacağımızı bilmediğimiz işlevlerle gelmenin kolay olduğunu unutmayın. Örneğin aşağıdakileri göz önünde bulundurun:

def recursive (n):
    if 0 == n%2:
        return 1 + recursive(n/2)
    elif 1 == n:
        return 0
    else:
        return recursive(3*n + 1)

Öyle anda bilinmeyen bu işlev her zaman çalışma zamanı ne dursun, iyi tanımlanmış olup olmadığını.

Söz konusu işlev çiftinin çalışma zamanı sınırsızdır, çünkü ikisi de diğerini çağırmadan geri dönmez. Dönüş değeri aolan her zaman yapılan çağrının dönüş değerine bağımlı bolan her zaman çağırır a... ve olarak bilinen yıllardan bu sonsuz özyineleme .

Bariz yöntem işlevi çalıştırmak ve ne kadar sürdüğünü ölçmektir. Ancak bu yalnızca belirli bir girdinin ne kadar sürdüğünü gösterir. Önceden işlevin sonlandığını bilmiyorsanız, zor: işlevin sonlanıp sonlanmadığını anlamanın mekanik bir yolu yoktur - bu durma problemidir ve karar verilemez.

Bir fonksiyonun çalışma süresini bulmak, Rice teoremi ile benzer şekilde kararlaştırılamaz . Aslında Rice'ın teoremi, bir fonksiyonun O(f(n))zamanında çalışıp çalışmadığına karar vermenin bile kararsız olduğunu gösterir.

Bu yüzden genel olarak yapabileceğiniz en iyi şey, bildiğimiz kadarıyla Turing makinelerinin sınırlarına bağlı olmayan insan zekanızı kullanmak ve bir deseni tanımaya veya bir icat yapmaya çalışmaktır. Bir işlevin çalışma süresini analiz etmenin tipik bir yolu, işlevin özyinelemeli tanımını, çalışma zamanında özyinelemeli bir denkleme (veya karşılıklı olarak özyinelemeli işlevler için bir dizi denkleme) dönüştürmektir:

T_a(x) = if x ≤ 0 then 1 else T_b(x-1) + T_a(x-1)
T_b(x) = if x ≤ -5 then 1 else T_b(T_a(x-1))

Sırada ne var? Şimdi bir matematik probleminiz var: bu fonksiyonel denklemleri çözmeniz gerekiyor. Genellikle çalışan bir yaklaşım fonksiyonları yorumlayarak, bu çözmek için analitik fonksiyonlar ve kullanım calculus'a denklem içine tamsayı fonksiyonları üzerine bu denklemleri açmaktır T_ave T_bolarak üreten fonksiyonlar .

Fonksiyonlar ve diğer ayrık matematik konularında Ronald Graham, Donald Knuth ve Oren Patashnik'in Beton Matematik kitabını öneriyorum .

Diğerlerinin belirttiği gibi, özyinelemeyi analiz etmek çok hızlı bir şekilde zorlaşabilir. İşte böyle bir şeyin başka bir örneği: http://rosettacode.org/wiki/Mutual_recursion http://en.wikipedia.org/wiki/Hofstadter_sequence#Hofstadter_Female_and_Male_sequences Bir cevap ve çalışma süresi hesaplamak zor. Bunun nedeni, "zor bir forma" sahip olan karşılıklı olarak özyinelemeli işlevlerdir.

Her neyse, bu kolay örneğe bakalım:

http://pramode.net/clojure/2010/05/08/clojure-trampoline/

(declare funa funb)
(defn funa [n]
  (if (= n 0)
    0
    (funb (dec n))))
(defn funb [n]
  (if (= n 0)
    0
    (funa (dec n))))

Hesaplamaya çalışarak başlayalım funa(m), m > 0:

funa(m) = funb(m - 1) = funa(m - 2) = ... funa(0) or funb(0) = 0 either way.

Çalışma süresi:

R(funa(m)) = 1 + R(funb(m - 1)) = 2 + R(funa(m - 2)) = ... m + R(funa(0)) or m + R(funb(0)) = m + 1 steps either way

Şimdi biraz daha karmaşık bir örnek daha seçelim:

Kendi başına iyi bir okuma olan http://planetmath.org/encyclopedia/MutualRecursion.html'den esinlenerek şunları inceleyelim: "" "Fibonacci sayıları karşılıklı özyineleme ile yorumlanabilir: F (0) = 1 ve G (0) ) = 1, F (n + 1) = F (n) + G (n) ve G (n + 1) = F (n) ile. "" "

Peki, F'nin çalışma süresi nedir? Diğer yoldan gideceğiz.
Şey, R (F (0)) = 1 = F (0); R (G (0)) = 1 = G (0)
Şimdi R (F (1)) = R (F (0)) + R (G (0)) = F (0) + G (0) = F (1)
...
R (F (m)) = F (m) - örneğin, i indeksindeki bir Fibonacci numarasını hesaplamak için gereken fonksiyon çağrılarının sayısının bir Fibonacci sayısının değerine eşit olduğunu görmek zor değil i dizininde. Bu, iki sayı birlikte eklemenin bir işlev çağrısından çok daha hızlı olduğu varsayılmıştır. Durum böyle olmasaydı, bu doğru olurdu: R (F (1)) = R (F (0)) + 1 + R (G (0)) ve bunun analizi daha karmaşık olurdu, muhtemelen kolay kapalı bir form çözümü olmadan.

Fibonacci dizisi için kapalı formun yeniden icat edilmesi kolay değildir, daha karmaşık örneklerden bahsetmiyoruz.

Yapılacak ilk şey, tanımladığınız işlevlerin tam olarak hangi değerlere sonlandığını göstermektir. Tanımladığınız örnekte

int a(int x){
  if (x < = 0)
    return 1010;
  else
    return b(x-1) + a(x-1);
}
int b(int y){
  if (y <= -5)
    return -2;
  else
    return b(a(y-1));
}

by <= -5çünkü yalnızca başka bir değer eklerseniz formun bir terimi olacaktır b(a(y-1)). Eğer genişleyen biraz daha yaparsanız göreceksiniz formun bir terim olduğunu b(a(y-1))terime sonunda açar b(1010)hangi bir terim için iletkenler b(a(1009))hangi terime tekrar açar b(1010). Bu, atatmin edici olmayan herhangi bir değeri ekleyemeyeceğiniz anlamına gelir, x <= -4çünkü bunu yaparsanız, hesaplanacak değerin hesaplanacak değere bağlı olduğu sonsuz bir döngü elde edersiniz. Yani bu örnekte sabit çalışma süresi vardır.

Bu nedenle basit cevap, özyinelemeli işlevlerin çalışma süresini belirlemek için genel bir yöntem olmamasıdır, çünkü özyinelemeli olarak tanımlanmış bir işlevin sonlanıp sonlanmadığını belirleyen genel bir prosedür yoktur.

Big-O'da olduğu gibi mi?

Bu kolay: O (N) - bir fesih koşulu olduğu varsayılarak.

Özyineleme sadece döngüdür ve bu döngüde ne kadar çok şey yaparsanız yapın (ve başka bir yöntem çağırmak döngüdeki başka bir adımdır ) basit bir döngü O (N ) 'dir.

İlginç olacağı nokta, özyinelemeli yöntemlerden bir veya daha fazlasında bir döngü varsa. Bu durumda, bir tür üstel performans elde edersiniz ( yöntemden her geçişte O (N) ile çarpılır ).