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

เมื่อฉันอ่านหนังสืออัลกอริทึมบางเล่มพวกเขาเต็มไปด้วยกระบวนการที่ชาญฉลาดสำหรับปัญหาบางอย่าง (การเรียงลำดับเส้นทางที่สั้นที่สุด) หรือวิธีการทั่วไปบางอย่าง (อัลกอริทึมแบบเรียกซ้ำแบ่งและพิชิตการเขียนโปรแกรมแบบไดนามิก ... ) ฉันพบร่องรอยการเขียนโปรแกรมเชิงวัตถุน้อย (ทำไมพวกเขาถึงมุ่งเน้นกระบวนการมากขึ้น?) จากนั้นฉันก็คิดว่า: ความสัมพันธ์ระหว่างอัลกอริทึมกับ OOP คืออะไร พวกเขาเป็นสองหัวข้ออิสระ? มีปัญหาบางอย่างที่สามารถนำเสนอและแก้ไขโดย OOP เท่านั้น? OOP จะช่วยอัลกอริทึมได้อย่างไร หรือในทิศทางที่มันสามารถส่งผลกระทบต่อมัน?

9 object-oriented  algorithms 

ฉันกำลังพยายามสร้างตารางเวลากีฬาลีก ฉันมีปัญหาในการระบุอัลกอริทึมเพื่อช่วยฉันเติมในแต่ละช่องอย่างมีประสิทธิภาพ ข้อมูลตัวอย่างเพื่อสร้างตารางจะเป็น: 10 ทีม แต่ละทีมเล่นกัน 1 ครั้ง (ต้องมีเกมทั้งหมด 45 เกม) แต่ละทีมเล่นไม่เกิน 1 ครั้งต่อวัน ในการทดสอบของฉันฉันใช้ 9 วันกับ 5 ช่องต่อวัน ตารางคำสั่งผสม (ประกอบด้วย 45 คอมโบ) ID Team1ID Team2ID บิตได้รับการแต่งตั้ง ตารางเวลา (ประกอบด้วย 45 ช่วงเวลา) กำหนดเวลา ID บ้าน ทีมออก ห่างทีม เกมวันเกมเวลา ตอนนี้ขั้นตอนที่มีอยู่ของฉันเติมประมาณ 90% ของช่องที่เหลือ 10% ของช่องว่างของฉันให้ว่างเปล่ากับความขัดแย้งของการตั้งเวลาตามกฎข้างต้น ฉันวนรอบตารางเวลาของฉันตามลำดับวันที่ / เวลาจากน้อยไปมาก สล็อตแรกของฉันอาจเป็นวันเสาร์เวลา 8:00 น. ฉันสอบถามรายชื่อทีมที่ยังไม่ได้กำหนด ฉันจึงจัดเรียงชุดค่าผสมที่เป็นไปได้ของทีมเหล่านั้น …

9 algorithms  scheduling 

