Pseudopolynomial zaman nedir? Polinom zamandan farkı nedir?

Nedir pseudopolynomial zaman ? Polinom zamandan farkı nedir? Pseudopolinom zamanında çalışan bazı algoritmalar, O (nW) ( 0/1 Sırt Çantası Problemi için ) veya O (√n) ( deneme bölümü için ) gibi çalışma zamanlarına sahiptir ; bu neden polinom zaman olarak sayılmıyor?

Polinom zaman ile sözde-polinom zaman arasındaki farkı anlamak için, "polinom zaman" ın ne anlama geldiğini resmileştirerek başlamamız gerekir.

Polinom zaman için ortak sezgi, "bir ^k için O (n ^k ) zamanı" dır . Örneğin, seçim sıralaması , polinom zamanı olan O (n ² ) zamanında çalışırken, TSP'nin kaba kuvvet çözümlemesi, polinom zamanı olmayan O (n · n!) Süresini alır.

Bu çalışma zamanlarının tümü, girdinin boyutunu izleyen bazı değişken n'ye karşılık gelir. Örneğin, seçim sıralamasında n, dizideki öğelerin sayısını belirtirken, TSP'de n, grafikteki düğüm sayısını belirtir. Bu bağlamda "n" nin gerçekte ne anlama geldiğinin tanımını standartlaştırmak için, zaman karmaşıklığının biçimsel tanımı, bir problemin "boyutunu" aşağıdaki gibi tanımlar:

Bir probleme girişin boyutu, o girişi yazmak için gereken bit sayısıdır.

Örneğin, bir sıralama algoritmasının girdisi 32 bitlik tam sayılardan oluşan bir diziyse, bu durumda girdinin boyutu 32n olacaktır, burada n, dizideki girdi sayısıdır. Düğümleri ve m kenarları olan bir grafikte, girdi, tüm düğümlerin bir listesi olarak belirtilebilir ve bunu, Ω (n + m) bit gerektiren tüm kenarların bir listesi izleyebilir.

Bu tanım göz önüne alındığında, polinom zamanın biçimsel tanımı aşağıdaki gibidir:

Bir algoritma, çalışma zamanı bazı sabit k için O (x ^k ) ise, polinom zamanda çalışır , burada x, algoritmaya verilen girdi bitlerinin sayısını gösterir.

Grafikleri, listeleri, ağaçları vb. İşleyen algoritmalarla çalışırken, bu tanım geleneksel tanıma az çok uymaktadır. Örneğin, 32 bitlik tam sayı dizilerini sıralayan bir sıralama algoritmanız olduğunu varsayalım. Bunu yapmak için seçim sıralaması gibi bir şey kullanırsanız, dizideki giriş elemanlarının sayısının bir fonksiyonu olarak çalışma zamanı O (n ² ) olacaktır. Fakat girdi dizisindeki eleman sayısı olan n, girdi bitlerinin sayısına nasıl karşılık gelir? Daha önce bahsedildiği gibi, girdi bitlerinin sayısı x = 32n olacaktır. Bu nedenle, algoritmanın çalışma zamanını n yerine x cinsinden ifade edersek, çalışma zamanının O (x ² ) olduğunu ve bu nedenle algoritmanın polinom zamanda çalıştığını anlarız .

Benzer şekilde, bir grafik üzerinde derinlemesine arama yaptığınızı varsayalım , bu süre O (m + n) alır; burada m, grafikteki kenar sayısı ve n, düğüm sayısıdır. Bu, verilen girdi bitlerinin sayısıyla nasıl ilişkilidir? Peki, girdinin bir bitişiklik listesi (tüm düğümlerin ve kenarların bir listesi) olarak belirtildiğini varsayarsak, daha önce belirtildiği gibi, girdi bitlerinin sayısı x = Ω (m + n) olacaktır. Bu nedenle, çalışma zamanı O (x) olacaktır, bu nedenle algoritma polinom zamanda çalışır.

Bununla birlikte, sayılar üzerinde çalışan algoritmalardan bahsetmeye başladığımızda işler bozulur. Bir sayının asal olup olmadığını test etme problemini düşünelim. Bir n sayısı verildiğinde, aşağıdaki algoritmayı kullanarak n'nin asal olup olmadığını test edebilirsiniz:

function isPrime(n):
    for i from 2 to n - 1:
        if (n mod i) = 0, return false
    return true

Peki bu kodun zaman karmaşıklığı nedir? Bu iç döngü O (n) kez çalışır ve her seferinde n mod i'yi hesaplamak için bir miktar çalışma yapar (gerçekten muhafazakar bir üst sınır olarak, bu kesinlikle O (n ³ ) zamanında yapılabilir ). Bu nedenle, bu genel algoritma O (n ⁴ ) zamanında ve muhtemelen çok daha hızlı çalışır.

2004 yılında, üç bilgisayar bilimcisi PRIMES is in P adında bir sayının asal olup olmadığını test etmek için bir polinom zaman algoritması veren bir makale yayınladı . Dönüm noktası niteliğinde bir sonuç olarak kabul edildi. Peki önemli olan nedir? Bunun için bir polinom-zaman algoritmamız yok mu, yani yukarıdaki algoritma?

