คำถามติดแท็ก strings

ฉันกำลังพยายามเขียนตัวตรวจการสะกดซึ่งควรใช้กับพจนานุกรมที่มีขนาดค่อนข้างใหญ่ ฉันต้องการวิธีที่มีประสิทธิภาพในการจัดทำดัชนีข้อมูลพจนานุกรมของฉันโดยใช้ระยะทางDamerau-Levenshteinเพื่อกำหนดว่าคำใดที่ใกล้เคียงที่สุดกับคำที่สะกดผิด ฉันกำลังมองหาโครงสร้างข้อมูลที่จะให้ความประนีประนอมระหว่างความซับซ้อนของพื้นที่กับความซับซ้อนของรันไทม์ได้ดีที่สุด จากสิ่งที่ฉันพบบนอินเทอร์เน็ตฉันมีโอกาสในการขายไม่กี่เกี่ยวกับประเภทของโครงสร้างข้อมูลที่จะใช้: Trie นี่เป็นความคิดแรกของฉันและดูใช้งานได้ง่ายและควรมีการค้นหา / แทรกอย่างรวดเร็ว การค้นหาโดยประมาณโดยใช้ Damerau-Levenshtein ควรง่ายต่อการใช้งานที่นี่เช่นกัน แต่มันไม่ได้ดูมีประสิทธิภาพมากนักในแง่ของความซับซ้อนของพื้นที่เนื่องจากคุณมักจะมีค่าใช้จ่ายจำนวนมากกับที่เก็บข้อมูลพอยน์เตอร์ Patricia Trie ดูเหมือนว่าจะใช้เนื้อที่น้อยกว่า Trie ปกติเนื่องจากคุณไม่ต้องเสียค่าใช้จ่ายในการเก็บพอยน์เตอร์ แต่ฉันกังวลเกี่ยวกับการแยกส่วนข้อมูลในกรณีที่พจนานุกรมมีขนาดใหญ่มากเหมือนที่ฉันมี ต้นไม้ต่อท้าย ฉันไม่แน่ใจเกี่ยวกับสิ่งนี้ดูเหมือนว่าบางคนจะพบว่ามีประโยชน์ในการทำเหมืองข้อความ แต่ฉันไม่แน่ใจว่าสิ่งที่จะให้ในแง่ของประสิทธิภาพสำหรับตัวตรวจสอบการสะกด Ternary Search Tree สิ่งเหล่านี้ดูดีมากและในแง่ของความซับซ้อนควรอยู่ใกล้ (ดีกว่า) กับ Patricia Tries แต่ฉันไม่แน่ใจเกี่ยวกับการแยกส่วนหากมันจะดีกว่าแย่กว่า Patricia Tries ต้นไม้ระเบิด ดูเหมือนว่าจะเป็นลูกผสมและฉันก็ไม่แน่ใจว่าจะได้ประโยชน์อะไรจาก Tries และสิ่งที่คล้ายกัน แต่ฉันได้อ่านมาหลายครั้งแล้วว่ามันมีประสิทธิภาพมากสำหรับการทำเหมืองข้อความ ฉันต้องการรับความคิดเห็นเกี่ยวกับโครงสร้างข้อมูลที่ดีที่สุดที่จะใช้ในบริบทนี้และสิ่งที่ทำให้ดีกว่าที่อื่น หากฉันขาดโครงสร้างข้อมูลบางอย่างที่เหมาะสมกว่าสำหรับเครื่องตรวจการสะกดคำฉันก็สนใจเช่นกัน

41 data-structures  strings  string-metrics 