ฉันเล่นกับการทำภาพโมเสค สคริปต์ของฉันใช้ภาพจำนวนมากปรับขนาดให้เป็นภาพขนาดย่อจากนั้นใช้เป็นภาพย่อยเพื่อประมาณภาพเป้าหมาย จริงๆแล้ววิธีการนี้ค่อนข้างเป็นที่น่าพอใจ: ฉันคำนวณข้อผิดพลาดกำลังสองเฉลี่ยสำหรับทุกหัวแม่มือในทุกตำแหน่งไทล์ ตอนแรกฉันเพิ่งใช้ตำแหน่งที่โลภ: วางนิ้วโป้งโดยมีข้อผิดพลาดน้อยที่สุดบนกระเบื้องที่เหมาะสมที่สุดแล้วต่อไปเรื่อย ๆ ปัญหาเกี่ยวกับความโลภคือมันจะทำให้คุณวางนิ้วหัวแม่มือที่แตกต่างกันมากที่สุดบนกระเบื้องที่ได้รับความนิยมน้อยที่สุดในที่สุดไม่ว่าพวกเขาจะจับคู่กันอย่างใกล้ชิดหรือไม่ก็ตาม ฉันแสดงตัวอย่างที่นี่: http://williamedwardscoder.tumblr.com/post/84505278488/making-image-mosaics ดังนั้นฉันจึงทำการสุ่มสลับจนกว่าสคริปต์จะถูกขัดจังหวะ ผลลัพธ์ค่อนข้างโอเค การสลับแบบสุ่มของไพ่สองใบไม่ได้เป็นการปรับปรุงเสมอไป แต่บางครั้งการหมุนของไพ่สามใบขึ้นไปส่งผลให้เกิดการปรับปรุงระดับโลกเช่นA <-> Bอาจไม่ดีขึ้น แต่A -> B -> C -> A1อาจจะ .. ด้วยเหตุนี้หลังจากที่สุ่มไพ่สองใบและพบว่าพวกมันไม่ได้ปรับปรุงฉันก็เลือกไพ่หลายใบเพื่อประเมินว่าพวกเขาสามารถเป็นไพ่ใบที่สามได้ไหมในการหมุน ฉันไม่สำรวจว่าชุดไพ่สี่ชุดใด ๆ สามารถหมุนได้อย่างมีกำไรและอื่น ๆ ; นั่นจะเป็นของจริงแพงสูงในไม่ช้า แต่มันต้องใช้เวลา .. มาก! มีวิธีที่ดีกว่าและเร็วกว่านี้ไหม? ปรับปรุงเงินรางวัล ผมทดสอบจากการใช้งานที่หลากหลายและงูหลามผูกของวิธีฮังการี ที่เร็วที่สุดคือ pure-Python https://github.com/xtof-durr/makeSimple/blob/master/Munkres/kuhnMunkres.py ลางสังหรณ์ของฉันคือสิ่งนี้ใกล้เคียงกับคำตอบที่ดีที่สุด; เมื่อเรียกใช้บนภาพทดสอบห้องสมุดอื่น ๆ ทั้งหมดเห็นด้วยกับผลลัพธ์ แต่ kuhnMunkres.py นี้ในขณะที่เป็นคำสั่งที่มีขนาดเร็วขึ้นมากเพียงใกล้มากกับคะแนนที่การใช้งานอื่น ๆ ได้ตกลงไว้ ความเร็วขึ้นอยู่กับข้อมูล …

9 algorithms  graphics 

ฉันเริ่มทำงานในโครงการใหม่ที่เกี่ยวข้องกับ Big Data สำหรับการฝึกงานของฉัน ผู้จัดการของฉันแนะนำให้เริ่มการเรียนรู้การเขียนโปรแกรมฟังก์ชั่น (พวกเขาขอแนะนำสกาล่า) ฉันมีประสบการณ์ที่ต่ำต้อยโดยใช้ F # แต่ฉันไม่เห็นความสำคัญของการใช้กระบวนทัศน์การเขียนโปรแกรมนี้เนื่องจากมีราคาแพงในบางกรณี คณบดีพูดคุยเกี่ยวกับหัวข้อนี้ที่น่าสนใจและแบ่งปันความคิดของเขาว่าทำไม "Big Data" ที่นี่: http://www.youtube.com/watch?v=DFAdLCqDbLQ แต่มันไม่สะดวกเพราะ Big Data ไม่ได้แปล Hadoop เท่านั้น ในฐานะที่เป็น BigData แนวคิดที่คลุมเครือมาก ฉันลืมไปซักพักแล้ว ฉันพยายามหาตัวอย่างง่ายๆหนึ่งตัวอย่างเพื่อเปรียบเทียบระหว่างแง่มุมต่าง ๆ เมื่อเราจัดการกับข้อมูลเพื่อดูว่าวิธีการใช้งานมีราคาแพงหรือไม่ หากการเขียนโปรแกรมเชิงฟังก์ชั่นมีราคาแพงและใช้หน่วยความจำสำหรับข้อมูลขนาดเล็กทำไมเราต้องใช้กับ Big Data? นอกเหนือจากเครื่องมือแฟนซีฉันพยายามสร้างวิธีแก้ปัญหาสำหรับปัญหาเฉพาะและเป็นที่นิยมโดยใช้สามวิธีคือวิธีที่จำเป็นและวิธีการใช้งาน (การเรียกซ้ำโดยใช้คอลเลกชัน) ฉันเปรียบเทียบเวลาและความซับซ้อนเพื่อเปรียบเทียบระหว่างสามแนวทาง ฉันใช้ Scala เพื่อเขียนฟังก์ชันเหล่านี้เนื่องจากเป็นเครื่องมือที่ดีที่สุดในการเขียนอัลกอริทึมโดยใช้กระบวนทัศน์สามแบบ def main(args: Array[String]) { val start = System.currentTimeMillis() // Fibonacci_P val s = …

9 algorithms  scala  big-data 

