โครงสร้างข้อมูลหรืออัลกอริทึมสำหรับค้นหาความแตกต่างระหว่างสตริงได้อย่างรวดเร็ว

ฉันมีอาร์เรย์ของ 100,000 สตริงทั้งหมดของความยาวk$k$ฉันต้องการเปรียบเทียบแต่ละสตริงกับสตริงอื่น ๆ เพื่อดูว่ามีสองสตริงที่แตกต่างกัน 1 อักขระหรือไม่ ตอนนี้ที่ผมเพิ่มแต่ละสายไปยังอาร์เรย์ที่ฉันตรวจสอบกับทุกสตริงแล้วในอาร์เรย์ซึ่งมีความซับซ้อนเวลาของการk$\frac{n(n-1)}{2} k$

มีโครงสร้างข้อมูลหรืออัลกอริทึมที่สามารถเปรียบเทียบสตริงได้เร็วกว่าสิ่งที่ฉันกำลังทำอยู่หรือไม่?

ข้อมูลเพิ่มเติมบางส่วน:

• หัวข้อการสั่งซื้อ: abcdeและxbcdeแตกต่างกัน 1 ตัวอักษรในขณะที่abcdeและedcbaแตกต่างกัน 4 ตัว

• สำหรับแต่ละคู่ของสตริงที่แตกต่างกันโดยตัวละครตัวหนึ่งฉันจะลบหนึ่งในสายเหล่านั้นออกจากอาร์เรย์

• ตอนนี้ฉันกำลังมองหาสตริงที่แตกต่างกันเพียง 1 ตัวอักษร แต่มันจะดีถ้าความแตกต่างของตัวละคร 1 ตัวนั้นสามารถเพิ่มขึ้นได้เช่น 2, 3 หรือ 4 ตัวอักษร อย่างไรก็ตามในกรณีนี้ฉันคิดว่าประสิทธิภาพสำคัญกว่าความสามารถในการเพิ่มขีดจำกัดความแตกต่างของตัวละคร

• $k$มักจะอยู่ในช่วง 20-40

เป็นไปได้ที่จะบรรลุเวลาทำงานที่เลวร้ายที่สุด$O(nk \log k)$

มาเริ่มกันง่ายๆ หากคุณสนใจโซลูชันที่ใช้งานง่ายซึ่งจะมีประสิทธิภาพในอินพุตจำนวนมาก แต่ไม่ใช่ทั้งหมดนี่คือโซลูชันที่ใช้งานง่ายและใช้งานได้ง่ายที่ใช้งานได้จริงในหลายสถานการณ์ มันกลับไปใช้เวลากำลังสองในกรณีที่เลวร้ายที่สุดแม้ว่า

ใช้สตริงแต่ละเส้นและเก็บไว้ใน hashtable โดยพิมพ์ครึ่งแรกของสตริง จากนั้นทำซ้ำผ่าน hashtable buckets สำหรับแต่ละคู่ของสตริงในที่ฝากข้อมูลเดียวกันตรวจสอบว่าพวกเขาแตกต่างกันใน 1 อักขระ (เช่นตรวจสอบว่าครึ่งหลังของพวกเขาแตกต่างกันใน 1 อักขระ)

จากนั้นใช้แต่ละสายและเก็บไว้ใน Hashtable ครั้งนี้คีย์ในสองครึ่งหนึ่งของสตริง ตรวจสอบสตริงแต่ละคู่อีกครั้งในที่ฝากข้อมูลเดียวกัน