สมมติว่าและเป็นสองสตริงที่มีความยาวเท่ากัน anagrammingของสองสายคือการทำแผนที่ bijectiveเช่นว่าสำหรับแต่ละฉันb 1 b 2 … b na1a2…ana1a2…ana_1a_2\ldots a_nb1b2…bnb1b2…bnb_1b_2\ldots b_na i = b p ( i ) ip:[1…n]→[1…n]p:[1…n]→[1…n]p:[1\ldots n]\to[1\ldots n]ai=bp(i)ai=bp(i)a_i = b_{p(i)}iii อาจมีแอนนาแกรมมากกว่าหนึ่งรายการสำหรับคู่สายเดียวกัน ตัวอย่างเช่นถ้า `abcab` และเรามีและและอื่น ๆb = p 1 [ 1 , 2 , 3 , 4 , 5 ] → [ 4 , 5 , 1 , …

31 algorithms  strings  search-algorithms  natural-language-processing 

ฉันกำลังมองหาโครงสร้างข้อมูลที่เก็บชุดสตริงไว้ในชุดอักขระสามารถทำการดำเนินการต่อไปนี้ได้ เราแสดงว่าเป็นโครงสร้างข้อมูลการจัดเก็บชุดของสตริงSD ( S ) SΣΣ\SigmaD (S)D(S)\mathcal{D}(S)SSS Add-Prefix-Setบน : กำหนดชุดของ (อาจว่างเปล่า) สตริงซึ่งขนาดถูก จำกัด ด้วยค่าคงที่และความยาวสตริงถูก จำกัด โดยค่าคงที่ส่งคืน\}) ทั้งสองนี้คง bounding มีทั่วโลก: พวกเขาเป็นเหมือนกันสำหรับปัจจัยการผลิตทั้งหมดTT D ( { t s | t ∈ T , s ∈ S } ) TD (S)D(S)\mathcal{D}(S)TTTD ({ts | t∈T , s ∈ S} )D({ts | t∈T,s∈S})\mathcal{D}( \{ t s\ …

28 data-structures  time-complexity  strings  stacks 

คำชี้แจงปัญหาที่ไม่เป็นทางการ: รับสตริงเช่นเราต้องการให้สีตัวอักษรสีแดงและบางตัวอักษรสีน้ำเงิน (และบางส่วนไม่ได้เลย) เช่นการอ่านตัวอักษรสีแดงจากซ้ายไปขวาให้ผลเช่นเดียวกับการอ่าน ตัวอักษรสีน้ำเงินเท่านั้นACCABBABACCABBABACCABBAB ในตัวอย่างเราสามารถระบายสีพวกมันได้ดังนี้: ACCABBABACCABBABA\color{blue}{C}\color{red}{CAB}B\color{blue}{AB} ดังนั้นเราจึงบอกว่าเป็น subsequence ซ้ำC C B B B นอกจากนี้ยังมีการวนซ้ำซ้ำที่ยาวที่สุด (ซึ่งง่ายต่อการตรวจสอบ)CBCABCABCCA B B A BACCABBABACCABBAB เราสามารถคำนวณส่วนประกอบซ้ำที่ยาวที่สุดได้อย่างมีประสิทธิภาพหรือไม่ คำถามทางการ: มันยากที่จะตัดสินใจว่าจะให้สตริงกับหรือไม่ว่ามีการเรียงตัวของความยาวkซ้ำอยู่ในสตริงหรือไม่?kkkkkk ถ้าเป็นเช่นนั้น: ปัญหาใดที่สามารถลดปัญหานี้ได้ ถ้าไม่: อัลกอริทึมที่มีประสิทธิภาพคืออะไร? (เห็นได้ชัดว่าอัลกอริธึมนี้สามารถใช้ในการคำนวณการวนซ้ำที่ยาวที่สุด) คำถามโบนัส: จะมีการเรียงลำดับความยาวหากขนาดของตัวอักษรถูกล้อมด้วยค่าคงที่หรือไม่?n / 2 - o ( n )n/2−o(n)n/2 - o(n) (สิ่งนี้เป็นที่รู้จักกันว่าเป็นจริงสำหรับตัวอักษรไบนารี) แก้ไข 2: คำตอบเชิงลบเพื่อโบนัสคำถามที่เป็นที่รู้จักกันไปแล้วสำหรับตัวอักษรที่มีขนาดอย่างน้อย5ในความเป็นจริงสำหรับตัวอักษรขนาดมีสตริงกับ subsequences ซ้ำที่ยาวที่สุดของความยาวของเพียง1/2}) สตริงสุ่มเพียงพอที่จะแสดงสิ่งนี้ ผลลัพธ์มีอยู่แล้ว แต่ฉันมองข้ามไป555ΣΣΣO(n⋅Σ−1/2)O(n·Σ−1/2)O(n · Σ^{-1/2}) …

26 algorithms  complexity-theory  np-complete  strings  subsequences 