ฉันกำลังมองหาอัลกอริทึมในการจัดการปัญหาต่อไปนี้ซึ่งตอนนี้ฉันกำลังเรียกอัลกอริทึม "แอปเปิ้ลไม่ดี" ปัญหา ฉันมี N โพรเซสที่ทำงานในแซนด์บ็อกซ์ M โดยที่ >> N มันเป็นไปไม่ได้เลยที่จะให้แต่ละกระบวนการเป็น sandbox ของตัวเอง อย่างน้อยหนึ่งในกระบวนการเหล่านั้นมีพฤติกรรมไม่ดีและนำลงสู่ sandbox ทั้งหมดดังนั้นจึงฆ่ากระบวนการอื่นทั้งหมดใน sandbox เดียวกัน หากเป็นกระบวนการที่ประพฤติตัวไม่ดีเพียงครั้งเดียวฉันสามารถใช้การแบ่งครึ่งแบบง่าย ๆ เพื่อใส่กระบวนการครึ่งหนึ่งลงในแซนด์บ็อกซ์หนึ่งและอีกครึ่งหนึ่งในแซนด์บ็อกซ์อื่นจนกว่าฉันจะพบคนผิดปกติ คำถาม หากมีมากกว่าหนึ่งกระบวนการที่มีพฤติกรรมไม่ดี - รวมถึงความเป็นไปได้ที่พวกเขาทั้งหมดมีพฤติกรรมไม่ดี - อัลกอริทึมไร้เดียงสานี้ใช้งานได้หรือไม่? มันรับประกันว่าจะทำงานภายในขอบเขตที่เหมาะสมหรือไม่? simplifications เพื่อประโยชน์ในการโต้แย้งลองสมมติว่ากระบวนการที่ไม่ดีจะทำลายกล่องทรายของมันทันทีและกระบวนการที่ดีไม่เคยทำ

9 algorithms 

ประเด็นของคำถามนี้ไม่ได้เป็นการอภิปรายถึงข้อดีของอัลกอริทึมการเรียงลำดับอื่น ๆ - แน่นอนว่ามีคำถามอื่น ๆ อีกมากมายที่ทำเช่นนี้ คำถามนี้เกี่ยวกับชื่อ เหตุใด Quicksort จึงเรียกว่า "Quicksort" แน่นอนว่ามันเป็น "เร็ว" ส่วนใหญ่ แต่ไม่เสมอไป ความเป็นไปได้ของการเสื่อมสภาพไปยัง O (N ^ 2) เป็นที่รู้จักกันดี มีการแก้ไข Quicksort มากมายที่ช่วยลดปัญหานี้ แต่กรณีที่นำกรณีที่แย่ที่สุดมาสู่ O (n log n) ที่รับประกันจะไม่เรียกว่า Quicksort อีกต่อไป (เช่น Introsort) ฉันแค่สงสัยว่าทำไมอัลกอริธึมการเรียงลำดับที่รู้จักกันดีทั้งหมดนี่เป็นสิ่งเดียวที่สมควรได้รับชื่อ "ด่วน" ซึ่งไม่ได้อธิบายว่าอัลกอริทึมทำงานอย่างไร แต่เร็วแค่ไหน (ปกติ) การรวมกันเรียกว่าเพราะมันรวมข้อมูล Heapsort เรียกว่าเพราะใช้ฮีป Introsort ได้รับชื่อจาก "Introspective" เนื่องจากตรวจสอบประสิทธิภาพของตัวเองเพื่อตัดสินใจว่าเมื่อใดที่จะเปลี่ยนจาก Quicksort เป็น Heapsort ในทำนองเดียวกันสำหรับคนที่ช้ากว่า …

9 algorithms  naming  history  sorting 

ฉันมีอาร์เรย์ไม่ได้เรียงลำดับ ฉันมีข้อความค้นหาที่ให้ช่วงและค่าสูงสุดจากช่วงนั้นต้องส่งคืน ตัวอย่างเช่น: array[]={23,17,9,45,78,2,4,6,90,1}; query(both inclusive): 2 6 answer: 78 ฉันจะสร้างอัลกอริทึมหรือโครงสร้างข้อมูลใดเพื่อดึงค่าสูงสุดอย่างรวดเร็วจากช่วงใดก็ได้ (มีข้อความค้นหาจำนวนมาก) แก้ไข: นี่เป็นปัญหาจริงที่เรียบง่าย ฉันสามารถมีขนาดอาร์เรย์ที่มีขนาดใหญ่ถึง 100,000 และจำนวนการสืบค้นสูงสุดถึง 100,000 ดังนั้นฉันต้องมีการประมวลผลล่วงหน้าซึ่งจะช่วยให้การตอบแบบสอบถามรวดเร็วขึ้น

