ฉันเป็นผู้พัฒนาซอฟต์แวร์แผนภูมิต้นไม้บางตระกูล (เขียนด้วยภาษา C ++ และ Qt) ฉันไม่มีปัญหาจนกระทั่งลูกค้าคนใดคนหนึ่งส่งรายงานข้อผิดพลาดถึงฉัน ปัญหาคือลูกค้ามีลูกสองคนพร้อมกับลูกสาวของตนเองและทำให้เขาไม่สามารถใช้ซอฟต์แวร์ของฉันได้เนื่องจากข้อผิดพลาด

ข้อผิดพลาดเหล่านั้นเป็นผลมาจากการยืนยันและค่าคงที่ต่างๆของฉันเกี่ยวกับกราฟครอบครัวที่กำลังประมวลผล (ตัวอย่างเช่นหลังจากเดินรอบโปรแกรมระบุว่า X ไม่สามารถเป็นทั้งพ่อและปู่ของ Y)

ฉันจะแก้ไขข้อผิดพลาดเหล่านั้นโดยไม่ลบการยืนยันข้อมูลทั้งหมดได้อย่างไร

ดูเหมือนว่าคุณ (และ / หรือ บริษัท ของคุณ) มีความเข้าใจผิดขั้นพื้นฐานเกี่ยวกับต้นไม้ตระกูลที่ควรจะเป็น

ให้ฉันอธิบายฉันยังทำงานให้กับ บริษัท ที่มีต้นไม้ครอบครัวในผลงานของเรา (และเป็นหนึ่งในผลิตภัณฑ์ของ บริษัท ) และเรากำลังดิ้นรนกับปัญหาที่คล้ายกัน

ในกรณีของเราและฉันคิดว่ากรณีของคุณมาจากรูปแบบGEDCOMที่ให้ความเห็นอย่างมากเกี่ยวกับสิ่งที่ครอบครัวควรจะเป็น อย่างไรก็ตามรูปแบบนี้มีความเข้าใจผิดที่รุนแรงเกี่ยวกับลักษณะต้นไม้ครอบครัว

GEDCOM มีปัญหามากมายเช่นความไม่ลงรอยกันกับเพศเดียวกันการร่วมประเวณีระหว่างพี่น้องและอื่น ๆ ... ซึ่งในชีวิตจริงเกิดขึ้นบ่อยกว่าที่คุณคาดคิด

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

การขาดการตรวจสอบความถูกต้องทำให้เรามี "โลกแห่งความเป็นจริง" มากขึ้นง่ายขึ้นและมีความยืดหยุ่นมากขึ้น

สำหรับกรณีเฉพาะนี้ฉันขอแนะนำให้นำคำยืนยันออกเนื่องจากพวกเขาไม่ถือเป็นสากล

สำหรับการแสดงปัญหา (ที่จะเกิดขึ้น) ฉันขอแนะนำให้วาดโหนดเดียวกันหลาย ๆ ครั้งตามต้องการโดยให้คำแนะนำในการทำซ้ำโดยให้แสงสำเนาทั้งหมดเกี่ยวกับการเลือกหนึ่งในนั้น

ผ่อนคลายคำพูดของคุณ

ไม่ใช่โดยการเปลี่ยนกฎซึ่งส่วนใหญ่มีประโยชน์มากกับ 99.9% ของลูกค้าของคุณในการจับข้อผิดพลาดในการป้อนข้อมูลของพวกเขา

ให้เปลี่ยนจากข้อผิดพลาด "ไม่สามารถเพิ่มความสัมพันธ์" เป็นคำเตือนด้วย "เพิ่มต่อไป" แทน

นี่คือปัญหาเกี่ยวกับต้นไม้ครอบครัว: พวกเขาไม่ใช่ต้นไม้ พวกเขาเป็นผู้กำกับกราฟ acyclic หรือ DAG ถ้าฉันเข้าใจหลักการทางชีววิทยาของการสืบพันธุ์ของมนุษย์อย่างถูกต้องจะไม่มีวัฏจักรใด ๆ