ฉันกำลังมองหาโครงสร้างข้อมูลที่สนับสนุนการค้นหาคีย์โดยประมาณอย่างมีประสิทธิภาพ (เช่นระยะทางของ Levenshtein สำหรับสตริง) โดยคืนค่าการจับคู่ที่ใกล้เคียงที่สุดสำหรับคีย์อินพุต โครงสร้างข้อมูลที่เหมาะสมที่สุดที่ฉันเคยพบคือต้นไม้ Burkhard-Kellerแต่ฉันสงสัยว่ามีโครงสร้างข้อมูลอื่น ๆ / ดีกว่าสำหรับจุดประสงค์นี้ แก้ไข: รายละเอียดเพิ่มเติมเกี่ยวกับกรณีเฉพาะของฉัน: สายอักขระมักจะมีความแตกต่างกันมากในระดับที่ค่อนข้างใหญ่ สตริงมีความยาวสูงสุดประมาณ 20-30 ตัวอักษรโดยมีค่าเฉลี่ยใกล้เคียงกับ 10-12 ฉันสนใจในการค้นหาที่มีประสิทธิภาพมากกว่าการแทรกเนื่องจากฉันจะสร้างชุดข้อมูลสแตติกส่วนใหญ่ที่ฉันต้องการค้นหาอย่างมีประสิทธิภาพ

25 data-structures  strings  efficiency 

ผมอยากรู้ว่าวิธีหนึ่งอาจมากดานบีบอัดโดเมนของพลIDNชื่อโฮสต์ (ตามที่กำหนดโดยRFC5890 ) และสงสัยว่านี้อาจจะกลายเป็นความท้าทายที่น่าสนใจ โฮสต์ Unicode หรือชื่อโดเมน (U-label) ประกอบด้วยสตริงของอักขระ Unicode โดยทั่วไปจะถูก จำกัด ให้เป็นหนึ่งภาษาขึ้นอยู่กับโดเมนระดับบนสุด (เช่นตัวอักษรกรีกภายใต้.gr) ซึ่งเข้ารหัสเป็นสตริง ASCII ที่ขึ้นต้นด้วยxn--(ที่สอดคล้องกัน A-ฉลาก) หนึ่งสามารถสร้างแบบจำลองข้อมูลไม่เพียง แต่จากข้อกำหนดอย่างเป็นทางการที่ แต่ละป้ายที่ไม่ใช่ Unicode จะจับคู่สตริง^[a-z\d]([a-z\d\-]{0,61}[a-z\d])?$; แต่ละ A-label เป็นการจับคู่สตริง^xn--[a-z\d]([a-z\d\-]{0,57}[a-z\d])?$; และ ความยาวรวมของโดเมนทั้งหมด (ป้ายกำกับ A และป้ายกำกับที่ไม่ใช่ IDN ตัดแบ่งด้วย '.' ตัวคั่น) ไม่เกิน 255 อักขระ แต่จากการวิเคราะห์พฤติกรรมต่าง ๆ รวมไปถึง: ลดการสั่งซื้อ U-ฉลากมักจะ lexically, ไวยากรณ์และความหมายวลีที่ถูกต้องในภาษาธรรมชาติบางอย่างรวมทั้งคำนามที่เหมาะสมและตัวเลข (unpunctuated ยกเว้นยัติภังค์ปลดออกจากช่องว่างและพับต่อNameprep ) มีการตั้งค่าสำหรับวลีสั้น; และ …

21 algorithms  strings  natural-language-processing  data-compression 

ให้เป็นชุดของอักขระที่มีขนาดคงที่ Letเป็นสตริงบางกว่า\เราบอกว่าว่างย่อยของเป็นซ้ำถ้าสตริงบาง\ΣΣ\Sigmaαα\alphaΣΣ\Sigmaββ\betaαα\alphaβ=γγβ=γγ\beta = \gamma \gammaγγ\gamma ตอนนี้คำถามของฉันคือว่าต่อไปนี้: สำหรับทุก ๆมีบางเช่นนั้นสำหรับทุกสายมากกว่าของความยาวอย่างน้อย ,มีการทำซ้ำอย่างน้อยหนึ่งครั้งΣΣ\Sigman ∈ Nn∈ยังไม่มีข้อความn \in \mathbb{N}αα\alphaΣΣ\Sigmannnαα\alpha ฉันได้ตรวจสอบสิ่งนี้ผ่านตัวอักษรไบนารีและมันค่อนข้างง่ายสำหรับกรณีนี้ แต่ตัวอักษรขนาด 3 นั้นค่อนข้างยากที่จะตรวจสอบอยู่แล้วและฉันต้องการหลักฐานสำหรับไวยากรณ์ขนาดใหญ่โดยพลการ หากการคาดคะเนดังกล่าวข้างต้นเป็นความจริงแล้วฉันสามารถ (เกือบ) เอาความต้องการสำหรับการแทรกสตริงที่ว่างเปล่าในคำถามอื่น ๆ ของฉัน