9 algorithms  array 

ไม่มีใครรู้วิธีการสร้างอัลกอริทึมที่สามารถทำให้รูปเหมือนในภาพเมื่อได้รับชุดของคะแนนเฉพาะ (อาร์เรย์ 3D)

9 algorithms 

ฉันเพิ่งใช้อัลกอริทึมระยะทาง Damerau-Levenshtein จาก pseudocode บน Wikipedia ฉันไม่สามารถหาคำอธิบายใด ๆ ว่าวิธีการทำงานและชื่อตัวแปรใช้ pseudocode uninformative สมบูรณ์เช่นDA, DB, i1และj1ที่เหลือฉันเกาหัวของฉัน นี่คือการใช้งานของฉันใน Python: https://gist.github.com/badocelot/5327337 การติดตั้ง Python ช่วยให้ฉันเดินผ่านโปรแกรมและค้นหาสิ่งที่เกิดขึ้นเปลี่ยนชื่อตัวแปรเป็นชื่อที่มีประโยชน์มากขึ้น ฉันคุ้นเคยกับแนวทางของ Wagner-Fischer มากพอที่จะคำนวณระยะทางของ Levenshtein ที่ฉันมีกรอบอ้างอิง ด้วยความเสี่ยงที่จะมีความยาวมากเกินไปนี่เป็นวิธีที่ฉันเข้าใจ Damerau-Levenshtein: ตัวแปรลึกลับ: DA( last_rowในรหัสของฉัน) เป็นแผนที่ชนิดหนึ่งที่ถือแถวสุดท้ายที่แต่ละองค์ประกอบถูกเห็น ในรหัสของฉันมันเป็นพจนานุกรม Python ที่แท้จริง DB( last_match_col) เก็บคอลัมน์สุดท้ายที่ตัวอักษรbตรงกับตัวอักษรในaแถวปัจจุบัน i1( last_matching_row) คือหมายเลขแถวจากDAสำหรับตัวอักษรปัจจุบันในb j1เป็นเพียงสำเนาของDB/ last_match_colก่อนที่จะอัปเดต ในรหัสของฉันฉันเพิ่งย้ายที่last_match_colมีการปรับปรุงและกำจัดตัวแปรนี้ ค่าขนย้าย: H[i1][j1] + (i-i1-1) + 1 + …

9 algorithms  strings  algorithm-analysis 

บนอินเทอร์เน็ตฉันเจอคำถามนี้: จำแนกฟังก์ชั่นการแฮชตามวิธีการต่างๆที่พบค่าคีย์ ด้วยคำตอบเช่น วิธีการโดยตรง วิธีการลบ วิธีการโมดูโล วิธีการสกัดหลัก วิธีการของ Mid-Square วิธีการพับ วิธีการสุ่มหลอก ซึ่งฉันพบว่าแปลก ฉันคิดว่าฉันรู้มากเกี่ยวกับการคร่ำครวญ แต่นี่เป็นคำที่ไม่มีความหมายสำหรับฉันใครจะอธิบายได้บ้าง

9 algorithms  hashing 

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

9 algorithms  computer-vision 

การใช้หน่วยความจำของวัตถุจำนวนเต็มที่เขียนใน Java เปรียบเทียบ \ contrast กับการใช้หน่วยความจำของวัตถุจำนวนเต็มที่เขียนใน C ++ อย่างไร ความแตกต่างเล็กน้อยหรือไม่ ไม่แตกต่าง? ความแตกต่างใหญ่? ฉันคาดเดาว่ามันเหมือนกันเพราะ int เป็น int โดยไม่คำนึงถึงภาษา (?) เหตุผลที่ฉันถามสิ่งนี้เพราะฉันกำลังอ่านเกี่ยวกับความสำคัญของการรู้ว่าข้อกำหนดหน่วยความจำของโปรแกรมเมื่อใดจะทำให้โปรแกรมเมอร์ไม่สามารถแก้ไขปัญหาที่กำหนดได้ สิ่งที่ทำให้ฉันหลงใหลคือจำนวนหน่วยความจำที่จำเป็นสำหรับการสร้างวัตถุ Java ชิ้นเดียว ยกตัวอย่างเช่นวัตถุจำนวนเต็ม แก้ไขให้ฉันถ้าฉันผิด แต่วัตถุจำนวนเต็ม Java ต้องการหน่วยความจำ 24 ไบต์: 4 ไบต์สำหรับตัวแปรอินสแตนซ์ของมัน 16 ไบต์ของค่าใช้จ่าย (อ้างอิงถึงคลาสของวัตถุข้อมูลการรวบรวมขยะ & ข้อมูลการซิงโครไนซ์) การซ้อน 4 ไบต์ เป็นอีกตัวอย่างหนึ่งอาร์เรย์ Java (ซึ่งถูกนำมาใช้เป็นวัตถุ) ต้องการ 48 + ไบต์: ข้อมูลส่วนหัว 24 ไบต์ ค่าใช้จ่ายของวัตถุ …

