การทดสอบว่าตัวอักษรสามารถกำหนดเวลาเพื่อให้ได้คำในภาษาปกติ


23

ผมแก้ไขภาษาปกติ LLบนตัวอักษรΣΣและผมคิดว่าปัญหาที่เกิดขึ้นต่อไปนี้ที่ผมเรียกการตั้งเวลาตัวอักษรสำหรับL Lอย่างไม่เป็นทางการการป้อนข้อมูลให้ฉันnnตัวอักษรและช่วงเวลาสำหรับแต่ละตัวอักษร (เช่นตำแหน่งที่น้อยที่สุดและสูงสุด) และเป้าหมายของฉันคือการวางตัวอักษรแต่ละตัวในช่วงเวลาของมันเพื่อให้ไม่มีตัวอักษรสองตัวถูกแมปไปยังตำแหน่งเดียวกัน ส่งผลให้nnคำ -letter อยู่ในL Lอย่างเป็นทางการ:

  • การป้อนข้อมูล: nnอเนกประสงค์( ฉัน , L ฉัน , r ฉัน )(ai,li,ri)ที่ฉันΣและ1 ลิตรฉันr ฉันnเป็นจำนวนเต็มaiΣ1lirin
  • ขาออกจะมี bijection F : { 1 , ... , n } { 1 , ... , n }f:{1,,n}{1,,n}เช่นที่ลิตรฉัน( ฉัน) R ฉันlif(i)riทั้งหมดของฉันiและ- 1 ( 1 )- 1 ( n ) Laf1(1)af1(n)L

เห็นได้ชัดว่าปัญหานี้อยู่ใน NP โดยคาดเดา bijection ffและตรวจสอบการเป็นสมาชิกของLLใน PTIME คำถามของฉัน: มีภาษาปกติLLเช่นว่าปัญหาการตั้งเวลาจดหมายสำหรับLLนั้นยากหรือไม่

ข้อสังเกตเบื้องต้นบางประการ:

  • ดูเหมือนว่ามีการศึกษาปัญหาที่คล้ายกันในการจัดตารางเวลา: เราสามารถเห็นปัญหาในการจัดตารางงานต้นทุนต่อหน่วยในเครื่องเดียวขณะที่เคารพวันที่เริ่มต้นและสิ้นสุด อย่างไรก็ตามปัญหาหลังนี้เห็นได้ชัดใน PTIME ด้วยวิธีโลภและฉันไม่เห็นอะไรเลยในวรรณคดีการจัดตารางเวลาสำหรับกรณีที่งานมีข้อความกำกับและเราต้องการบรรลุคำในภาษาปกติเป้าหมาย
  • วิธีการหนึ่งที่อื่น ๆ เพื่อดูปัญหาที่เกิดขึ้นเป็นกรณีพิเศษของปัญหาการจับคู่สูงสุดฝ่าย (ระหว่างตัวอักษรและตำแหน่ง) แต่อีกครั้งก็ยากที่จะแสดงข้อ จำกัด ว่าเราจะต้องตกอยู่ในLL
  • ในกรณีเฉพาะที่LLเป็นภาษาของรูปแบบu uสำหรับคำบางคำที่ตายตัวuu (เช่น( a b ) (ab) ) จากนั้นปัญหาการตั้งเวลาจดหมายสำหรับLLอยู่ใน PTIME ด้วยอัลกอริทึมโลภง่าย: สร้างคำจากซ้าย ไปทางขวาและใส่ในแต่ละตำแหน่งหนึ่งของตัวอักษรที่มีอยู่ซึ่งเป็นญาติที่ถูกต้องเพื่อLLและมีเวลาที่มีขนาดเล็กที่สุดRriฉัน (หากไม่มีตัวอักษรที่ใช้ได้ถูกต้องล้มเหลว) อย่างไรก็ตามสิ่งนี้ไม่ได้พูดถึงภาษาปกติLโดยพลการLเพราะสำหรับภาษาดังกล่าวเราอาจมีตัวเลือกประเภทของจดหมายที่จะใช้
  • ดูเหมือนอัลกอริทึมแบบไดนามิกควรใช้งานได้ แต่ในความเป็นจริงมันไม่ง่ายเลย: ดูเหมือนว่าคุณจะต้องจดจำชุดของตัวอักษรที่คุณได้จดไว้จนถึงตอนนี้ แน่นอนเมื่อสร้างคำจากซ้ายไปขวาเมื่อคุณมาถึงตำแหน่งที่1iรัฐของคุณขึ้นอยู่กับตัวอักษรที่คุณใช้จนหมด คุณไม่สามารถจำทั้งชุดได้เพราะจะมีหลายรัฐแทน แต่มันไม่ง่ายเลยที่จะ "สรุป" มัน (เช่นจำนวนสำเนาของจดหมายแต่ละฉบับที่ใช้) เพราะรู้ว่าคุณใช้สำเนาชุดไหนดูเหมือนว่าคุณจำเป็นต้องจำเมื่อคุณบริโภคพวกเขา (หลังจากที่คุณบริโภคไปแล้ว พวกเขามีตัวอักษรมากขึ้น) แม้จะมีภาษาเช่น( a b | b a ) (ab|ba)อาจมีอยู่แล้วจะมีความซับซ้อนข้อ จำกัด เกี่ยวกับเมื่อคุณควรเลือกที่จะใช้และเมื่อคุณควรเลือกที่จะใช้ซึ่งขึ้นอยู่กับตัวอักษรที่คุณจะต้องต่อมาและเมื่อตัวอักษรกลายเป็นใช้ได้abba
  • อย่างไรก็ตามเนื่องจากภาษาปกติLLได้รับการแก้ไขและไม่สามารถจดจำข้อมูลได้มากฉันจึงมีปัญหาในการค้นหาปัญหา NP-hard ที่ฉันสามารถลดได้