Maalesef yapmıyoruz. Zaman karmaşıklığının biçimsel tanımının , girdi bitlerinin sayısının bir fonksiyonu olarak algoritmanın karmaşıklığından bahsettiğini unutmayın . Algoritmamız O (n ⁴ ) zamanında çalışır , ancak bu, giriş bitlerinin sayısının bir fonksiyonu olarak nedir? Pekala, n sayısını yazmak O (log n) bitlerini alır. Bu nedenle, x'in n girişini yazmak için gereken bit sayısı olmasına izin verirsek, bu algoritmanın çalışma zamanı aslında O (2 ^4x ) 'dir ve bu, x'te bir polinom değildir .

Bu, polinom zaman ile psödopolinom zamanı arasındaki ayrımın kalbidir. Bir yandan, bizim algoritmamız bir polinom gibi görünen O (n ⁴ ) 'dür, ancak diğer yandan, polinom zamanın biçimsel tanımı altında, bu polinom-zaman değildir.

Algoritmanın neden bir polinom zaman algoritması olmadığına dair bir önsezi edinmek için aşağıdakileri düşünün. Algoritmanın çok iş yapmasını istediğimi varsayalım. Böyle bir girdi yazarsam:

10001010101011

o zaman, örneğin en kötü durumda Ttamamlanması biraz zaman alacaktır . Şimdi sayının sonuna şöyle bir bit eklersem :

100010101010111

Çalışma zamanı şimdi (en kötü durumda) 2T olacaktır. Sadece bir bit daha ekleyerek algoritmanın yaptığı iş miktarını ikiye katlayabilirim!

Sahte polinom zamanında çalışan bir algoritma zamanı, onu temsil etmek için gereken bit sayısı yerine , girdinin sayısal değerinde bir polinom ise, polinom . Bizim birincil test algoritmamız bir sözde -polinom zaman algoritmasıdır, çünkü O (n ⁴ ) zamanında çalışmaktadır , ancak bir polinom zaman algoritması değildir, çünkü girdiyi yazmak için gereken x bit sayısının bir fonksiyonu olarak, çalışma zamanı O'dur. (2 ^4x ). "PRIMES'in P'de" kağıdının bu kadar önemli olmasının nedeni, çalışma süresinin (kabaca) O (log ¹² n) olmasıydı , bu da bit sayısının bir fonksiyonu olarak O (x ¹² ) 'dir.

Peki bu neden önemli? Tam sayıları çarpanlarına ayırmak için birçok sözde-polinom zaman algoritmamız var. Bununla birlikte, bu algoritmalar teknik olarak üstel zamanlı algoritmalardır. Bu, kriptografi için çok kullanışlıdır: RSA şifrelemesini kullanmak istiyorsanız, sayıları kolayca çarpanlara ayıramayacağımıza güvenebilmeniz gerekir. Rakamlardaki bit sayısını çok büyük bir değere (örneğin 1024 bit) yükselterek, sözde-polinom-zaman faktörleme algoritmasının o kadar fazla alması gereken süreyi yapabilirsiniz ki, sayılar. Öte yandan, bir polinom-zaman faktörleme algoritması bulabilirsek , bu ille de böyle değildir. Daha fazla bit eklemek, işin çok büyümesine neden olabilir, ancak büyüme sadece polinom büyüme olacaktır, üstel büyüme değil.

Bununla birlikte, çoğu durumda sözde-polinom zaman algoritmaları mükemmel derecede iyidir çünkü sayıların boyutu çok büyük olmayacaktır. Örneğin, sayma sıralaması çalışma zamanı O (n + U) içerir, burada U dizideki en büyük sayıdır. Bu sözde-polinomlu zamandır (çünkü U'nun sayısal değerinin yazması için O (log U) bitleri gerekir, bu nedenle çalışma zamanı girdi boyutunda üsteldir). U'nun çok büyük olmaması için U'yu yapay olarak sınırlarsak (örneğin, U'nun 2 olmasına izin verirsek), o zaman çalışma zamanı O (n) olur ki bu aslında polinom zamandır. Bu nasıl sayı tabanı sıralama çalışır: Genel çalışma zamanı, O, böylece numaralar, bir seferde bir bit işleyerek, her turun zamanı O (n) (n U log) 'dir. Bu aslında olduğu polinom zamanı, çünkü sıralamak için n sayı yazmak Ω (n) bit kullanır ve günlük U'nun değeri dizideki maksimum değeri yazmak için gereken bit sayısı ile doğru orantılıdır.

Bu yardımcı olur umarım!

Sözde polinom zaman karmaşıklığı, girdinin değerinde / büyüklüğünde polinom, ancak girdi boyutunda üstel anlamına gelir.

Boyut olarak, girdiyi yazmak için gereken bit sayısını kastediyoruz.

Sırt çantasının sözde kodundan, zaman karmaşıklığını O (nW) olarak bulabiliriz.

// Input:
// Values (stored in array v) 
// Weights (stored in array w)
// Number of distinct items (n) //
Knapsack capacity (W) 
for w from 0 to W 
    do   m[0, w] := 0 
end for  
for i from 1 to n do  
        for j from 0 to W do
               if j >= w[i] then 
                      m[i, j] := max(m[i-1, j], m[i-1, j-w[i]] + v[i]) 
              else 
                      m[i, j] := m[i-1, j]
              end if
       end for 
end for

Burada, W girdinin uzunluğunda polinom değildir, bu da onu sözde polinom yapan şeydir.

W'yi temsil etmek için gereken bit sayısı olsun

i.e. size of input= s =log(W) (log= log base 2)
-> 2^(s)=2^(log(W))
-> 2^(s)=W  (because  2^(log(x)) = x)

Şimdi, running time of knapsack= O (nW) = O (n * 2 ^ s) olan polinom değil.