เท่าที่ฉันรู้แม้แต่คริสเตียนก็ยอมรับการแต่งงานระหว่างลูกพี่ลูกน้องซึ่งจะทำให้ต้นไม้ครอบครัวกลายเป็น DAG ครอบครัว

คุณธรรมของเรื่องราวคือเลือกโครงสร้างข้อมูลที่เหมาะสม

ฉันเดาว่าคุณมีค่าบางอย่างที่ระบุบุคคลที่คุณสามารถใช้เช็คของคุณ

นี่เป็นสิ่งที่ยุ่งยาก สมมติว่าคุณต้องการรักษาโครงสร้างต้นไม้ฉันแนะนำสิ่งนี้:

สมมติว่า: Aมีลูกพร้อมกับลูกสาวของเขาเอง

Aเพิ่มตัวเองกับโปรแกรมที่เป็นและเป็นA Bเมื่ออยู่ในบทบาทของพ่อเราเรียกว่าเป็นแฟน

เพิ่มis_same_for_out()ฟังก์ชั่นที่บอกเอาต์พุตที่สร้างส่วนของโปรแกรมของคุณว่าลิงก์ทั้งหมดที่ไปยังBภายในควรจะAนำเสนอข้อมูล

สิ่งนี้จะทำให้การทำงานพิเศษสำหรับผู้ใช้ แต่ฉันเดาว่ามันจะง่ายต่อการติดตั้งและบำรุงรักษา

การสร้างจากนั้นคุณสามารถทำงานกับการซิงค์รหัสAและBเพื่อหลีกเลี่ยงความไม่สอดคล้องกัน

วิธีการแก้ปัญหานี้ไม่สมบูรณ์แบบแน่นอน แต่เป็นวิธีแรก

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

ฉันแนะนำให้คุณขอโทษลูกค้ารายนี้บอกเขาว่าสถานการณ์ของเขาอยู่นอกขอบเขตสำหรับซอฟต์แวร์ของคุณและคืนเงินให้เขา

คุณควรตั้งตระกูลAtreides (ทั้งที่ทันสมัยDuneหรือ Ancient Oedipus Rex ) เป็นกรณีทดสอบ คุณไม่พบข้อบกพร่องโดยใช้ข้อมูลที่ถูกสุขอนามัยเป็นกรณีทดสอบ