9 java  c++  algorithms  data-structures  memory 

ฉันเพิ่งเจอคำถามนี้: "คุณจะได้รับนิพจน์บูลีนประกอบด้วยสตริงของสัญลักษณ์ 'จริง', 'เท็จ', 'และ', 'หรือ' และ 'และ' xor 'นับจำนวนวิธีในการวงเล็บ นิพจน์เช่นนั้นจะประเมินเป็นจริงตัวอย่างเช่นมีสองวิธีในการวงเล็บ 'true และ false xor true' ซึ่งจะประเมินค่าเป็นจริง " ฉันรู้ว่ามันเป็นปัญหาการเขียนโปรแกรมแบบไดนามิกดังนั้นฉันจึงพยายามหาวิธีแก้ปัญหาด้วยตัวเองซึ่งมีดังต่อไปนี้ สมมติว่าเรามีการแสดงออกเป็น ABC .... D '' ที่ไหน แสดงถึงการดำเนินการใด ๆ และหรือหรือ xor และตัวอักษรพิมพ์ใหญ่แสดงถึงความจริงหรือเท็จ ให้บอกว่าหลายวิธีสำหรับการแสดงออกของขนาด K นี้ที่จะสร้างความจริงคือ N. เมื่อเพิ่มค่าบูลีนใหม่ E ในการแสดงออกนี้มี 2 วิธีในการวงเล็บการแสดงออกใหม่นี้ 1 (ABC .... D) .E) เช่น ด้วยวงเล็บที่เป็นไปได้ทั้งหมดของ ABC .... เราเพิ่ม E …

9 algorithms  dynamic-programming 

มีวิธีการทั่วไปในการประเมินความเหมาะสมของอัลกอริธึมการปรับให้เหมาะสมที่สุดตัวอย่างเช่นอัลกอริทึมที่แก้ปัญหา NP-hard หรือ NP-complete วิธีเดียวที่ฉันค้นพบคือการเปรียบเทียบผลลัพธ์ของอัลกอริทึมกับโซลูชันที่ดีที่สุดที่รู้จักกันแล้ว ถ้าไม่มีมีวิธีการเฉพาะสำหรับปัญหาพิเศษหรือไม่? แก้ไขเพื่อชี้แจง: โดยการเพิ่มประสิทธิภาพฉันหมายถึงว่าผลลัพธ์ใกล้ถึงผลลัพธ์ที่ดีที่สุดเพียงใด

9 algorithms  optimization  evaluation 

ฉันจะอ้างอิงปัญหาจาก ACM 2003: พิจารณาสตริงที่มีความยาว n (1 <= n <= 100000) กำหนดการหมุนเวียนคำศัพท์ขั้นต่ำสุด ตัวอย่างเช่นการหมุนของสตริง“ alabala” คือ: alabala labalaa abalaal balaala alaalab laalaba aalabal และที่เล็กที่สุดในหมู่พวกเขาคือ "aalabal" สำหรับวิธีการแก้ปัญหา - ฉันรู้ว่าฉันต้องสร้างอาร์เรย์ต่อท้าย - และสมมุติว่าฉันสามารถทำได้ใน O (n) คำถามของฉันคือฉันจะค้นหาการหมุนที่เล็กที่สุดใน O (n) ได้อย่างไร (n = ความยาวของสตริง) ฉันสนใจปัญหานี้มากและฉันก็ยังหาวิธีแก้ปัญหาไม่ได้ ฉันสนใจในแนวคิดและวิธีการแก้ไขปัญหามากกว่าการใช้งานอย่างเป็นรูปธรรม หมายเหตุ: การหมุนต่ำสุดหมายถึงในลำดับเดียวกันกับในพจนานุกรมภาษาอังกฤษ - "dwor" อยู่ก่อน "word" เพราะ d อยู่ก่อน w แก้ไข: …

9 algorithms  complexity  suffix-trees