20 combinatorics  strings  word-combinatorics 

ฉันกังวลกับคำถามเกี่ยวกับเวลาที่ใช้ในการทำงานแบบไม่แสดงอาการของอัลกอริทึมของ Ukkonenซึ่งอาจเป็นอัลกอริทึมที่ได้รับความนิยมมากที่สุดสำหรับการสร้างต้นไม้ต่อท้ายในเวลาเชิงเส้น (?) นี่คือการอ้างอิงจากหนังสือ "อัลกอริทึมในสตริงต้นไม้และลำดับ" โดย Dan Gusfield (ส่วน 6.5.1): "... อัลกอริธึมAho-Corasick, Weiner, Ukkonenและ McCreight นั้นต้องการพื้นที่หรือเวลาต้องถูกแทนที่ด้วยค่าต่ำสุดของและ "Θ(m|Σ|)Θ(m|Σ|)\Theta(m|\Sigma|)O(m)O(m)O(m)O(mlogm)O(mlog⁡m)O(m \log m)O(mlog|Σ|)O(mlog⁡|Σ|)O(m \log|\Sigma|) [คือความยาวสตริงและคือขนาดของตัวอักษร]mmmΣΣ\Sigma ฉันไม่เข้าใจว่าทำไมถึงเป็นจริง พื้นที่:ดีในกรณีที่เราเป็นตัวแทนของสาขาออกจากโหนดใช้อาร์เรย์ขนาดแล้วแน่นอนเราจบลงด้วยการใช้พื้นที่ อย่างไรก็ตามเท่าที่ฉันเห็นมันเป็นไปได้ที่จะจัดเก็บกิ่งไม้โดยใช้ตารางแฮช (เช่นพจนานุกรมใน Python) จากนั้นเราจะมีเฉพาะตัวชี้เก็บไว้ในตารางแฮชทั้งหมด (เนื่องจากมีขอบในต้นไม้) ในขณะที่ยังคงสามารถเข้าถึงโหนดลูกในเวลาเร็วที่สุด เช่นเดียวกับเมื่อใช้อาร์เรย์Θ(|Σ|)Θ(|Σ|)\Theta(|\Sigma|)Θ(m|Σ|)Θ(m|Σ|)\Theta(m|\Sigma|)Θ(m)Θ(m)\Theta(m)Θ(m)Θ(m)\Theta(m)O(1)O(1)O(1) เวลา : ดังกล่าวข้างต้นโดยใช้ตารางแฮชช่วยให้เราสามารถเข้าถึงสาขาขาออกของโหนดใด ๆ ในเวลา ตั้งแต่ขั้นตอนวิธี Ukkonen ต้องใช้การดำเนินงาน (รวมถึงการเข้าถึงโหนดเด็ก) เวลาการทำงานโดยรวมแล้วจะเป็นยัง(เมตร)O(1)O(1)O(1)O(m)O(m)O(m)O(m)O(m)O(m) ฉันจะขอบคุณคุณเป็นอย่างมากสำหรับคำแนะนำใด ๆ ว่าทำไมฉันถึงเข้าใจผิดในข้อสรุปของฉันและทำไม Gusfield ถึงถูกต้องเกี่ยวกับการพึ่งพาอัลกอริทึมของ Ukkonen ในตัวอักษร

19 algorithms  data-structures  algorithm-analysis  strings 