นี่คือหนึ่งในเหตุผลที่ภาษาเช่น "Go" ไม่มีการยืนยัน พวกมันถูกใช้เพื่อจัดการกับกรณีที่คุณอาจไม่ได้คิดถึงบ่อยเกินไป คุณควรยืนยันเป็นไปไม่ได้ไม่เพียง แต่ไม่น่า การทำหลังเป็นสิ่งที่ให้การยืนยันชื่อเสียงที่ไม่ดี ทุกครั้งที่คุณพิมพ์assert(เดินไปสิบนาทีแล้วคิดถึงมันจริงๆ

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

การยืนยันว่าปู่ทวดผู้ยิ่งใหญ่ผู้ยิ่งใหญ่ของคุณเป็นพ่อของคุณอย่างที่เป็นไปไม่ได้เป็นสิ่งที่ควรทำ

หากฉันทำงานให้กับ บริษัท ทดสอบที่ว่าจ้างให้ทดสอบซอฟต์แวร์ของคุณแน่นอนว่าฉันจะได้นำเสนอสถานการณ์นั้น ทำไม? เด็กและเยาวชนทุกคน 'ผู้ใช้' ที่ชาญฉลาดจะทำสิ่งเดียวกันและเพลิดเพลินกับผลลัพธ์ 'รายงานบั๊ก'

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

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

อย่างไรก็ตามดูเหมือนว่าคุณกำลังยืนยันว่ามีเพียงเส้นทางเดียวระหว่างบุคคลและหนึ่งในบรรพบุรุษของพวกเขา รับรองได้ว่าจะไม่มีรอบ แต่ก็เข้มงวดเกินไป การพูดคุยทางชีวภาพการลงตำแหน่งเป็นกราฟที่มีการนำทาง (DAG) กรณีที่คุณมีเป็นกรณีที่เลวลงอย่างแน่นอน แต่สิ่งประเภทนั้นเกิดขึ้นตลอดเวลาบนต้นไม้ขนาดใหญ่

ตัวอย่างเช่นหากคุณดูบรรพบุรุษ 2 ^ n คุณมีรุ่นที่ n หากไม่มีการเหลื่อมกันคุณจะมีบรรพบุรุษมากกว่า 1,000 AD กว่าคนที่ยังมีชีวิตอยู่ ดังนั้นจะต้องมีการทับซ้อนกัน

อย่างไรก็ตามคุณมักจะได้รับรอบที่ไม่ถูกต้องเพียงข้อมูลที่ไม่ดี หากคุณกำลังสำรวจต้นไม้จะต้องจัดการกับวัฏจักร คุณสามารถทำได้ในแต่ละอัลกอริทึมหรือโหลด ฉันทำมันโหลดแล้ว

การค้นหาวัฏจักรที่แท้จริงในต้นไม้สามารถทำได้สองสามวิธี วิธีที่ผิดคือการทำเครื่องหมายทุกบรรพบุรุษจากบุคคลที่กำหนดและเมื่อข้ามถ้าคนที่คุณกำลังจะไปขั้นต่อไปมีการทำเครื่องหมายแล้วตัดการเชื่อมโยง สิ่งนี้จะตัดความสัมพันธ์ที่อาจถูกต้อง วิธีที่ถูกต้องที่จะทำคือเริ่มต้นจากแต่ละคนและทำเครื่องหมายบรรพบุรุษแต่ละคนด้วยเส้นทางไปยังบุคคลนั้น หากเส้นทางใหม่มีเส้นทางปัจจุบันเป็นเส้นทางย่อยก็เป็นวงจรและควรจะเสีย คุณสามารถจัดเก็บพา ธ เป็น vector <bool> (MFMF, MFFFMF, ฯลฯ ) ซึ่งทำให้การเปรียบเทียบและการจัดเก็บรวดเร็วมาก

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

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

อีกคำตอบที่เยาะเย้ยอย่างจริงจังสำหรับคำถามโง่ ๆ :

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

แม้ว่าเราต้องการละเว้นความสัมพันธ์แบบต้องห้ามในท้องถิ่นตามที่กล่าวไว้ในที่นี้ แต่ก็มีวิธีการทางกฎหมายที่สมบูรณ์แบบและไม่คาดคิดอย่างสมบูรณ์ในการนำวงจรมาสู่ต้นไม้

ตัวอย่างเช่น: http://en.wikipedia.org/wiki/Cousin_marriage

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

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

ผลกระทบทางกฎหมายที่อาจเกิดขึ้นข้าง ๆ กันอย่างแน่นอนดูเหมือนว่าคุณจำเป็นต้องปฏิบัติต่อ 'โหนด' บนแผนภูมิต้นไม้ในฐานะบุคคลที่เป็นบรรพบุรุษมากกว่าที่จะสมมติว่าโหนดนั้นสามารถเป็นบุคคลเพียงคนเดียว

ให้โหนดของต้นไม้รวมถึงบุคคลและผู้สืบทอด - จากนั้นคุณสามารถมีโหนดอื่นที่ลึกกว่าต้นไม้ที่มีบุคคลเดียวกันกับผู้สืบทอดที่แตกต่างกัน

คำตอบสองสามข้อได้แสดงวิธีที่จะรักษาคำยืนยัน / ค่าคงที่ แต่ดูเหมือนจะเป็นการใช้คำยืนยัน / ค่าคงที่ในทางที่ผิด การยืนยันว่าต้องแน่ใจว่าสิ่งที่ควรเป็นจริงนั้นเป็นจริงและผู้รุกรานต้องแน่ใจว่าสิ่งที่ไม่ควรเปลี่ยนแปลงนั้นไม่เปลี่ยนแปลง

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

แผนภูมิต้นไม้ครอบครัวของคุณควรใช้ความสัมพันธ์โดยตรง วิธีนี้คุณจะไม่มีวงจร

ข้อมูลลำดับวงศ์ตระกูลนั้นมีลักษณะเป็นวงจรและไม่เหมาะกับกราฟแบบวนรอบดังนั้นหากคุณมีการยืนยันกับวงจรคุณควรลบออก

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

ในการคำนวณคุณอาจต้องปรับปรุงตรรกะของคุณเพื่อจัดการกราฟแบบวงกลมเพื่อที่ว่าโหนดจะไม่ได้รับการเยี่ยมชมมากกว่าหนึ่งครั้งหากมีรอบ

สิ่งที่สำคัญที่สุดคือการavoid creating a problemดังนั้นฉันเชื่อว่าคุณควรใช้ความสัมพันธ์โดยตรงเพื่อหลีกเลี่ยงวงจร

ดังที่ @markmywords กล่าวไว้#include "fritzl.h"

recheck your data structureในที่สุดผมก็ต้องบอกว่า อาจมีบางอย่างผิดปกติที่นั่น (อาจเป็นรายการที่เชื่อมโยงแบบสองทิศทางแก้ปัญหาของคุณ)

ยืนยันไม่รอดความเป็นจริง

โดยทั่วไปแล้วการยืนยันไม่รอดจากการสัมผัสกับข้อมูลจริง เป็นส่วนหนึ่งของกระบวนการวิศวกรรมซอฟต์แวร์ในการตัดสินใจว่าข้อมูลใดที่คุณต้องการจัดการและอยู่นอกขอบเขต

กราฟครอบครัวแบบวงกลม

เกี่ยวกับครอบครัว "ต้นไม้" (อันที่จริงมันเป็นกราฟที่พัดเต็มรวมถึงรอบ) มีเกร็ดเล็กเกร็ดน้อยที่ดี:

ฉันแต่งงานกับหญิงม่ายที่มีลูกสาวโต พ่อของฉันที่มาเยี่ยมเราบ่อยครั้งหลงรักลูกสาวของฉันและแต่งงานกับเธอ เป็นผลให้พ่อของฉันกลายเป็นลูกชายของฉันและลูกสาวของฉันกลายเป็นแม่ของฉัน หลังจากนั้นไม่นานฉันก็ให้ลูกชายภรรยาของฉันซึ่งเป็นพี่ชายของพ่อของฉันและลุงของฉัน ภรรยาของพ่อของฉัน (ซึ่งเป็นลูกสาวของฉันและแม่ของฉัน) มีลูกชายด้วย เป็นผลให้ฉันได้รับพี่ชายและหลานชายในบุคคลเดียวกัน ภรรยาของฉันตอนนี้ยายของฉันเพราะเธอเป็นแม่ของฉัน ดังนั้นฉันเป็นสามีของภรรยาของฉันและในเวลาเดียวกันหลานชายของภรรยาของฉัน กล่าวอีกนัยหนึ่งฉันเป็นปู่ของฉันเอง

สิ่งต่าง ๆ น่าประหลาดใจยิ่งขึ้นเมื่อคุณนำตัวแทนหรือ "บิดาคลุมเครือ" มาพิจารณา

วิธีจัดการกับสิ่งนั้น

กำหนดรอบเป็นนอกขอบเขต

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

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

อนุญาตความสัมพันธ์ด้วยตนเอง

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

ผู้ใช้สามารถจัดการกรณีที่หายากด้วยมือ แบบจำลองข้อมูลของคุณจะยังคงค่อนข้างง่ายและการยืนยันของคุณจะอยู่รอด

ระมัดระวังความสัมพันธ์ด้วยตนเอง มีสิ่งล่อใจที่จะทำให้สามารถกำหนดค่าได้อย่างสมบูรณ์และสร้างโมเดลข้อมูลที่กำหนดค่าได้อย่างสมบูรณ์ สิ่งนี้จะไม่ทำงาน: ซอฟต์แวร์ของคุณจะไม่ขยายคุณจะได้รับข้อผิดพลาดที่แปลกและในที่สุดอินเทอร์เฟซผู้ใช้จะไม่สามารถใช้งานได้ รูปแบบการต่อต้านนี้เรียกว่า"soft coding"และ"The WTF รายวัน"เต็มไปด้วยตัวอย่างสำหรับสิ่งนั้น

ทำให้แบบจำลองข้อมูลของคุณมีความยืดหยุ่นมากขึ้นข้ามการยืนยันยืนยันค่าคงที่

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

ในกรณีนี้คุณควรทดสอบซอฟต์แวร์อย่างกว้างขวาง คุณต้องข้ามการยืนยันเกือบทั้งหมดดังนั้นจึงมีโอกาสที่ดีสำหรับข้อบกพร่องเพิ่มเติม

ใช้เครื่องสร้างข้อมูลการทดสอบเพื่อตรวจสอบกรณีทดสอบที่ผิดปกติ มีห้องสมุดสำหรับการตรวจสอบอย่างรวดเร็วมีHaskell , ErlangหรือC สำหรับ Java / Scala มีScalaCheckและNyaya แนวคิดการทดสอบอย่างหนึ่งคือการจำลองประชากรสุ่มปล่อยให้มันเป็นการรวมกันแบบสุ่มจากนั้นให้ซอฟต์แวร์ของคุณนำเข้าก่อนแล้วจึงส่งออกผลลัพธ์ ความคาดหวังจะเป็นไปได้ว่าการเชื่อมต่อทั้งหมดในเอาท์พุทก็อยู่ในอินพุทและข้อรองด้วย

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

• ลุงยังคงเป็นลุงแม้เมื่อคุณเพิ่ม "ความสัมพันธ์แบบโรแมนติก" มากขึ้น
• เด็กทุกคนมีผู้ปกครอง
• ประชากรที่มีสองชั่วอายุคนมีปู่ย่าตายายอย่างน้อยหนึ่งคน

หรืออาจเป็นเทคนิค:

• ซอฟต์แวร์ของคุณจะไม่ผิดพลาดบนกราฟมากถึง 10,000 ล้านสมาชิก (ไม่ว่าจะเชื่อมโยงกันกี่ครั้ง)
• ซอฟต์แวร์ของคุณปรับขนาดด้วย O (จำนวนโหนด) และ O (จำนวนขอบ ^ 2)
• ซอฟต์แวร์ของคุณสามารถบันทึกและโหลดกราฟครอบครัวใหม่ได้สูงสุดถึง 10,000 ล้านสมาชิก

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

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

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

ทำซ้ำพ่อ (หรือใช้ symlink / การอ้างอิง)

ตัวอย่างเช่นถ้าคุณใช้ฐานข้อมูลแบบลำดับชั้น:

$ #each person node has two nodes representing its parents.
$ mkdir Family
$ mkdir Family/Son
$ mkdir Family/Son/Daughter
$ mkdir Family/Son/Father
$ mkdir Family/Son/Daughter/Father
$ ln -s Family/Son/Daughter/Father Family/Son/Father
$ mkdir Family/Son/Daughter/Wife
$ tree Family
Family
└── Son
    ├── Daughter
    │   ├── Father
    │   └── Wife
    └── Father -> Family/Son/Daughter/Father

4 directories, 1 file