Maksimum Bir bölümdeki benzersiz alt dize sayısı

Başlığı daha anlaşılır olacak şekilde değiştirdim.

İşte sorunun ayrıntılı bir versiyonu:

Bir dizemiz var s ve onu alt dizelere ayırmak istiyoruz . Her alt dize birbirinden farklıdır. Bir kesimden alabileceğimiz maksimum benzersiz alt dize sayısı nedir ? Başka bir deyişle, forma birleştiren maksimum benzersiz alt dize sayısı nedir s?

İşte bazı örnekler:

Example 1
s = 'aababaa'
output = 4
Explain: we can split `s` into aa|b|aba|a or aab|a|b|aa, 
         and 4 is the max number of substrings we can get from one split.

Example 2
s = 'aba'
output = 2
Explain: a|ba

Example 3
s = 'aaaaaaa'
output = 3
Explain: a|aa|aaaa

Not : syalnızca küçük harfler içerir. Bana sen uygun zaman karmaşıklığını ne kadar süre ve dolayısıyla tahmin edemediğimi söylemedim . :(

NP zor bir problem mi? Değilse, verimli bir şekilde nasıl çözebilirim?

Bu problemi bir arkadaşımdan duydum ve cevaplayamadım. Bu sorunu çözmek için bir Trie + açgözlü kullanmaya çalışıyorum. Yöntem ilk örnek için başarısız olur.

İşte geldiğim Trie çözümü:

def triesolution(s):
    trie = {}
    p = trie
    output = 0
    for char in s:
        if char not in p:
            output += 1
            p[char] = {}
            p = trie
        else:
            p = p[char]
    return output

O bölünmeye çalışıyor beri Örneğin 1, yukarıda kod 3 dönecektir siçine a|ab|abaa.

Ekleme: Herkesin fikri sayesinde, bu problem bir NP problemine çok yakın görünüyor. Şu anda, bu yönden düşünmeye çalışıyorum. Bir fonksiyonumuz olduğunu varsayalım Guess(n). Tek bir bölmeden veya başka bir şekilde benzersiz alt dizeler Truebulabilirsek bu işlev geri döner . Burada bir gözlem, eğer o zaman herkes için . Bitişik iki alt dizeyi bir araya getirebildiğimiz için. Bu gözlem ikili bir çözüme yol açabilir. Ancak, yine de fonksiyonu çok verimli bir şekilde hesaplayabilmemizi gerektirir . Ne yazık ki, hala hesaplamak için polinom bir yol bulamadım .nFalseGuess(n) == TrueGuess(i) == Truei <= nGuessGuess(n)

Bu, çarpışmaya duyarlı dize bölme sorunu olarak bilinir ve Anne Condon, Ján Maňuch ve Chris Thachuk tarafından yayınlanan bir makalede 3-SAT'dan bir azalma ile NP-tam olduğu gösterilmiştir. gen sentezi için oligo tasarımla ilişkisi ( Uluslararası Bilişim ve Kombinatorik Konferansı , 265-275, 2008).

(Gilad Barkan'a (גלעד ברקן) bu tartışmadan haberdar olduğum için çok teşekkürler.)

Bu sorun hakkındaki düşüncelerimi tamamen teorik bir bakış açısıyla paylaşayım ("alt kelime" yerine "faktör" kullandığımı da unutmayın).

Bence burada ele alınan problemin (veya problemlerin) yeterince resmi bir tanımı aşağıdaki gibidir:

W kelimesi verildiğinde u_1, u_2, ..., u_k kelimelerini bulun.

• u_i! = her i için u_j, j 1 <= i <j <= k ve
• u_1 u_2 ... u_k = w

Maksimizasyon varyantı (birçok u_i istiyoruz): maks. K

Minimizasyon varyantı (kısa u_i istiyoruz): maksimize et {| u_i | : 1 <= i <= k}

Bu problemler, ek olarak "çok faktörlü" -varyanttan mı yoksa "kısa faktörler" -varyanttan mı bahsettiğimize göre, k üzerinde daha düşük bir sınır olan (en azından B'yi istiyoruz) faktörler) veya maks. {| u_i | : 1 <= i <= k} (sırasıyla en fazla B uzunluk faktörü istiyoruz). NP sertliği hakkında konuşmak için karar problemleri hakkında konuşmamız gerekir.

"Kısa faktörler" -varyant için SF terimlerini ve "birçok faktör" -varyant için MF terimlerini kullanalım. Özellikle, ve bu gerçekten çok önemli bir nokta, problemler, hiçbir şekilde kısıtlanmamış bazı alfabe üzerinde bir kelime alacak şekilde tanımlanıyor . Sorun versiyonu, sadece girdi kelimelerini devralmamızın bir öncül olduğunu bilmemizdi, örneğin, alfabe {a, b, c, d} farklı bir sorundur! NP-sertlik yok değil otomatik olarak "sabit alfabe" varyant (ikincisi basit olabilir) için "sınırsız" üzerinde taşıyacaktır.

Hem SF hem de MF NP-tam problemlerdir. Bu sırasıyla [1, 1b] ve [2] 'de gösterilmiştir (Gilad'ın daha önce işaret ettiği gibi). Bu tartışmanın başında (belki de) gayrı resmi sorun tanımını doğru anlarsam, bu tartışmanın sorunu tam olarak sorunlu MF'dir. Başlangıçta kelimelerin bazı sabit alfabe ile sınırlı olduğu söylenmez, daha sonra sadece küçük harflerin kullanıldığını varsayabiliriz. Bu, yalnızca sabit alfabe {a, b, c, ..., z} üzerindeki kelimeleri düşündüğümüz anlamına gelirse, bu aslında NP sertliği açısından çok değişecektir.

Daha yakından bakıldığında, SF ve MF'nin karmaşıklığındaki bazı farklılıklar ortaya çıkıyor:

1. kâğıt [1, 1b], alfabeyi ikili bir alfabeye sabitlersek SF'nin NP-tam kaldığını gösterir (daha kesin olarak: a ve b harfleri ve bir B harfi üzerine w kelimesi almak, farklı uzunluk faktörlerinde çarpanlara ayırabilir miyiz? çoğu B?).
2. bildiri [1, 1b], bağlı B = 2'yi sabitlersek SF'nin NP-tam kaldığını gösterir (daha kesin olarak: w kelimesi almak, onu en fazla 2 farklı faktörde çarpanlarına ayırabilir miyiz?).
3. makale [3] hem alfabe hem de bağlı B sabitse, SF'nin polinom zamanda çözülebileceğini gösterir.
4. bildiri [2] MF'nin NP-tamamlanmış olduğunu, ancak sadece alfabe kısıtlanmış veya önceden belirlenmiş değilse ! Özellikle, giriş kelimelerini sadece bazı sabit alfabe üzerinde (pratik ayarlarda olduğu gibi) dikkate alırsak, sorunun NP-tamamlanmış olup olmadığı sorusuna cevap vermez .
5. kağıt [3], giriş sınırları B tekrar bir sabit tarafından üst sınırda ise MF'nin polinom zamanda çözülebileceğini gösterir, yani, problem girdisi bir kelime ve {1, 2, ..., K} 'dan bağlı bir B ise burada K sabit bir sabittir.

Bu sonuç hakkında bazı yorumlar: Wrt (1) ve (2), sezgisel olarak açıktır, eğer alfabe ikili ise, SF'yi problemi zorlaştırmak için, bağlı B'nin de düzeltilemeyeceği açıktır. Tersine, B = 2'yi sabitlemek, zor örnekler üretmek için alfabe boyutunun oldukça büyük olması gerektiği anlamına gelir. Sonuç olarak, (3) oldukça önemsizdir (aslında, [3] biraz daha fazlasını söyler: daha sonra sadece polinom değil, aynı zamanda | w | ^ sadece alfabe boyutuna bağlı bir faktörün 2 katı kadar çözebiliriz ve bağlı B). (5) de zor değildir: Sözümüz B'ye kıyasla uzunsa, o zaman sadece farklı uzunluklardaki faktörlere dilimleyerek istenen faktörleştirmeyi elde edebiliriz. Değilse, sadece B'de üstel olan, bu durumda sabit olduğu varsayılan tüm olasılıkları kaba kuvvet uygulayabiliriz.

Yani elimizdeki resim şudur: SF daha zor görünüyor, çünkü sabit alfabe veya sabit bir B için bile sertliğe sahibiz. Öte yandan, MF sorunu, eğer sabit ise ( bu açıdan SF'den daha kolaydır), karşılık gelen soru ise alfabe boyutu açıktır. Bu nedenle MF, sabit alfabe MF'nin NP-tamamlanmış olduğu ortaya çıksa bile SF'den biraz daha az karmaşıktır. Bununla birlikte, MF'nin sabit alfabe için poli zamanda çözülebileceği gösterilebiliyorsa, MF'nin SF'den çok daha kolay olduğu gösterilmektedir ... çünkü zor olduğu bir durum biraz yapaydır (sınırsız alfabe!) .

Sınırlı alfabe ile MF davasını çözmeye çalışmak için biraz çaba harcadım, ancak o zamandan beri yerleşemedim ve üzerinde çalışmayı bıraktım. Diğer araştırmacıların bunu çözmek için çok uğraştığına inanmıyorum (bu yüzden bu çok zor açık problemlerden biri değil, birçok insan zaten denedi ve başarısız oldu; Bir şekilde yapılabilir olduğunu düşünüyorum). Benim tahminim de sabit alfabe için NP-sert olurdu, ama belki de azalma o kadar karmaşık ki "MF 35 veya daha büyük boyutlu alfabe için zor" veya süper hoş olmayan bir şey elde edersiniz. .

Daha fazla literatürle ilgili olarak, bir kelimeyi w'yi NP-tamamlanmış olan tüm palindromlar olan u_1, u_2, ..., u_k gibi farklı faktörlere bölme problemini dikkate alan makaleyi biliyorum [4].

Gilad'ın işaret ettiği makaleye [5] hızlıca baktım. Yine de farklı bir ortam düşünüyor gibi görünüyor. Bu makalede, yazarlar belirli bir kelimede kaç farklı alt dizinin veya alt sözcüğün bulunabileceği ile ilgili birleştirici soru ile ilgilenmektedir, ancak bunlar üst üste gelebilir. Örneğin, aaabaab 20 farklı alt kelime içerir a, b, aa, ab, ba, bb, aaa, aab, aba, baa, aaab, aaba, abaa, baab, aaaba, aabaa, abaab, aabaab, aaabaa, aaabaab (belki ben yanlış sayılır, ancak fikri anlayabilirsiniz). Bazılarının sadece bir olayı var, baa gibi, bazıları birkaç, aa gibi. Her durumda, soru, birçok farklı faktörü elde etmek için bir şekilde kelimeyi nasıl bölebileceğimiz değildir, çünkü bu, her bir sembolün tam olarak bir faktöre katkıda bulunduğu anlamına gelir.

Bu tür sorunlara pratik çözümler konusunda (bir teorisyen olduğumu unutmayın, bu yüzden bunu tuz tanesi ile alın):

• Bildiğim kadarıyla, yalnızca sabit bir alfabe üzerinde giriş sözcükleri düşünürsek, polinom zamanında MF'yi çözmesini engelleyecek teorik alt sınırlar (NP sertliği gibi) yoktur. Ancak bir uyarı var: Bir poli-zaman algoritması alırsanız, o zaman bu sabit alfabedeki sembollerin sayısında üstel olarak çalışmalıdır (veya bunun bazı işlevlerinde üstel olmalıdır)! Aksi takdirde, sınırsız alfabeler için bir polinom zaman algoritması da olacaktır. Yani, bir teorisyen olarak, sadece sembol sayısı ve bir şekilde MF için bir algoritma geliştirmeye yardımcı olursa, zaman içinde üstel olarak hesaplanabilen algoritmik görevleri arıyordum. Öte yandan, böyle bir algoritmanın mevcut olmaması ve MF'nin sabit alfabe durumunda NP-zor olması muhtemeldir.

• Pratik çözümlerle ilgileniyorsanız, çözümü yaklaşık olarak bulmak faydalı olabilir. Bu nedenle, en kötü durumdaki optimumun sadece yarısı kadar büyük olması garanti edilen faktorizasyonun elde edilmesi çok kötü olmaz.

• Kanıtlanabilir bir tahmin oranı vermeyen, ancak pratik bir ortamda iyi çalışan sezgisel yöntemler de ilginç olurdu.

• Sorunlu örnekleri SAT veya ILP örneklerine dönüştürmek çok zor olmamalı ve daha sonra en uygun çözümleri elde etmek için bir SAT veya ILP Çözücü çalıştırabilirsiniz.

• Kişisel düşüncem, MF'nin sabit alfabe vakasının NP-zor olup olmadığı bilinmese de, sorunun sezgisel çözümlere bakmanın haklı olması için yeterince zor olduğunu gösteren yeterli teorik içgörü var. pratik bir ortamda iyi çalışır.

Kaynakça:

[1] Anne Condon, Ján Manuch, Chris Thachuk: Yaylı bölümlemenin karmaşıklığı. J. Ayrık Algoritmalar 32: 24-43 (2015)

[1b] Anne Condon, Ján Manuch, Chris Thachuk: Bir Çarpışmaya Duyarlı Dize Bölme Sorununun Karmaşıklığı ve Gen Sentezi için Oligo Tasarımı ile İlişkisi. KOKON 2008: 265-275

[2] Henning Fernau, Florin Manea, Robert Mercas, Markus L. Schmid: Değişkenlerle Desen Eşleştirme: Hızlı Algoritmalar ve Yeni Sertlik Sonuçları. STACS 2015: 302-315

[3] Markus L. Schmid: Eşitsiz ve tekrarlayan dizi çarpanlarına hesaplama. Theor. Comput. Sci. 618: 42-51 (2016)

[4] Hideo Bannai, Travis Gagie, Shunsuke Inenaga, Juha Kärkkäinen, Dominik Kempa, Marcin Piatkowski, Shiho Sugimoto: Farklı Palindromik Çarpanlara Ayırma NP-Tamamlandı. Int. J. Bulundu. Comput. Sci. 29 (2): 143-164 (2018)

[5] Abraham Flaxman, Aram Wettroth Harrow, Gregory B. Sorkin: Maksimal Olarak Çok Farklı Alt Özeti ve Alt Dizesi Olan Dizeler. Elektrikli. J. Comb. 11 (1) (2004)

İşte bir çözüm ama gerçekten hızlı patlıyor ve verimli bir çözümün yakınında hiçbir yerde değil. İlk önce dizeyi, sipariş için endişe duymadan benzersiz bir alt dize listesine böler, ardından bu alt dizeleri orijinal dizeye geri monte etmek için itertools.permutation kullanmaya çalışır ve orijinal dizeyle eşleşip eşleşmediğini görmek için her bir dizgiyi test eder.

import itertools as it

def splitter(seq):                                                             
    temp = [seq]
    for x in range(1, len(seq)):
        print(seq[:x], seq[x:])
        temp.append(seq[:x])
        temp.append(seq[x:])
    return temp

if __name__ == "__main__":
    test = input("Enter a string: ")
    temp = splitter(test)
    copy = temp[::]
    condition = True
    for x in temp:
        if len(x) > 1:
            copy.extend(splitter(x))
    copy = sorted(list(set(copy)))
    print(copy)
    count = []
    for x in range(len(test)):
        item = it.permutations(copy, x)
        try:
            while True:
                temp = next(item)
                if "".join(list(temp)) == test:
                    if len(temp) == len(set(temp)):
                        count.append((len(temp), temp))
        except StopIteration:
            print('next permutation begin iteration')
            continue
    print(f"All unique splits: {count}")
    print(f"Longest unique split : {max(count)[0]}")

İlk test için şunu elde ederiz:

All unique splits: [(1, ('aababaa',)), (2, ('a', 'ababaa')), (2, ('aa', 'babaa')), (2, 
('aab', 'abaa')), (2, ('aaba', 'baa')), (2, ('aabab', 'aa')), (2, ('aababa', 'a')), (3, 
('a', 'ab', 'abaa')), (3, ('a', 'aba', 'baa')), (3, ('a', 'abab', 'aa')), (3, ('aa', 'b',
 'abaa')), (3, ('aa', 'ba', 'baa')), (3, ('aa', 'baba', 'a')), (3, ('aab', 'a', 'baa')),
 (3, ('aab', 'ab', 'aa')), (3, ('aab', 'aba', 'a')), (3, ('aaba', 'b', 'aa')), (3,
 ('aaba', 'ba', 'a')), (4, ('a', 'aba', 'b', 'aa')), (4, ('aa', 'b', 'a', 'baa')), (4,
 ('aa', 'b', 'aba', 'a')), (4, ('aab', 'a', 'b', 'aa'))]
Longest unique split : 4

Belki bu bir şekilde optimize edilebilir, ancak bu makinede birkaç saniye sürer.

Bu sorunu denedim ve düşündüm ya da belirli bir dizinde bölümleme olup olmadığını düşündüm. Bu fonksiyon özyinelemeli ve endeksine her endeks 1. Dont bölüm 2 şubesi yaratır Yani ben endeksi i de 2. Partition.

Bir seti doldurduğum ve sonra setin boyutunu döndürdüğüm bölüm

def max(a,b):
    if a>b: return a
    return b



def keep(last, current, inp, map):
    # print last
    # print current
    # print map

    if len(inp) == 2 :
        if inp[0]==inp[1]: return 1
        return 2

    if current >= len(inp):
        return len(map)
    // This is when we are at the start of the string. 
    // In this case we can only do one thing not partition and thus take the entire string as a possible string.

    if current == last :
        map11 = map.copy()
        map11.add(inp[current:])
        return keep(last, current + 1, inp, map11)

    map1 = map.copy();
    if current != (len(inp)-1):
        map1.add(inp[last:current])

    map2 = map.copy()

    return max(keep(last,current+1,inp, map2), keep(current, current+1, inp, map1))

print keep(0,0,"121", set([]))
print keep(0,0,"aaaaaaa", set([]))
print keep(0,0,"aba", set([]))
print keep(0,0,"aababaa", set([]))
print keep(0,0,"21", set([]))
print keep(0,0,"22", set([]))

https://onlinegdb.com/HJynWw-iH

Şimdiye kadar geçerli yoldaki benzersiz dizeleri izlemek için ikinci bir parametre olarak set ile özyinelemeli bir işlev kullanabilirsiniz. Her özyineleme için, tüm dizinleri artı 1 dizesini olası bir aday dizeye bölmek için yineleyin ve aday dizesi henüz kümede değilse, kalan dizeyle ve kümeye eklenen adayla özyinelemeli bir çağrı yapın kalan dizeden maksimum sayıda benzersiz alt dize elde etmek için, buna 1 ekleyin ve yinelemelerden en fazla maksimum alt dizeyi döndürün. Verilen dize boşsa veya tüm aday dizeler zaten kümede bulunuyorsa 0 değerini döndürün:

def max_unique_substrings(s, seen=()):
    maximum = 0
    for i in range(1, len(s) + 1):
        candidate = s[:i]
        if candidate not in seen:
            maximum = max(maximum, 1 + max_unique_substrings(s[i:], {candidate, *seen}))
    return maximum

Demo: https://repl.it/@blhsing/PriceyScalySphere

Python 3.8'de, yukarıdaki mantık, maxbir atama ifadesi ile "görülen" adayları filtreleyen bir üretici ifadesiyle işleve yapılan bir çağrı ile de yazılabilir :

def max_unique_substrings(s, seen=()):
    return max((1 + max_unique_substrings(s[i:], {candidate, *seen}) for i in range(1, len(s) + 1) if (candidate := s[:i]) not in seen), default=0)

İşte grafik teorisi tabanlı bir cevap.

Modelleme
Bu sorun boyutta bir grafik üzerinde maksimum bağımsız ayar sorunu olarak modellenebilir O(n²)aşağıdaki gibidir:
Let w = c_1, ..., c_ngiriş dize.
Izin G = (V,E)bir yönsüz grafiği olmak, yerleşik olarak aşağıdaki gibidir:
V = { (a, b) such that a,b in [1, n], a <= b }. Biz boyutu olduğunu görebilirsiniz Volduğu n(n-1)/2her köşe bir alt dize temsil eder, w.
Daha sonra, köşelerin her çift için (a1, b1)ve (a2, b2)biz kenar oluşturmak ((a1, b1), (a2, b2))IFF
, (i) [a1, b1]kesiştiği [a2, b2]veya
(ii) ' c_a1...c_b1 = c_a2...c_b2.
Aksi takdirde, (i) temsil ettikleri alt diziler üst üste biniyorsa wveya (ii) iki alt dizgiye eşitse iki köşe arasında bir kenar oluştururuz .

Bir neden Sonra görebilirsiniz maksimum bağımsız küme ait Gsorunumuza cevap verir.

Karmaşıklık
Genel durumda, maksimum bağımsız küme (MIS) problemi NP-zordur, O(1.1996^n)polinom uzayda ve zaman içinde karmaşıklığı vardır [Xiao, NamaGoshi (2017)] .
İlk başta ortaya çıkan grafiğin, o zamandan beri MIS probleminin bu grafik sınıfında lineer zamanda çözülebileceği çok güzel olurdu olan bir kodal grafik (indüklenmiş uzunluk döngüsü> 3) olacağını düşündüm.
Ama hızlı bir şekilde fark ettim ki, durum böyle değil, 5 ve daha fazla uzunluktaki indüklenmiş döngülerin olduğu örnekleri bulmak oldukça kolaydır.
Aslında, ortaya çıkan grafik genellikle aradığımız ve MIS probleminin karmaşıklığını polinom olana indirgeyen herhangi bir 'hoş' özellik sergilemez.
Bu, sorunun karmaşıklığı üzerinde sadece bir üst sınırdır, çünkü polinom zaman azalması sadece bir yöne gider (bu sorunu MIS problemine indirebiliriz, ancak en azından önemsiz değil). Sonuçta bu sorunu O(1.1996^(n(n-1)/2))en kötü durumda çözüyoruz.
Ne yazık ki, bunun P'de olduğunu veya NP-tam veya NP-sert olduğunu kanıtlayamadım. Kesin olan bir şey, sorunun NP'de olması, ama sanırım bu herkes için bir sürpriz değil.

Uygulama
Bu problemin YBS sorununa indirgenmesinin avantajı YBS, çeşitli uygulamaların bulunabileceği klasik bir problemdir ve YBS probleminin de kolayca ILP olarak yazılmasıdır.
İşte MIS probleminin bir ILP formülasyonu:

Objective function 
maximize sum(X[i], i in 1..n)
Constraints:
for all i in 1..n, X[i] in {0, 1}
for all edge (i, j), X[i] + X[j] <= 1

Benim düşünceme göre, bu sorunu çözmenin en etkili yolu olmalı (bu modellemeyi MIS problemi olarak kullanmak), çünkü ILP çözücü, özellikle büyük örneklerde inanılmaz derecede verimlidir.

Bu Python3 ve GLPK çözücü kullanarak yaptığım bir uygulamadır . Test etmek için, Cplex dosya formatıyla uyumlu bir LP çözücüsüne ihtiyacınız vardır.

from itertools import combinations

def edges_from_string(w):
    # build vertices
    vertices = set((a, b) for b in range(len(w)) for a in range(b+1))
    # build edges
    edges = {(a, b): set() for (a, b) in vertices}
    for (a1, b1), (a2, b2) in combinations(edges, 2):
        # case: substrings overlap
        if a1 <= a2 <= b1:
            edges[(a1, b1)].add((a2, b2))
        if a2 <= a1 <= b2:
            edges[(a2, b2)].add((a1, b1))
        # case: equal substrings
        if w[a1:b1+1] == w[a2:b2+1]:
            if a1 < a2:
                edges[(a1, b1)].add((a2, b2))
            else:
                edges[(a2, b2)].add((a1, b1))
    return edges

def write_LP_from_edges(edges, filename):
    with open(filename, 'w') as LP_file:
        LP_file.write('Maximize Z: ')
        LP_file.write("\n".join([
            "+X%s_%s" % (a, b)
            for (a, b) in edges
        ]) + '\n')
        LP_file.write('\nsubject to \n')
        for (a1, b1) in edges:
            for (a2, b2) in edges[(a1, b1)]:
                LP_file.write(
                    "+X%s_%s + X%s_%s <= 1\n" %
                    (a1, b1, a2, b2)
                )
        LP_file.write('\nbinary\n')
        LP_file.write("\n".join([
            "X%s_%s" % (a, b)
            for (a, b) in edges.keys()
        ]))
        LP_file.write('\nend\n')
write_LP_from_edges(edges_from_string('aababaa'), 'LP_file_1')
write_LP_from_edges(edges_from_string('kzshidfiouzh'), 'LP_file_2')

Daha sonra bunları çözebilir glpsolkomutu: (benim laptop 0.02 sn) hızla çözüldü, ancak alır beklendiği gibi şeyler olsun dize boyutu büyüdükçe (çok) daha sert .... Bu program sadece sayısal değeri verir (ve Bununla birlikte, optimal bölüm ve karşılık gelen alt dizeler , benzer bir uygulama ile, pyomo gibi bir LP çözücü / python arayüzü kullanılarak bulunabilir.
glpsol --lp LP_file_1
aababaa

Zaman ve bellek
aababaa : 0.02 saniye, 0.4 MB, değer: 4
kzshidfiouzh: 1.4 saniye, 3.8 MB, değer: 10
aababababbababab: 60.2 saniye, 31.5 MB, değer: 8
kzshidfiouzhsdjfyu: 207.5 saniye, 55.7 MB, değer: 14
LP çözücünün de sunduğunu unutmayın çözeltideki mevcut alt ve üst sınırlar, bu nedenle son örnek için, gerçek çözümü bir dakika sonra bir alt sınır olarak alabilirim.

Diğer cevabım yakından ilgiliydi, ancak tam olarak bu soruna karşılık gelmedi, en büyük eşitlik içermeyen dize çarpanlarına ayırmanın bulunmasının, bağlı faktör uzunluğuna sahip herhangi bir eşitliksiz çarpanlara ayırma olup olmadığından daha farklı bir karmaşıklık sınıfına sahip olup olmadığının belirsiz olması atıfta bulunulan bildiri tarafından ele alınması).

Makalede, Değişkenlerle örüntü eşleştirme: Hızlı algoritmalar ve yeni sertlik sonuçları (Henning Fernau, Florin Manea, Robert Mercaş ve Markus L. Schmid, Proc. Uluslararası Bilişimde Bildiriler (LIPIcs) , sayfa 302–315, 2015), yazarlar, belirli bir sayı kve bir kelime için w, farklı faktörlere wçarpanlara ayrılabilir hale getirilip getirilemeyeceğine karar vermenin NP-eksiksiz olduğunu göstermektedir k.

Biz templatetypedef en düşünürsek yorumunu , ima biz içine dize bölünmüş Eğer edildiğinde o zaman cevap böyle bir algoritma kullanabilirsiniz sınırsız, büyük eşitlik içermeyen factorisation bir polinom zaman çözümü olabileceğini kayrı faktörlerin (altdizgelerin) eğer sadece gözlemleyerek kolduğunu Zaten bildiğimiz maksimumdan daha az.

Ancak Schmid (2016), "alfabe düzeltildiyse MaxEFF-s'nin NP-tam olarak kalması hala açık bir sorundur." (Eşitsiz ve tekrarlayan dizi çarpanlarına hesaplama, Teorik Bilgisayar Bilimleri Cilt 618 , 7 Mart 2016, Sayfa 42-51)

Yine de Maksimum Eşitsiz Serbest Faktorizasyon Boyutu (MaxEFF-s) hala parametrelendirilir ve şu şekilde tanımlanır:

Örnek: Bir kelime wve sayı m, 1 ≤ m ≤ |w|.

Soru: Eşitsiz faktorizasyon p değeri wvar s(p) ≥ mmı? ( s(p)çarpanlara ayırma boyutudur.)