สมมติว่าสตริงเป็นอย่างดีกระจายเวลาการทำงานมีแนวโน้มที่จะเกี่ยวกับ ) ยิ่งไปกว่านั้นหากมีคู่ของสตริงที่แตกต่างกัน 1 ตัวอักษรจะพบได้ในระหว่างหนึ่งในสองรอบที่ผ่านไป (เนื่องจากพวกเขาแตกต่างกันเพียง 1 ตัวอักษรอักขระที่แตกต่างจะต้องอยู่ในครึ่งแรกหรือครึ่งหลังของสตริง ดังนั้นครึ่งหลังของสตริงต้องเหมือนกัน) อย่างไรก็ตามในกรณีที่เลวร้ายที่สุด (เช่นถ้าสตริงทั้งหมดเริ่มต้นหรือสิ้นสุดด้วยอักขระk / 2เดียวกัน)เวลาในการทำงานจะลดลงเป็นO ( n 2 k )ดังนั้นเวลาในการทำงานที่แย่ที่สุดของกรณีนี้จึงไม่ได้รับการพัฒนาจากกำลังดุร้าย .$O(nk)$$k/2$$O(n^2 k)$

เป็นการเพิ่มประสิทธิภาพประสิทธิภาพหากที่ฝากข้อมูลใด ๆ มีสตริงมากเกินไปคุณสามารถทำซ้ำกระบวนการเดียวกันซ้ำ ๆ เพื่อค้นหาคู่ที่แตกต่างกันตามตัวละครตัวหนึ่ง ภาวนา recursive จะอยู่ในสายของความยาว 2$k/2$

หากคุณสนใจเวลาที่ใช้งานกรณีที่แย่ที่สุด:

ด้วยการเพิ่มประสิทธิภาพการปฏิบัติดังกล่าวข้างต้นผมเชื่อว่าเลวร้ายที่สุดกรณีเวลาการทำงานเป็น )$O(nk \log k)$

โซลูชันของฉันคล้ายกับ j_random_hacker แต่ใช้ชุดแฮชเพียงชุดเดียว

ฉันจะสร้างชุดแฮชของสตริง สำหรับแต่ละสตริงในอินพุตให้เพิ่มชุดสตริงในแต่ละสตริงเหล่านี้แทนที่หนึ่งในตัวอักษรด้วยอักขระพิเศษซึ่งไม่พบในสตริงใด ๆ ในขณะที่คุณเพิ่มพวกเขาตรวจสอบว่าพวกเขาไม่ได้อยู่ในชุด หากเป็นเช่นนั้นคุณจะมีสองสายที่แตกต่างกันเพียงตัวอักษร (อย่างมาก)$k$

ตัวอย่างที่มีสตริง 'abc', 'adc'

สำหรับ abc เราเพิ่ม '* bc', 'a * c' และ 'ab *'

สำหรับ adc เราเพิ่ม '* dc', 'a * c' และ 'ad *'

เมื่อเราเพิ่ม 'a * c' ครั้งที่สองเราสังเกตเห็นว่ามันมีอยู่แล้วในชุดดังนั้นเราจึงรู้ว่ามีสองสายที่แตกต่างกันเพียงตัวอักษรเดียว

รวมเวลาการทำงานของอัลกอริทึมนี้คือ ) นี่เป็นเพราะเราสร้างสตริงkใหม่สำหรับสตริงnทั้งหมดในอินพุต สำหรับแต่ละสายที่เราต้องคำนวณกัญชาซึ่งปกติจะใช้เวลาO ( k )เวลา$O(n*k^2)$$k$$n$$O(k)$

การจัดเก็บสตริงทั้งหมดจะใช้เวลาพื้นที่$O(n*k^2)$

การปรับปรุงเพิ่มเติม

เราสามารถปรับปรุงอัลกอริธึมเพิ่มเติมโดยไม่เก็บสตริงที่ถูกแก้ไขโดยตรง แต่เก็บวัตถุที่มีการอ้างอิงถึงสตริงเดิมและดัชนีของตัวละครที่ถูกหลอกลวง วิธีนี้เราไม่จำเป็นต้องสร้างสตริงทั้งหมดและเราต้องการเพียงพื้นที่เพื่อเก็บวัตถุทั้งหมด$O(n*k)$