คุณสามารถรับความสมบูรณ์แบบของ NP สำหรับ PTIME ได้ไหม?
Lance Fortnow

3
@ LanceFortnow แน่นอน คุณสามารถวาง 3CNF เพื่อให้ทุกตัวแปรเกิดขึ้นในจำนวนตัวอักษรที่เท่ากัน เข้ารหัสx ฉันเข้าไปใน0 ฉันหรือ1 ฉันแล้วในกรณีการตั้งเวลาตัวอักษรสัญลักษณ์( , ) , , ได้รับการแก้ไขในขณะที่ส่วนที่เหลือเป็นครึ่ง0 's ครึ่ง1 ' s ในเวลาพหุนามหนึ่งสามารถตรวจสอบว่าสตริงเข้ารหัส 3CNF เบาะซึ่งประเมินว่าเป็นจริง xผม0ผม1ผม( , ) , , 01
Willard Zhan

นอกจากนี้คุณยังสามารถสรุปปัญหาให้กับ "ตำแหน่งโดยพลการ" (ไม่ จำกัด เพียง 1..n) บางทีมันง่ายกว่าที่จะพิสูจน์ความแข็ง (ถ้ายาก)
Marzio De Biasi

@MarzioDeBiasi: ฉันไม่แน่ใจว่าฉันเข้าใจคุณหมายความว่าตำแหน่งของตัวอักษรอาจเป็นชุดย่อยโดยพลการใด ๆ มากกว่าช่วง? ฉันไม่รู้ว่านี่มันยากหรือเปล่า (มันเริ่มคล้ายปัญหาจับคู่ที่สมบูรณ์แบบนิดหน่อย) แต่รุ่นที่มีช่วงเวลาจะช่วยให้อัลกอริทึมโลภเมื่อL = u ดังนั้นฉันหวังว่ามันจะง่ายขึ้น L = คุณ* * * *
a3nm

@ a3nm: ไม่ฉันหมายความว่าคุณสามารถสรุปข้อ จำกัด การวางr in ; คุณขอคำใน L ที่มีตัวอักษรอย่างน้อยหนึ่งฉันในช่วง[ Lฉัน . r i ] ; กล่าวอีกนัยหนึ่งคุณไม่ได้ "สร้าง" คำเต็มความยาวnแต่ขอคำที่มีความยาวโดยพลการที่มีตัวอักษรที่กำหนดในช่วงที่อนุญาต ฉันไม่ทราบว่าสิ่งนี้เปลี่ยนแปลงความซับซ้อนของปัญหาหรือไม่ แต่ในกรณีนี้คุณต้องเผชิญกับ "ดัชนี" ที่อาจไม่ถูกผูกมัดด้วยพหุนามตามความยาวของอินพุต Rผมnai[li..ri]n
Marzio De Biasi

