บทนำ

ดิสก์เป็นภาชนะเชิงเส้นที่มีการจัดทำดัชนีบล็อกผ่าน0size-1

ไฟล์คือรายการชื่อของดัชนีบล็อกที่ใช้โดยไฟล์นั้น

ตัวอย่างระบบไฟล์แสดงดังนี้:

15 ALPHA=3,5 BETA=11,10,7

"ดิสก์มี 15 บล็อกบล็อกแรกของไฟล์ ALPHA คือบล็อกดิสก์ที่ดัชนี 3 ... "

แผนที่ดิสก์สามารถวาดได้ดังนี้:

Block Index  00  01  02  03  04  05  06  07  08  09  10  11  12  13  14
Contents    |   |   |   |A0 |   |A1 |   |B2 |   |   |B1 |B0 |   |   |   |

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

เป้าหมายของคุณ:

ปล่อยลำดับการเคลื่อนไหวทางกฎหมายที่สั้นที่สุดซึ่งจะจัดเรียงข้อมูลบนดิสก์ที่กำหนด

การเคลื่อนไหวทางกฎหมาย

การย้ายมีข้อมูลสามส่วน: ชื่อไฟล์ดัชนีของบล็อกในไฟล์ที่จะย้ายและดัชนีของบล็อกดิสก์ที่เลื่อนไป

ตัวอย่างเช่น

ALPHA:1>4

"ย้ายบล็อก 1 ของไฟล์ ALPHA ไปยังบล็อก 4 ของดิสก์"

หลังจากย้ายนี้ระบบไฟล์ตัวอย่างคือตอนนี้

15 ALPHA=3,4 BETA=11,10,7

Block Index  00  01  02  03  04  05  06  07  08  09  10  11  12  13  14
Contents    |   |   |   |A0 |A1 |   |   |B2 |   |   |B1 |B0 |   |   |   |

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

ข้อมูลอาจไม่ถูกทำลาย ไฟล์ไม่สามารถแบ่งปันบล็อกได้ในทุกขั้นตอนและการเคลื่อนไหวต้องอยู่ในช่วงของดิสก์ การเคลื่อนไหวต่อไปนี้ผิดกฎหมาย : ALPHA:0>10(เป็นเจ้าของโดยเบต้า), ALPHA:3>0(ไม่มีบล็อกดังกล่าวใน ALPHA), ALPHA:0>-1(ไม่มีดัชนีดิสก์ดังกล่าว), ALPHA:0>15(ดัชนีดิสก์ใหญ่เกินไป)

ตัวอย่างที่ 1

การแก้ตัวอย่างข้างต้นเต็ม

ALPHA:0>4
BETA:0>9
BETA:2>11

ไฟล์ไม่จำเป็นต้องอยู่ติดกันในโซลูชันเพียงต่อเนื่องภายในตัวเอง

ตัวอย่างที่ 2

นี่เป็นกรณีที่ จำกัด มากขึ้น

การป้อนข้อมูล:

10 A=1,2,3 B=6,7,8 C=4,5,0

เอาท์พุท:

B:2>9
B:1>8
B:0>7
C:2>6

ความก้าวหน้าของระบบไฟล์นี้คือ:

Block Index  00  01  02  03  04  05  06  07  08  09
Contents    |C2 |A0 |A1 |A2 |C0 |C1 |BO |B1 |B2 |   |
            |C2 |A0 |A1 |A2 |C0 |C1 |BO |B1 |   |B2 |
            |C2 |A0 |A1 |A2 |C0 |C1 |BO |   |B1 |B2 |
            |C2 |A0 |A1 |A2 |C0 |C1 |   |B0 |B1 |B2 |
            |   |A0 |A1 |A2 |C0 |C1 |C2 |B0 |B1 |B2 |

ทางเลือกในการ defrag นี้จะจากไปC:2>9แล้วนำมาAลงขั้นตอนแล้วนำมาCลงขั้นตอนแล้วทำC:2>5แต่นี้จะไม่เป็นวิธีการแก้ปัญหาทางกฎหมายเพราะมันมีการเคลื่อนไหวมากขึ้นกว่าทางเลือก

การแสดง

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

"15 ALPHA=3,5 BETA=11,10,7"
[15," ","ALPHA","=",3,",",5," ","BETA","=",11,",",10,",",7]
(15,(("ALPHA",(3,5)),("BETA",(11,10,7))))
etc

ในทำนองเดียวกันผลลัพธ์อาจเป็นสิ่งที่สะดวกสำหรับภาษาของคุณในขณะที่มันถูกพิมพ์มนุษย์อ่านได้และเป็นตัวแทนของรายการเคลื่อนไหวทางกฎหมายสั่งย้ายแต่ละคนถูกอธิบายโดย 1) ชื่อไฟล์ 2) ไฟล์บล็อกดัชนี 3) new-disk-block-index

"ALPHA:1>6 BETA:2>9"
(0=>(0=>"ALPHA",1=>"1",2=>"6"), 1=>(0=>"BETA",1=>"2",2=>"9"))
["ALPHA",1,6,"BETA",2,9]
etc

ความต้องการ

รหัสของคุณจะต้องยอมรับดิสก์ทุกขนาดและจำนวนและขนาดของไฟล์

อินพุตที่ไม่ได้อธิบายสถานะระบบไฟล์เริ่มต้นตามกฎหมายสามารถนำไปสู่พฤติกรรมที่ไม่ได้กำหนด

รหัสของคุณจะต้องสร้างโซลูชันการย้ายที่สั้นที่สุดสำหรับอินพุตที่กำหนดไว้อย่างดี

ทุกการเคลื่อนไหวของคุณจะต้องถูกกฎหมาย ระบบไฟล์จะต้องอยู่ในสถานะที่ถูกต้องหลังจากใช้แต่ละขั้นตอนที่คุณสร้าง

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

ในกรณีที่มีโซลูชันสั้นที่สุดมากกว่าหนึ่งรายการสามารถเลือกได้ว่าถูกต้อง

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

Python 3 , 295 ไบต์

S,F=eval(input());d=[0]*S;E=enumerate
for n,P in F:
 for j,p in E(P):d[int(p)]=n,j
Z=[(d,())]
while Z:d,p=Z.pop(0);any(e and(e[0],e[1]+1)in d and(S<j+2or(e[0],e[1]+1)!=d[j+1])for j,e in E(d))or print(p).q;{d[j]or exec("D=d[:];D[j]=e;D[k]=0;Z+=(D,p+(e,j)),")for j,_ in E(d)for k,e in E(d)if d[k]}

ลองออนไลน์!

อีกกรณีทดสอบ

การป้อนข้อมูล:
   7 ALEF = 6,4,0 BET = 5,1 GIMEL = 3

สถานะดิสก์เริ่มต้น:
   A2 B1 __ G0 A1 B0 A0

วิธีการแก้:
   ALEF: 2> 2
   ALEF: 0> 0
   การพนัน: 1> 6
   ALEF: 1> 1

โซลูชันที่มองเห็น:
   A2 B1 __ G0 A1 B0 A0
   __ B1 A2 G0 A1 B0 A0
   A0 B1 A2 G0 A1 B0 __
   A0 __ A2 G0 A1 B0 B1
   A0 A1 A2 G0 __ B0 B1

เวอร์ชันที่ไม่ดี