คุณจะต้องใช้ฟังก์ชันแฮชที่กำหนดเองสำหรับวัตถุ เราสามารถใช้การใช้ Java เป็นตัวอย่างให้ดูเอกสารจาวา java hashCode คูณค่ายูนิโค้ดของอักขระแต่ละตัวด้วย (ด้วยkความยาวสตริงและiดัชนีแบบอิงฐานเดียวของอักขระโปรดทราบว่าแต่ละสตริงที่เปลี่ยนแปลงจะแตกต่างกันโดยอักขระหนึ่งตัวจากต้นฉบับเท่านั้นเราสามารถคำนวณได้อย่างง่ายดาย การมีส่วนร่วมของตัวละครนั้นในรหัสแฮชเราสามารถลบมันและเพิ่มตัวละครที่สวมหน้ากากแทนได้ซึ่งจะใช้เวลาO ( 1 )ในการคำนวณสิ่งนี้ช่วยให้เราสามารถนำเวลาการทำงานทั้งหมดลงไปที่O ( $31^{k-i}$$k$$i$$O(1)$$O(n*k)$

ฉันจะทำให้ hashtables H 1 , … , H k , ซึ่งแต่ละคนมีสตริง( k - 1 ) - ความยาวเป็นกุญแจสำคัญและรายการของตัวเลข (สตริง ID) เป็นค่า hashtable H iจะมีสตริงทั้งหมดที่ถูกประมวลผลจนถึงตอนนี้แต่ด้วยอักขระที่ตำแหน่งที่ฉันลบไป ตัวอย่างเช่นถ้าk = 6ดังนั้นH 3 [ A B D E F ]จะมีรายการของสตริงทั้งหมดที่เห็นจนถึงที่มีรูปแบบ$k$$H_1, \dots, H_k$$(k-1)$$H_i$$i$$k=6$$H_3[ABDEF]$โดยที่ ⋅หมายถึง "ตัวละครใด ๆ " จากนั้นประมวลผลสตริงอินพุต j -th s j :$AB\cdot DEF$$\cdot$$j$$s_j$

1. สำหรับแต่ละในช่วง 1 ถึงk : $i$$k$
   • สตริงแบบฟอร์มโดยการลบผมตัวละครจาก -th s J$s_j'$$i$$s_j$
   • เงยหน้าขึ้นมอง ] ทุก ID สตริงที่นี่ระบุสตริงเดิมที่อาจเท่ากับsหรือแตกต่างที่ตำแหน่ง$H_i[s_j']$$s$เท่านั้น เอาท์พุทเหล่านี้เป็นแมตช์สำหรับสตริง s J (หากคุณต้องการแยกรายการที่ซ้ำกันให้ทำประเภทค่าของคู่ hashtables (ID สตริง, อักขระที่ถูกลบ) เพื่อให้คุณสามารถทดสอบสำหรับผู้ที่มีตัวอักษรที่ถูกลบเหมือนที่เราเพิ่งลบจาก s j )$i$$s_j$$s_j$
   • ใส่ลงในH iเพื่อใช้แบบสอบถามในอนาคต$j$$H_i$

หากเราเก็บคีย์แฮชแต่ละคีย์ไว้อย่างชัดเจนเราจะต้องใช้พื้นที่และมีความซับซ้อนของเวลาอย่างน้อยนั้น แต่ตามที่อธิบายไว้โดย Simon Prinsเป็นไปได้ที่จะแสดงชุดของการดัดแปลงสตริง (ในกรณีของเขาอธิบายว่าการเปลี่ยนอักขระเดียวเป็นของฉันเป็นการลบ) โดยปริยายในลักษณะที่k hash keys สำหรับสตริงเฉพาะต้องการเพียงพื้นที่ O ( k )นำไปสู่พื้นที่โดยรวมO ( n k )และเปิดความเป็นไปได้ของO ( n k $O(nk^2)$*$k$$O(k)$$O(nk)$$O(nk)$เวลาด้วย เพื่อให้เกิดความซับซ้อนในเวลานี้เราจำเป็นต้องมีวิธีการคำนวณแฮชสำหรับตัวแปรทั้งหมดของความยาวkในเวลาO ( k ) : ตัวอย่างนี้สามารถทำได้โดยใช้แฮชพหุนามตามที่แนะนำโดย DW (และนี่คือ น่าจะดีกว่า XOR เพียงการลบตัวอักษรที่มีแฮชสำหรับสตริงเดิม)$k$$k$$O(k)$

เคล็ดลับการแสดงโดยนัยของ Simon Prins ก็หมายความว่า "การลบ" ของตัวละครแต่ละตัวนั้นไม่ได้ทำจริง ๆ ดังนั้นเราจึงสามารถใช้การแทนสตริงตามปกติโดยไม่ต้องมีการปรับประสิทธิภาพ

นี่เป็นวิธีการแฮชที่แข็งแกร่งกว่าวิธีการโพลิโนเมียล - แฮช แรกสร้างจำนวนเต็มบวกสุ่มr 1 .. kที่มี coprime ขนาด Hashtable M คือ0 ≤ r ฉัน < M จากนั้นกัญชาแต่ละสายx 1 .. kไป( Σ k ฉัน= 1 x ฉันr ฉัน ) mod M นอกจากนี้เกือบไม่มีอะไรเป็นปรปักษ์สามารถทำได้เพื่อทำให้เกิดการชนกันไม่สม่ำเสมอมากเนื่องจากคุณสร้างR 1 .. kในเวลาทำงานและเพื่อให้เป็น$k$$r_{1..k}$$M$$0 \le r_i < M$$x_{1..k}$$(\sum_{i=1}^k x_i r_i ) \bmod M$$r_{1..k}$$k$เพิ่มความน่าจะเป็นสูงสุดของการปะทะกันของคู่ใดก็ตามของสตริงที่แตกต่างกันไปอย่างรวดเร็วเพื่อ M นอกจากนี้ยังเห็นได้ชัดว่าวิธีการคำนวณในเวลาO ( k )แฮชที่เป็นไปได้ทั้งหมดสำหรับแต่ละสตริงที่เปลี่ยนไปหนึ่งอักขระ$1/M$$O(k)$

หากคุณต้องการรับประกันการ hashing อย่างสม่ำเสมอคุณสามารถสร้างหมายเลขธรรมชาติสุ่มหนึ่งน้อยกว่าMสำหรับแต่ละคู่( i , c )สำหรับiจาก1ถึงkและสำหรับอักขระแต่ละตัวcและ hash แต่ละสตริงx 1 .. kถึง( ∑ k i = 1 r ( i , x i ))จากนั้นความน่าจะเป็นที่จะเกิดการชนกันของสายอักขระคู่ใด ๆ$r(i,c)$$M$$(i,c)$$i$$1$$k$$c$$x_{1..k}$$(\sum_{i=1}^k r(i,x_i) ) \bmod M$ M วิธีนี้จะดีกว่าถ้าชุดอักขระของคุณค่อนข้างเล็กเมื่อเทียบกับ$1/M$$n$ n

อัลกอริทึมมากมายที่โพสต์ที่นี่ใช้พื้นที่บนโต๊ะแฮชค่อนข้างน้อย นี่คือที่เก็บข้อมูลเสริมO ( ( n lg n ) ⋅ k 2$O(1)$$O((n \lg n) \cdot k^2)$อัลกอริทึมแบบง่าย

เคล็ดลับคือการใช้ซึ่งเป็นตัวเปรียบเทียบระหว่างสองค่าและขที่ผลตอบแทนจริงถ้า< B (lexicographically) ขณะที่ละเลยkตัวอักษร TH จากนั้นอัลกอริทึมมีดังนี้$C_k(a, b)$$a$$b$$a < b$$k$

ขั้นแรกให้เรียงลำดับสตริงอย่างสม่ำเสมอและทำการสแกนเชิงเส้นเพื่อลบรายการที่ซ้ำกัน

จากนั้นสำหรับแต่ละ :$k$

1. เรียงลำดับสตริงด้วยเป็นตัวเปรียบเทียบ$C_k$

2. เงื่อนไขที่แตกต่างเฉพาะในขณะนี้อยู่ติดกันและสามารถตรวจพบในการสแกนเชิงเส้น$k$

สองสายความยาวkแตกต่างกันในตัวละครตัวหนึ่งแบ่งปันคำนำหน้าของความยาวLและคำต่อท้ายของความยาวเมตรเช่นที่k = L + m + 1

คำตอบโดยไซมอน Prins encodes นี้โดยการจัดเก็บทุกคำนำหน้า / ต่อท้ายอยู่รวมกันอย่างชัดเจนคือabcจะกลายเป็น*bc, และa*c ab*นั่นคือ k = 3, l = 0,1,2 และ m = 2,1,0

เมื่อ valarMorghulis ชี้ให้เห็นคุณสามารถจัดระเบียบคำต่าง ๆ ในแผนผังคำนำหน้า นอกจากนี้ยังมีต้นไม้ต่อท้ายที่คล้ายกันมาก มันค่อนข้างง่ายที่จะเพิ่มต้นไม้ด้วยจำนวนของโหนดใบด้านล่างแต่ละคำนำหน้าหรือคำต่อท้าย; สามารถอัปเดตเป็น O (k) เมื่อแทรกคำใหม่

เหตุผลที่คุณต้องการนับพี่น้องเหล่านี้คือเพื่อให้คุณรู้คำใหม่ไม่ว่าคุณต้องการที่จะระบุสตริงทั้งหมดด้วยคำนำหน้าเดียวกันหรือว่าจะระบุสตริงทั้งหมดด้วยคำต่อท้ายเดียวกัน เช่นสำหรับ "abc" เป็นอินพุตคำนำหน้าที่เป็นไปได้คือ "", "a" และ "ab" ในขณะที่คำต่อท้ายที่สอดคล้องกันคือ "bc", "c" และ "" ตามที่เห็นได้ชัดสำหรับคำต่อท้ายสั้น ๆ ดีกว่าที่จะแจกแจงพี่น้องในต้นไม้คำนำหน้าและในทางกลับกัน

@einpoklum ชี้ให้เห็นว่าเป็นไปได้ที่สตริงทั้งหมดจะมีค่าk / 2เหมือนกันคำนำหน้าเหมือนกัน นั่นไม่ใช่ปัญหาสำหรับวิธีนี้ ต้นไม้คำนำหน้าจะเป็นเชิงเส้นสูงถึงความลึก k / 2 โดยแต่ละโหนดถึงความลึก k / 2 เป็นบรรพบุรุษของโหนดใบ 100.000 เป็นผลให้ต้นไม้ต่อท้ายจะใช้ความลึกสูงสุด (k / 2-1) ซึ่งเป็นสิ่งที่ดีเพราะสตริงจะต้องแตกต่างกันในส่วนต่อท้ายของพวกเขาเนื่องจากพวกเขาแบ่งปันคำนำหน้า

[แก้ไข] ในฐานะของการเพิ่มประสิทธิภาพเมื่อคุณได้กำหนดคำนำหน้าสั้น ๆ ที่ไม่ซ้ำกันของสตริงคุณจะรู้ว่าหากมีอักขระที่แตกต่างกันหนึ่งตัวจะต้องเป็นอักขระตัวสุดท้ายของคำนำหน้าและคุณจะพบสิ่งที่ใกล้เคียงกันเมื่อ ตรวจสอบคำนำหน้าที่สั้นกว่า ดังนั้นถ้า "abcde" มีคำนำหน้าสั้นที่สุดที่ไม่ซ้ำกัน "abc" นั่นหมายความว่ามีสตริงอื่น ๆ ที่ขึ้นต้นด้วย "ab?" แต่ไม่ใช่ด้วย "abc" นั่นคือถ้าพวกเขาต่างกันในตัวละครเดียวนั่นก็คือตัวละครตัวที่สาม คุณไม่จำเป็นต้องตรวจสอบ "abc? e" อีกต่อไป

โดยตรรกะเดียวกันถ้าคุณจะพบว่า "cde" เป็นคำต่อท้ายที่สั้นที่สุดที่ไม่ซ้ำกันแล้วคุณรู้ว่าคุณต้องตรวจสอบเฉพาะคำนำหน้าความยาว 2 "ab" และไม่นำหน้า 1 หรือ 3 ความยาว

โปรดทราบว่าวิธีนี้ใช้ได้เฉพาะกับความแตกต่างของตัวละครหนึ่งตัวเท่านั้นและไม่ได้สรุปถึงความแตกต่างของตัวละคร 2 ตัวโดยอาศัยหนึ่งตัวละครหนึ่งตัวซึ่งเป็นการแยกระหว่างคำนำหน้าเหมือนกันและคำต่อท้ายที่เหมือนกัน

การจัดเก็บสตริงในที่เก็บข้อมูลเป็นวิธีที่ดี (มีคำตอบที่แตกต่างกันอยู่แล้วซึ่งสรุปไว้นี้)

ทางเลือกอื่นอาจเป็นการจัดเก็บสตริงในรายการที่เรียงลำดับ เคล็ดลับคือการเรียงลำดับโดยขั้นตอนวิธี hashing ท้องที่ที่มีความอ่อนไหว นี่เป็นอัลกอริธึมการแฮชซึ่งให้ผลลัพธ์ที่คล้ายกันเมื่ออินพุตคล้ายกัน [1]

ทุกครั้งที่คุณต้องการตรวจสอบสตริงคุณสามารถคำนวณแฮชและค้นหาตำแหน่งของแฮชนั้นในรายการที่เรียงลำดับของคุณ (ใช้สำหรับอาร์เรย์หรือO ( n )สำหรับรายการที่เชื่อมโยง) หากคุณพบว่าเพื่อนบ้าน (พิจารณาเพื่อนบ้านที่ใกล้เคียงทั้งหมดไม่เพียง แต่ผู้ที่มีดัชนี +/- 1) ของตำแหน่งนั้นจะคล้ายกัน (ปิดโดยตัวอักษรหนึ่งตัว) ที่คุณพบคู่ที่ตรงกัน หากไม่มีสตริงที่คล้ายกันคุณสามารถแทรกสตริงใหม่ที่ตำแหน่งที่คุณพบ (ซึ่งใช้O ( 1 )สำหรับรายการที่เชื่อมโยงและO ( n )สำหรับอาร์เรย์)$O(log(n))$$O(n)$$O(1)$$O(n)$

อัลกอริทึมการแฮชที่มีความอ่อนไหวต่อพื้นที่ที่เป็นไปได้อย่างหนึ่งคือNilsimsa (ด้วยการใช้งานโอเพนซอร์ซที่มีให้ในตัวอย่างในไพ ธ อน )

[1]: โปรดทราบว่าบ่อยครั้งที่อัลกอริธึมการแฮชเช่น SHA1 ได้รับการออกแบบมาสำหรับตรงกันข้าม: ผลิตแฮชที่แตกต่างกันอย่างมากสำหรับสิ่งที่คล้ายกัน แต่ไม่เท่ากับอินพุต

คำแถลงการณ์ปฏิเสธความรับผิดชอบ: ตามจริงแล้วฉันจะใช้โซลูชันฝากข้อมูลแบบซ้อนซ้อน / ทรีที่จัดเรียงแบบต้นไม้เป็นการส่วนตัวสำหรับแอปพลิเคชันการผลิต อย่างไรก็ตามแนวคิดการเรียงลำดับทำให้ฉันเป็นทางเลือกที่น่าสนใจ โปรดทราบว่าอัลกอริทึมนี้ขึ้นอยู่กับอัลกอริทึมแฮชที่เลือก Nilsimsa เป็นอัลกอริทึมที่ฉันพบ - มีอีกหลายอย่าง (ตัวอย่างเช่น TLSH, Ssdeep และ Sdhash) ฉันไม่ได้ตรวจสอบว่า Nilsimsa ทำงานกับอัลกอริทึมที่ระบุไว้ของฉัน

One could achieve the solution in $O(nk+ n^2)$ time and $O(nk)$ space using enhanced suffix arrays (Suffix array along with the LCP array) that allows constant time LCP (Longest Common Prefix) query (i.e. Given two indices of a string, what is the length of the longest prefix of the suffixes starting at those indices). Here, we could take advantage of the fact that all strings are of equal length. Specifically,

1. Build the enhanced suffix array of all the $n$ strings concatenated together. Let $X = x_1.x_2.x_3 .... x_n$ where $x_i, \forall 1 \le i \le n$ is a string in the collection. Build the suffix array and LCP array for $X$.

2. $x_i$$(i-1)k$$x_i$$x_j$$j<i$$x_j$$x_i = x_j$$x_i[p] \ne x_j[p]$); in this case take another LCP starting at the corresponding positions following the mismatch. If the second LCP goes beyond the end of $x_j$ then $x_i$ and $x_j$ differ by only one character; otherwise there are more than one mismatches.

   for (i=2; i<= n; ++i){
       i_pos = (i-1)k;
       for (j=1; j < i; ++j){
           j_pos = (j-1)k;
           lcp_len = LCP (i_pos, j_pos);
           if (lcp_len < k) { // mismatch
               if (lcp_len == k-1) { // mismatch at the last position
               // Output the pair (i, j)
               }
               else {
                 second_lcp_len = LCP (i_pos+lcp_len+1, j_pos+lcp_len+1);
                 if (lcp_len+second_lcp_len>=k-1) { // second lcp goes beyond
                   // Output the pair(i, j)
                 }
               }
           }
       }
   }
   

You could use SDSL library to build the suffix array in compressed form and answer the LCP queries.

Analysis: Building the enhanced suffix array is linear in the length of $X$ i.e. $O(nk)$. Each LCP query takes constant time. Thus, querying time is $O(n^2)$.

Generalisation: This approach can also be generalised to more than one mismatches. In general, running time is $O(nk + qn^2)$ where $q$ is the number of allowed mismatches.

If you wish to remove a string from the collection, instead of checking every $j<i$, you could keep a list of only 'valid' $j$.

การปรับปรุงหนึ่งเดียวกับโซลูชั่นทั้งหมดที่เสนอ พวกเขาทั้งหมดต้องการ$O(nk)$หน่วยความจำในกรณีที่เลวร้ายที่สุด คุณสามารถลดได้โดยการแฮชของสตริงคอมพิวเตอร์กับ*แทนตัวละครแต่ละตัวเช่น*bcde, a*cde... และการประมวลผลที่ผ่านแต่ละสายพันธุ์เท่านั้นที่มีค่าแฮอยู่ในช่วงจำนวนเต็มบางอย่าง เฟที่มีค่าแฮชแม้แต่คู่ในการผ่านครั้งแรกและค่าการแฮชคี่ในอันที่สอง

คุณยังสามารถใช้วิธีนี้เพื่อแยกการทำงานระหว่างคอร์ CPU / GPU หลายคอร์

This is a short version of @SimonPrins' answer not involving hashes.

Assuming none of your strings contain an asterisk:

1. Create a list of size $nk$ where each of your strings occurs in $k$ variations, each having one letter replaced by an asterisk (runtime $\mathcal{O}(nk^2)$)
2. Sort that list (runtime $\mathcal{O}(nk^2\log nk)$)
3. Check for duplicates by comparing subsequent entries of the sorted list (runtime $\mathcal{O}(nk^2)$)

An alternative solution with implicit usage of hashes in Python (can't resist the beauty):

def has_almost_repeats(strings,k):
    variations = [s[:i-1]+'*'+s[i+1:] for s in strings for i in range(k)]
    return len(set(variations))==k*len(strings)

Here is my take on 2+ mismatches finder. Note that in this post I consider each string as circular, f.e. substring of length 2 at index k-1 consists of symbol str[k-1] followed by str[0]. And substring of length 2 at index -1 is the same!

If we have M mismatches between two strings of length k, they have matching substring with length at least $mlen(k,M) = \lceil{k/M}\rceil-1$ since, in the worst case, mismatched symbols split (circular) string into M equal-sized segments. F.e. with k=20 and M=4 the "worst" match may have the pattern abcd*efgh*ijkl*mnop*.

Now, the algorithm for searching all mismatches up to M symbols among strings of k symbols:

• for each i from 0 to k-1
  • split all strings into groups by str[i..i+L-1], where L = mlen(k,M). F.e. if L=4 and you have alphabet of only 4 symbols (from DNA), this will make 256 groups.
  • Groups smaller than ~100 strings can be checked with brute-force algorithm
  • For larger groups, we should perform secondary division:
    • Remove from every string in the group L symbols we already matched
    • for each j from i-L+1 to k-L-1
      • split all strings into groups by str[i..i+L1-1], where L1 = mlen(k-L,M). F.e. if k=20, M=4, alphabet of 4 symbols, so L=4 and L1=3, this will make 64 groups.
      • the rest is left as exercise for the reader :D

Why we don't start j from 0? Because we already made these groups with the same value of i, so job with j<=i-L will be exactly equivalent to job with i and j values swapped.

Further optimizations:

• At every position, also consider strings str[i..i+L-2] & str[i+L]. This only doubles amount of jobs created, but allows to increase L by 1 (if my math is correct). So, f.e. instead of 256 groups, you will split data into 1024 groups.
• If some $L[i]$ becomes too small, we can always use the * trick: for each i in in 0..k-1, remove i'th symbol from each string and create job searching for M-1 mismatches in those strings of length k-1.

ฉันทำงานทุกวันในการประดิษฐ์และปรับปรุง algos ดังนั้นหากคุณต้องการประสิทธิภาพทุกบิตนั่นคือแผน:

• ตรวจสอบกับ*ในแต่ละตำแหน่งอย่างอิสระเช่นแทนการประมวลผลn*kสตริงชุดงานเดียว- เริ่มkงานอิสระแต่ละชุดการตรวจสอบnสตริง คุณสามารถกระจายkงานเหล่านี้ในหลายคอร์ CPU / GPU นี่เป็นสิ่งสำคัญอย่างยิ่งหากคุณจะตรวจสอบความแตกต่างของถ่าน 2+ ขนาดงานที่เล็กลงจะช่วยปรับปรุงตำแหน่งของแคชด้วยตัวเองซึ่งจะทำให้โปรแกรมเร็วขึ้น 10 เท่า
• หากคุณกำลังจะใช้ตารางแฮชให้ใช้การดำเนินการของคุณเองโดยใช้การตรวจสอบเชิงเส้นและปัจจัยโหลด ~ 50% มันใช้งานง่ายและรวดเร็ว หรือใช้การใช้งานที่มีอยู่ด้วยการเปิดที่อยู่ ตารางแฮช STL ช้าเนื่องจากใช้การโยงแบบแยกกัน
• คุณอาจลองกรองข้อมูลล่วงหน้าโดยใช้ตัวกรอง Bloom 3 สถานะ (แยก 0/1/1 + ที่เกิดขึ้น) ตามที่เสนอโดย @AlexReynolds
• สำหรับแต่ละ i จาก 0 ถึง k-1 ให้รันงานต่อไปนี้:
  • สร้างโครงสร้าง 8 ไบต์ที่ประกอบด้วยแฮช 4-5 ไบต์ของแต่ละสตริง (ด้วย*ตำแหน่ง i-th) และดัชนีสตริงจากนั้นเรียงลำดับหรือสร้างตารางแฮชจากระเบียนเหล่านี้

สำหรับการเรียงลำดับคุณอาจลองใช้คอมโบต่อไปนี้:

• การส่งครั้งแรกคือการเรียง MSD radix ใน 64-256 วิธีใช้เคล็ดลับ TLB
• การผ่านครั้งที่สองคือการจัดเรียง MSD radix ใน 256-1024 วิธีที่ไม่มีเคล็ดลับ TLB (รวม 64K วิธี)
• รอบที่สามคือการจัดเรียงการแทรกเพื่อแก้ไขความไม่สอดคล้องที่เหลืออยู่