คำตอบ:


7

ปัญหาคือ NP-hard สำหรับL = A โดยที่Aเป็นภาษา จำกัด ที่มีคำต่อไปนี้:L=AA

  • x 111 , x 000 ,x111x000
  • y 100 , y 010 , y 001 ,y100y010y001
  • 00 c 11 , 01 c 10 , 10 c 01และ 11 c 0000c1101c1010c0111c00

การลดลงมาจากปัญหาการวางแนวกราฟซึ่งเป็นที่รู้จักกันว่า NP-hard (ดูที่https://link.springer.com/article/10.1007/s00454-017-9884-9 ) ในปัญหานี้เราจะได้รับกราฟแบบไม่ระบุทิศทาง 3 รูปแบบซึ่งจุดยอดทุกจุดจะมีป้ายกำกับว่า " { 1 } " หรือ " { 0 , 3 } " เป้าหมายคือกำหนดขอบของกราฟเพื่อให้ขอบเขตของจุดยอดทุกจุดอยู่ในการกำหนดป้ายกำกับจุดยอดนั้น{1}{0,3}

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

  • อักขระx , y , และcเป็นช่วงเวลาที่กำหนดเพียงหนึ่งดัชนีเท่านั้น กล่าวอีกนัยหนึ่งเมื่อใดก็ตามที่อักขระเหล่านี้ถูกวางไว้xyc
  • For every triple (i,l,r)(i,l,r) present in the instance with i{0,1}i{0,1}, the triple (1i,l,r)(1i,l,r) is also present.
  • ถ้า( α , l , r )และ( α , l , r )เป็นทั้งสามสิ่งที่มีอยู่ในอินสแตนซ์แล้วทั้งl < l r < rหรือl < l r < r หรือ{ α , α } = { 0 , 1 }กับl = l(α,l,r)(α,l,r)l<lr<rl<lr<r{α,α}={0,1}' < R = R 'l = l'< r = r'
  • ถ้า( α , L , R )เป็นสามแล้วจำนวนอเนกประสงค์( α ' , L ' , R ' )กับL L 'R 'Rเป็นสิ่งr - L + 1( α , l , r )( α', l', r')l l'r'rr - l + 1

หมายเหตุบทแทรกต่อไปนี้พิสูจน์ในตอนท้ายของโพสต์นี้

แทรก: สำหรับรายชื่อที่ถูกต้องของอเนกประสงค์ตัวอักษรx , YและCจะต้องวางตรงตามที่ระบุโดยอเนกประสงค์และสำหรับคู่ของอเนกประสงค์ใด ๆ( 0 , L , R )และ( 1 , L , R )ที่ สำหรับตัวละครสองตัวสามที่จะต้องวางไว้ที่ดัชนีLและRxY( 0 , l , r )( 1 , l , r )ล.R

จากนั้นความคิดของการลดมีดังต่อไปนี้

เราใช้คู่อเนกประสงค์( 0 , l , r )และ( 1 , l , r )เพื่อแสดงขอบ ขอบไประหว่างปลายทางที่ดัชนีลิตรและที่ดัชนีR สมมติว่าเราผลิตรายการอเนกประสงค์ที่ถูกต้องตัวละครจากทั้งสองนี้จะต้องวางไว้ที่lและrดังนั้นเราจึงสามารถปฏิบัติตามลำดับที่พวกเขาวางไว้เป็นการระบุทิศทางของขอบ นี่คือ1 "หัว" ของขอบและ0คือ "หาง" กล่าวอีกนัยหนึ่งถ้า1ถูกวางไว้ที่r( 0 , l , r )( 1 , l , r )ล.Rล.R101Rแล้วจุดขอบจากลิตรเพื่อRและถ้า1จะอยู่ที่ลิตรแล้วจุดขอบจากRเพื่อลิตรล.R1ล.Rล.

ในการเป็นตัวแทนของจุดยอดเราวางอักขระxหรือyที่ดัชนีและใช้อักขระสามตัวถัดไปเป็นจุดปลายของขอบทั้งสามซึ่งสัมผัสกับจุดยอด โปรดทราบว่าถ้าเราวางxทั้งสามขอบที่จุดสุดยอดจะต้องชี้ไปในทิศทางเดียวกัน (ทั้งหมดลงในจุดสุดยอดหรือออกทั้งหมดของจุดสุดยอด) เพียงเพราะสตริงที่มีในภาษา จำกัด จุดดังกล่าวมี outdegree 0หรือ3ดังนั้นเราจึงวางxว่าสำหรับจุดที่มีป้ายกำกับ{ 0 , 3 } ถ้าเราวางyxYxA03x{ 0 , 3 }Yว่าหนึ่งในสามของขอบที่จุดสุดยอดจะต้องชี้ไปในทิศทางเดียวกันเนื่องจากสตริงใน จุดดังกล่าวมี outdegree 1ดังนั้นเราจึงวางYว่าสำหรับจุดที่มีป้ายกำกับ{ 1 }A1Y{ 1 }

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

เพื่อต่อสู้กับสิ่งนี้เราได้เพิ่มโครงสร้างพื้นฐานเพิ่มเติม โดยเฉพาะอย่างยิ่งเราเพิ่ม "จุดยอดครอสโอเวอร์" จุดยอดแบบครอสโอเวอร์เป็นจุดสุดยอดของระดับ4ซึ่งมีการจับคู่ขอบซึ่งภายในแต่ละคู่หนึ่งขอบจะต้องชี้ไปที่จุดยอดแบบครอสโอเวอร์และอีกหนึ่งตัว กล่าวอีกนัยหนึ่งจุดยอดครอสโอเวอร์จะทำงานเหมือนกับขอบ "ข้าม" เพียงสองจุด เราเป็นตัวแทนยอดครอสโอเวอร์โดยการวางตัวละครที่บางส่วนดัชนีฉัน จากนั้นโปรดทราบว่าภาษาAจำกัด อักขระที่i - 1และi + 2ให้อยู่ตรงกันข้าม (หนึ่ง0และหนึ่ง1 ) และอักขระที่i - 24ciAi1i+201i2และฉัน+ 1จะเป็นตรงข้าม ดังนั้นหากเราใช้ดัชนีเหล่านี้เป็นจุดสิ้นสุดสำหรับสี่ขอบที่จุดยอดครอสโอเวอร์พฤติกรรมจะเป็นไปตามที่อธิบายไว้: ขอบทั้งสี่เป็นคู่และทุกคู่มีหนึ่งคะแนนในหนึ่งจุดi+1

How do we actually place these crossovers? Well suppose we have two intervals (l,r)(l,r) and (l,r)(l,r) which overlap. WLOG, l<l<r<rl<l<r<r. We add the crossover character into the middle (between ll and rr). (Let's say that all along we spaced everything out so far that there's always enough space, and at the end we will remove any unused space.) Let the index of the crossover character be ii. Then we replace the four triples (0,l,r)(0,l,r), (1,l,r)(1,l,r), (0,l,r)(0,l,r), and (1,l,r)(1,l,r) with eight triples with two each (one with character 00 and one with character 11) for the following four intervals (l,i1)(l,i1), (i+2,r)(i+2,r), (l,i2)(l,i2), (i+1,r)(i+1,r). Notice that the intervals don't overlap in the bad way anymore! (After this change, if two intervals overlap, one is strictly inside the other.) Furthermore, the edge from ll to rr is replaced by an edge from ll to the crossover vertex followed by the edge from there to rr; these two edges are paired at the crossover vertex in such a way that one is pointed in and one is pointed out; in other words, the two edges together behave just like the one edge they are replacing.

In some sense, putting in this crossover vertex "uncrossed" two edges (whose intervals were overlapping). It is easy to see that adding the crossover vertex can't cause any additional edges to become crossed. Thus, we can uncross every pair of crossing edges by inserting enough crossover vertices. The end result still corresponds to the Graph Orientation instance, but now the list of triples is valid (the properties are all easy to verify now that we have "uncrossed" any crossing edges), so the lemma applies, the edges must behave as described, and the correspondence is actually an equivalence. In other words, this reduction is correct.


proof of lemma

Lemma: for a valid list of triples, the characters xx, yy, and cc must be placed exactly as indicated by the triples, and for any pair of triples (0,l,r)(0,l,r) and (1,l,r)(1,l,r), the two characters for that triple must be placed at indices ll and rr.

proof:

We proceed by induction on the triples by interval length. In particular, our statement is the following: for any kk if some triple has interval length kk then the character in that triple must be placed as described in the lemma.

Base case: for k=0k=0, the triple must be placing a character xx, yy, or cc at the single index inside the interval. This is exactly as described in the lemma.

Inductive case: assume the statement holds for any kk less than some kk. Now consider some triple with interval length kk. Then that triple must be of the form (i,l,r)(i,l,r) with r=l+k1r=l+k1 and i{0,1}i{0,1}. The triple (1i,l,r)(1i,l,r) must also be present. The number of triples (α,l,r)(α,l,r) with llrrllrr is exactly rl+1=krl+1=k. These triples include triples (0,l,r)(0,l,r) and (1,l,r)(1,l,r) but also k2k2 other triples of the form (α,l,r)(α,l,r) with l<lr<rl<lr<r. These other triples all have interval length smaller than kk, so they all must place their characters as specified in the lemma. The only way for this to occur is if these triples place characters in every index starting at index l+1l+1 and ending at index r+1r+1. Thus, our two triples (0,l,r)(0,l,r) and (1,l,r)(1,l,r) must place their characters at indices ll and rr, as described in the lemma, concluding the inductive case.

By induction, the lemma is correct.


Thanks a lot for this elaborate proof, and with a very simple language! I think it is correct, the only thing I'm not sure about is the claim that "adding the crossover vertex can't cause any additional edges to become crossed". Couldn't it be the case that the interval (l,r)(l,r) included some other interval (l,r)(l′′,r′′) with llrrll′′r′′r, and now one of (l,i1)(l,i1) and (i+2,r)(i+2,r) crosses it? It seems like the process still has to converge because the intervals get smaller, but that's not completely clear either because of the insertion of crossover vertices. How should I see it?
a3nm

If l<l<r<rl<l<r<r, then you can insert the new indices for the new crossover vertex immediately to the right of ll. This causes the new indices (i±i± a bit) to be in exactly those intervals that used to contain ll. It should be easy to see that adding a crossover vertex can add a new crossing with some other interval only if the new indices fall in the other interval. If l<l<r<rl<l′′<r′′<r then the new indices do not fall into the interval (l,r)(l′′,r′′). If l<l<r<rl<l′′<r′′<r then the new indices might fall into the interval (l,r)(l′′,r′′), but only if ll already fell into that
Mikhail Rudoy

(continued) interval. In this case, you aren't actually creating a new crossing, just turning an old crossing with the old interval (l,r)(l,r) into a new crossing with the interval (i+something,r)(i+something,r)
Mikhail Rudoy

I guess in your second message you meant "with the old interval (l,r)(l,r)" rather than "(l,r)(l,r)"? But OK, I see it: when you add the crossing vertex, the only bad case would be an interval II that overlap with a new interval without overlapping with the corresponding interval. This cannot happen for supersets of (l,r)(l,r) or of (l,r)(l,r): if they overlap with a new interval then they overlapped with the old one. Likewise for subsets of (l,r)(l,r) or (l,r)(l,r) for the reason that you explain. So I agree that this proof looks correct to me. Thanks again!
a3nm

2

@MikhailRudoy was the first to show NP-hardness, but Louis and I had a different idea, which I thought I could outline here since it works somewhat differently. We reduce directly from CNF-SAT, the Boolean satisfiability problem for CNFs. In exchange for this, the regular language LL that we use is more complicated.

The key to show hardness is to design a language LL that allows us to guess a word and repeat it multiple times. Specifically, for any number kk of variables and number mm of clauses, we will build intervals that ensure that all words ww of LL that we can form must start with an arbitrary word uu of length kk on alphabet {0,1}{0,1} (intuitively encoding a guess of the valuation of variables), and then this word uu is repeated m times (which we will later use to test that each clause is satisfied by the guessed valuation).

To achieve this, we will fix the alphabet A={0,1,#,0,1} and the language: L:=(0|1)(#(00|11))#(0|1). The formal claim is a bit more complicated:

Claim: For any numbers k,mN, we can build in PTIME a set of intervals such that the words in L that can be formed with these intervals are precisely:

{u(#(˜u˜u)#(uu))m#˜uu{0,1}k}

where ˜u denotes the result of reversing the order of u and swapping 0's and 1's, where u denotes the result of adding a prime to all letters in u, and where xy for two words x of y of length p is the word of length 2p formed by taking alternatively one letter from x and one letter from y.

Here's an intuitive explanation of the construction that we use to prove this. We start with intervals that encode the initial guess of u. Here is the gadget for n=4 (left), and a possible solution (right):

choice gadget

It's easy to show the following observation (ignoring L for now): the possible words that we can form with these intervals are exactly u#˜u for u{0,1}k. This is shown essentially like the Lemma in @MikhailRudoy's answer, by induction from the shortest intervals to the longest ones: the center position must contain #, the two neighboring positions must contain one 0 and one 1, etc.

We have seen how to make a guess, now let's see how to duplicate it. For this, we will rely on L, and add more intervals. Here's an illustration for k=3:

duplication gadget

For now take L:=(0|1)(#(00|11))#(0|1). Observe how, past the first #, we must enumerate alternatively an unprimed and a primed letter. So, on the un-dashed triangle of intervals, our observation above still stands: even though it seems like these intervals have more space to the right of the first #, only one position out of two can be used. The same claim holds for the dashed intervals. Now, L further enforces that, when we enumerate an unprimed letter, the primed letter that follows must be the same. So it is easy to see that the possible words are exactly: u#(˜u˜u)#u for u{0,1}k.

Now, to show the claim, we simply repeat this construction m times. Here's an example for k=3 and m=2, using now the real definition of L above the statement of the claim:

duplication gadget, repeated

As before, we could show (by induction on m) that the possible words are exactly the following: u(#˜u˜u#uu)2#˜u for u{0,1}k. So this construction achieves what was promised by the claim.

Thanks to the claim we know that we can encode a guess of a valuation for the variables, and repeat the valuation multiple times. The only missing thing is to explain how to check that the valuation satisfies the formula. We will do this by checking one clause per occurrence of u. To do this, we observe that without loss of generality we can assume that each letter of the word is annotated by some symbol provided as input. (More formally: we could assume that in the problem we also provide as input a word w of length n, and we ask whether the intervals can form a word u such that wu is in L.) The reason why we can assume this is because we can double the size of each interval, and add unit intervals (at the bottom of the picture) at odd positions to carry the annotation of the corresponding even position:

unit annotations

Thanks to this observation, to check clauses, we will define our regular language L to be the intersection of two languages. The first language enforces that the sub-word on even positions is a word in L, i.e., if we ignore the annotations then the word must be in L, so we can just use the construction of the claim and add some annotations. The second language L will check that the clauses are satisfied. To do this, we will add three letters in our alphabet, to be used as annotations: +, , and ϵ. At clause 1im, we add unit intervals to annotate by + the positions in the i-th repetition of u corresponding to variables occurring positively in clause i, and annotate by~ the positions corresponding to negatively occurring variables. We annotate everything else by~ϵ. It is now clear that L can check that the guessed valuation satisfies the formula, by verifying that, between each pair of consecutive # symbols that contain an occurrence of u (i.e., one pair out of two), there is some literal that satisfies the clause, i.e., there must be one occurrence of the subword +1 or of the subword 0.

This concludes the reduction from CNF-SAT and shows NP-hardness of the letter scheduling problem for the language L.

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.