ฉันทำงานเกี่ยวกับปัญหาต่อไปนี้จากหนังสือเล่มนี้ ภาษาการประมวลผลสตริงที่แน่นอนมีการดำเนินการดั้งเดิมซึ่งแยกสตริงออกเป็นสองชิ้น เนื่องจากการดำเนินการนี้เกี่ยวข้องกับการคัดลอกสตริงดั้งเดิมจึงใช้เวลา n หน่วยสำหรับสตริงที่มีความยาว n โดยไม่คำนึงถึงตำแหน่งของการตัด สมมติว่าตอนนี้คุณต้องการแบ่งสตริงออกเป็นหลาย ๆ ส่วน ลำดับการหยุดพักอาจส่งผลต่อเวลาการทำงานทั้งหมด ตัวอย่างเช่นหากคุณต้องการตัดสตริงอักขระ 20 ตัวที่ตำแหน่ง333และ101010ดังนั้นการตัดครั้งแรกที่ตำแหน่ง333จะมีค่าใช้จ่ายรวม20+17=3720+17=3720 + 17 = 37ขณะทำตำแหน่ง 10 ก่อนจะมีต้นทุนที่ดีกว่า20+10=3020+10=3020 + 10 = 30. ฉันต้องการอัลกอริธึมการเขียนโปรแกรมแบบไดนามิกที่ให้การตัดค้นหาค่าใช้จ่ายขั้นต่ำของการตัดสตริงเป็นm + 1ชิ้นmม.mm+1ม.+1m +1

16 algorithms  combinatorics  strings  dynamic-programming 

ให้สองสายคุณจะตรวจสอบได้อย่างไรว่าพวกมันเป็นการเปลี่ยนแปลงซึ่งกันและกันโดยใช้พื้นที่ O (1)? ไม่อนุญาตให้ดัดแปลงสตริงใด ๆ หมายเหตุ: พื้นที่ O (1) สัมพันธ์กับทั้งความยาวสตริงและขนาดของตัวอักษร

13 algorithms  strings  space-complexity 

Levenshtein-Distance ระยะทางแก้ไขระหว่างรายการเป็นปัญหาที่ศึกษากันดี แต่ฉันไม่สามารถหามากเกี่ยวกับการปรับปรุงไปได้ถ้า มันเป็นที่รู้จักกันว่าองค์ประกอบไม่มีไม่เกิดขึ้นมากกว่าหนึ่งครั้งในแต่ละรายการ ลองสมมติว่าองค์ประกอบนั้นสามารถเปรียบเทียบได้ / เรียงลำดับได้ (แต่รายการที่จะเปรียบเทียบจะไม่เรียงลำดับเพื่อเริ่มต้นด้วย) O(min(m,n)s)O(min(m,n)s)O(\min(m,n)s)O(min(s,m,n)s)O(min(s,m,n)s)O(\min(s,m,n)s)sss เป็นทางการมากขึ้น เราสามารถคำนวณระยะทางในการแก้ไขระหว่างสองสายที่กำหนด มีประสิทธิภาพด้วยคำสัญญาที่ว่าพวกเขาไม่มีตัวอักษรซ้ำ ๆ กันหรือไม่?s,t∈Σ∗s,t∈Σ∗s,t \in \Sigma^* ΣΣ\Sigmaเป็นตัวอักษรที่มีขนาดใหญ่มาก

12 algorithms  strings  string-metrics  edit-distance 

ฉันกำลังทำงานกับอัลกอริธึมการค้นหาสตริงที่สนับสนุนการค้นหาหลายรูปแบบ ผมพบว่าทั้งสองขั้นตอนวิธีการที่ดูเหมือนผู้สมัครที่แข็งแกร่งที่สุดในแง่ของเวลาการทำงานคือAho-Corasickและราบิน-คาร์พ อย่างไรก็ตามฉันไม่พบการเปรียบเทียบแบบครอบคลุมระหว่างอัลกอริธึมทั้งสอง อัลกอริทึมใดที่มีประสิทธิภาพมากกว่า นอกจากนี้อันไหนที่เหมาะกว่าสำหรับการคำนวณแบบขนานและการค้นหาหลายรูปแบบ? ในที่สุดใครจะใช้ทรัพยากรฮาร์ดแวร์น้อย? สำหรับอัลกอริทึม AC ระยะการค้นหาใช้เวลาในขณะที่เป็น RK อย่างไรก็ตามเวลาทำงานสำหรับ RK คือซึ่งทำให้คล้ายกับ AC ข้อสรุปเบื้องต้นของฉันคือ RK ดูดีกว่าเพราะไม่ต้องการหน่วยความจำมากเท่ากับ AC ถูกต้องหรือไม่O(n+m)O(n+m)O(n+m)O(nm)O(nm)O(nm)O(n+m)O(n+m)O(n+m)

11 algorithms  algorithm-analysis  runtime-analysis  strings 

ในระหว่างการสัมภาษณ์ตำแหน่งนักพัฒนา Java ฉันถูกถามต่อไปนี้: เขียนฟังก์ชั่นที่ใช้สองพารามิเตอร์: String แสดงเอกสารข้อความและ จำนวนเต็มซึ่งระบุจำนวนรายการที่จะส่งคืน ใช้ฟังก์ชั่นเพื่อส่งคืนรายการ Strings เรียงลำดับตามความถี่ของคำซึ่งเป็นคำที่เกิดขึ้นบ่อยที่สุดก่อน โซลูชันของคุณควรทำงานในเวลาโดยที่คือจำนวนอักขระในเอกสารO(n)O(n)O(n)nnn ต่อไปนี้เป็นสิ่งที่ฉันตอบ (ใน pseudocode) ไม่ใช่แต่ค่อนข้างเวลาเนื่องจากการเรียงลำดับ ฉันไม่สามารถคิดออกว่าจะทำมันเวลา O(n)O(n)O(n)O(nlogn)O(nเข้าสู่ระบบ⁡n)O(n \log n)O(n)O(n)O(n) wordFrequencyMap = new HashMap<String, Integer>(); words = inputString.split(' '); for (String word : words) { count = wordFrequencyMap.get(word); count = (count == null) ? 1 : ++count; wordFrequencyMap.put(word, count); } return …

11 algorithms  sorting  strings  data-mining 

เมื่อได้รับสองสัญลักษณ์และbให้นิยามสตริงk -th Fibonacci ดังนี้aa\text{a}bb\text{b}kkk F(k)=⎧⎩⎨baF(k−1)⋆F(k−2)if k=0if k=1elseF(k)={bif k=0aif k=1F(k−1)⋆F(k−2)else F(k) = \begin{cases} \text{b} &\mbox{if } k = 0 \\ \text{a} &\mbox{if } k = 1 \\ F(k-1) \star F(k-2) &\mbox{else} \end{cases} ด้วย denoting string concatenation⋆⋆\star ดังนั้นเราจะมี: F(0)=bF(0)=bF(0) = \text{b} F(1)=aF(1)=aF(1) = \text{a} F(2)=F(1)⋆F(0)=abF(2)=F(1)⋆F(0)=abF(2) = F(1) \star F(0) = \text{ab} F(3)=F(2)⋆F(1)=abaF(3)=F(2)⋆F(1)=abaF(3) …

10 algorithms  algorithm-analysis  runtime-analysis  strings  substrings 

ฉันกำลังมองหาอัลกอริทึมการจับคู่สตริง k-mismatch ที่รวดเร็ว กำหนดสตริงรูปแบบ P ของความยาว m และสตริงข้อความ T ของความยาว n, ฉันต้องการอัลกอริทึม (เชิงเส้นเวลา) ที่รวดเร็วเพื่อค้นหาตำแหน่งทั้งหมดที่ P ตรงกับสตริงย่อยของ T กับ k ไม่ตรงกันมากที่สุด สิ่งนี้แตกต่างจากปัญหาความแตกต่างของ k (ระยะทางแก้ไข) ไม่ตรงกันหมายถึงสตริงย่อยและรูปแบบมีตัวอักษรที่แตกต่างกันในตำแหน่ง k มากที่สุด ฉันต้องการเพียง k = 1 (มากที่สุด 1 ไม่ตรงกัน) ดังนั้นอัลกอริทึมที่รวดเร็วสำหรับกรณีเฉพาะของ k = 1 ก็จะเพียงพอเช่นกัน ขนาดตัวอักษรคือ 26 (ตัวพิมพ์เล็กและตัวพิมพ์เล็ก) ดังนั้นความต้องการพื้นที่ไม่ควรเติบโตเร็วเกินไปเมื่อเทียบกับขนาดของตัวอักษร (เช่นอัลกอริทึม FAAST ฉันเชื่อว่าใช้พื้นที่ชี้แจงแทนขนาดตัวอักษรและอื่น ๆ เหมาะสำหรับลำดับโปรตีนและยีนเท่านั้น) วิธีการเขียนโปรแกรมแบบไดนามิกที่ใช้มีแนวโน้มที่จะเป็น O (mn) …

10 algorithms  reference-request  strings  string-metrics  substrings