ขนาดที่เล็กที่สุดของการทำสัญญา DAG เป็น DAG ใหม่

เรามี DAG เรามีฟังก์ชั่นบนโหนด (พูดอย่างอิสระเรานับจำนวนโหนด) เราต้องการสร้างกราฟกำกับใหม่ด้วยกฎเหล่านี้:$F\colon V\to \mathbb N$

1. เฉพาะโหนดที่มีหมายเลขเท่ากันเท่านั้นที่สามารถทำการต่อสัญญาในโหนดใหม่เดียวกันได้ Y' (อย่างไรก็ตาม, .)$F(x) \neq F(y) \Rightarrow x' \neq y'$$x' \neq y'\nRightarrow F(x) \neq F(y)$
2. เราได้เพิ่มทุกขอบเก่าระหว่างโหนดใหม่: $(x,y) \in E \land x' \neq y' \iff (x',y')\in E'$E'
3. กราฟใหม่นี้ยังคงเป็น DAG

อะไรคือสิ่งที่น้อยที่สุด$|V'|$? อัลกอริทึมคืออะไรสร้างกราฟใหม่ที่น้อยที่สุด

วิธีหนึ่งในการแก้ปัญหานี้คือใช้การเขียนโปรแกรมเชิงเส้นจำนวนเต็ม (ILP) มาจัดการปัญหาของเวอร์ชันการตัดสินใจ: ให้มีวิธีทำสัญญาจุดยอดสีเดียวกันเพื่อให้ได้ DAG ที่มีขนาดหรือไม่?≤ $k$$\le k$

ซึ่งสามารถแสดงเป็นอินสแตนซ์ของ ILP ได้โดยใช้เทคนิคมาตรฐาน เราได้สีของแต่ละจุดยอดในกราฟต้นฉบับ ฉันขอแนะนำให้เราติดป้ายจุดสุดยอดแต่ละจุดด้วยป้ายกำกับใน ; จุดยอดทั้งหมดที่มีป้ายชื่อเดียวกันและสีเดียวกันจะถูกทำสัญญา ดังนั้นปัญหาการตัดสินใจกลายเป็น: มีการติดฉลากหรือไม่เช่นนั้นการทำสัญญาจุดยอดเดียวกัน - สีเดียวกันทั้งหมดให้ DAG หรือไม่$\{1,2,\dots,k\}$

ในการแสดงนี้เป็นจำนวนเต็มเชิงเส้นโปรแกรมแนะนำจำนวนเต็มตัวแปรสำหรับแต่ละจุดสุดยอดเพื่อเป็นตัวแทนของฉลากบนจุดสุดยอดวีเพิ่มความไม่สมดุลกันkวีวี1 ≤ ℓ วี ≤ $\ell_v$$v$$v$$1 \le \ell_v \le k$

ขั้นตอนต่อไปคือการแสดงความต้องการที่กราฟสัญญาจะต้องเป็น DAG ขอให้สังเกตว่าถ้ามีการติดฉลากในรูปแบบดังกล่าวข้างต้นโดยไม่สูญเสียของทั่วไปมีอยู่การติดฉลากดังกล่าวที่ฉลากเหนี่ยวนำให้เกิดการจัดเรียงทอพอโลยีในรูปแบบของกราฟหดตัว (เป็นเช่นถ้าแจ๋วในกราฟหดแล้ว 's ฉลาก เล็กกว่าป้ายกำกับของ ) ดังนั้นสำหรับแต่ละขอบในกราฟต้นฉบับเราจะเพิ่มข้อ จำกัด ที่และมีป้ายกำกับและสีเดียวกันหรือมิฉะนั้นป้ายกำกับของจะเล็กกว่าป้ายกำกับของโดยเฉพาะสำหรับแต่ละขอบW V W วี→ W V W V W วี→ W V , W ℓ วี ≤ ℓ Wวี→ W V , W ℓ วี < ℓ $v$$w$$v$$w$$v\to w$$v$$w$$v$$w$$v\to w$ในรูปแบบของกราฟเริ่มต้นที่มีสีเดียวกันให้เพิ่มความไม่สมดุลกัน\ สำหรับแต่ละขอบที่มีสีที่แตกต่างกันเพิ่มความไม่เท่าเทียมกัน<\$v,w$$\ell_v \le \ell_w$$v \to w$$v,w$$\ell_v < \ell_w$

ตอนนี้ดูว่ามีวิธีแก้ปัญหาที่เป็นไปได้สำหรับโปรแกรมเชิงเส้นจำนวนเต็มนี้ จะมีวิธีแก้ปัญหาที่เป็นไปได้ถ้าหากว่าการติดฉลากนั้นอยู่ในรูปแบบที่ต้องการ (เช่นการทำสัญญาจุดยอดเดียวกันสีเดียวกันทั้งหมดให้ DAG) ในคำอื่น ๆ จะมีวิธีการแก้ปัญหาที่เป็นไปได้และถ้าหากมีวิธีการหดตัวของกราฟเดิม DAG ขนาดที่k เราสามารถใช้แก้การเขียนโปรแกรมเชิงเส้นจำนวนเต็มใด ๆ หากนักแก้ปัญหา ILP ให้คำตอบกับเราเรามีคำตอบสำหรับปัญหาการตัดสินใจเดิม$\le k$

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

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

(ฉันหวังว่านี่ถูกต้องฉันไม่ได้ตรวจสอบทุกรายละเอียดอย่างถี่ถ้วนดังนั้นโปรดตรวจสอบเหตุผลของฉันอีกครั้ง!

อัปเดต (10/21): ดูเหมือนว่า ILP ของแบบฟอร์มนี้สามารถแก้ไขได้ในเวลาเชิงเส้นโดยการประมวลผล DAG ตามลำดับทอพอโลยีเรียงลำดับและติดตามขอบเขตล่างบนฉลากสำหรับแต่ละจุดสุดยอด สิ่งนี้ทำให้ฉันสงสัยวิธีแก้ปัญหาของฉัน: ฉันทำผิดพลาดที่ไหนสักแห่งหรือไม่?

หมายเหตุ: AFAICT, DWพบช่องโหว่ในการลดลงนี้และมันผิด (ดูความคิดเห็น) เก็บไว้ที่นี่ด้วยเหตุผลทางประวัติศาสตร์

คำแนะนำ : ก่อนอื่นฉันจะลดปัญหาMonotone 3SAT เป็นปัญหาของเรา ถึงแม้ว่าปัญหาMonotone 3SATนั้นน่าพึงพอใจเล็กน้อย แต่ปัญหาของเราสามารถแก้ไขปัญหาขั้นต่ำ True Monotone 3SATซึ่งเป็น NP-hard; ดังนั้นปัญหานี้คือปัญหา NP-hard

ลดจากMonotone 3SATเป็นปัญหาของเรา

เรามีสูตรบูลีน monotone ที่แสดงเป็นลำดับของตัวแปรและลำดับของข้อ CNF อยู่ในรูปแบบเช่นนั้น:$\Phi = (\mathcal V,\mathcal C)$

และ

การแปลง

เราสร้างกราฟ ' แต่ละจุดสุดยอดในG ′มีฉลาก จุดยอดที่มีป้ายกำกับเดียวกันมีสิทธิ์ได้รับการหด$G'=V',E'$$G'$

ก่อนอื่นเราสร้างกราฟดังนี้: สำหรับแต่ละเราสร้างสองโหนดแต่ละอันที่มีเลเบลx iและขอบกำกับจากที่หนึ่งไปอีกที่หนึ่ง (คลิกที่ภาพเพื่อดูความละเอียดสูง)$x_i \in \mathcal V$$x_i$

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

หลังจากขั้นตอนนี้ควรมี2 ⋅ | V | โหนด ต่อไปเราจะแนะนำข้อ จำกัด ของข้อ สำหรับแต่ละส่วนคำสั่งc i ∈ C , c i = ( x j ∨ x k ∨ x l ) | x j , x k , x l ∈ Vเราแนะนำหนึ่งโหนดc iและขอบต่อไปนี้:$V'$$2\cdot \left|\mathcal V\right|$$c_i \in \mathcal C, ~ \left.c_i = (x_j \vee x_k \vee x_l) \right|_{x_j,x_k,x_l \in \mathcal V}$$c_i$

^{$c_i$$1$$c_i$}

$2\cdot \left|\mathcal V\right| + |\mathcal C|$

$x_i$$x_j$ $x_k$$c_i \rightarrow c_i$

นี่คือการสร้างภาพข้อมูลอีกครั้งโดยการคลี่ข้อ จำกัด ของข้อ:

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

ลดจากขั้นต่ำ True Monotone 3SAT

Monotone 3SAT นั้นน่าพึงพอใจเล็กน้อย คุณสามารถตั้งค่าตัวแปรทั้งหมดให้เป็นจริงได้

อย่างไรก็ตามเนื่องจากปัญหาการย่อขนาด DAG ของเราคือการค้นหาการหดตัวมากที่สุดซึ่งแปลว่าการค้นหาการมอบหมายที่น่าพอใจซึ่งสร้างตัวแปรที่ผิดพลาดมากที่สุดใน CNF ของเรา ซึ่งเหมือนกับการค้นหาตัวแปรจริงขั้นต่ำ นี้ปัญหาบางครั้งเรียกว่าขั้นต่ำที่ทรู Monotone 3SATหรือนี่ (เป็นปัญหาการเพิ่มประสิทธิภาพหรือปัญหาการตัดสินใจ) หรือK-True Monotone 2SAT (เป็นปัญหาการตัดสินใจที่อ่อนแอ); ทั้งปัญหา NP-hard ดังนั้นปัญหาของเราคือ NP-hard

อ้างอิง:

• True Monotone ขั้นต่ำ 3SAT
• พิสูจน์ความสมบูรณ์แบบ NP ของการตัดสินใจความพึงพอใจของสูตรบูลีนโมโนโทน
• Monotone-2SAT และ Vertex Cover

แหล่งกราฟ:

• แหล่งที่มาในส่วนสำคัญ
• ดูบน writelatex

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

Python-ish (ไม่ได้ทดสอบ):

def play((V,E),F,sequence=[]):
  """
  (V,E) -- a dag.
  V     -- a set of vertices.
  E     -- a set of directed-edge-tuples.
  F     -- a function that takes a vertex, returns an integer.
  sequence -- the sequence of moved taken so far; starts with/defaults to
              an empty list, will contain tuples of the form (x,y)
              where x is removed and replaced with y.

  Returns the best recursively found solution.
  """

  #find all the integer values in the graph, remember which
  # values correspond to what vertices. Of the form {integer => {vertices}}.
  n2v = {}
  for x in V:
    n = F(x)

    #for each integer, make sure you have a set to put the vertices in.
    if n not in n2v:
      n2v[n] = set()

    #for each integer, add the vertex to the equivalent set.
    n2v[n].add(v)

  #record the best sequence/solution. You start with the current sequence,
  # and see if you can obtain anything better.
  best_solution = list(sequence)

  #Now you will try to combine a single pair of vertices, obtain a new
  # graph and then recursively play the game again from that graph. 

  #for each integer and equivalent set of vertices,
  for n,vset in n2v.iteritems():

    #pick a pair of vertices
    for x in vset:
      for y in vset:

        #no point if they are the same.
        if x == y:
          continue

        #If there is a path from x => y or y => x, then you will be
        # introducing a cycle, breaking a rule. So in that case, disregard
        # this pair.
        #However, the exception is when one is a direct child of the other;
        # in that case you can safely combine the vertices.
        if pathtest((V,E),x,y) and (x,y) not in E and (x,y) not in E:
          continue

        #combine the vertices (function is defined below), discard x,
        # replace it with y, obtain the new graph, (V',E').
        Vp,Ep = combine_vertex((V,E),x,y))

        #record the sequence for this move.
        sequencep = list(sequence) + [(x,y)]

        #recurse and play the game from this new graph.
        solution = play(Vp,Ep,F,sequencep)

        #if the returned solution is better than the current best,
        if len(solution) > len(best_solution):
          #record the new best solution
          best_solution = solution
  #return the best recorded solution
  return best_solution


def combine_vertex((V0,E0),x,y):
  """
  (V0,E0)   -- an initial digraph.
  V0        -- a set of vertices.
  E0        -- a set of directed-edge-tuples.
  x         -- vertex to discard.
  y         -- vertex to replace it with.

  returns a new digraph replacing all relationships to and from x to relate
   to y instead, and removing x from the graph entirely.
  """

  #the final vertex set will have everything except x
  V = set(V0)
  V.discard(x)

  #now you construct the edge set.
  E = set()

  #for every edge,
  for (u0,v0) in E0:
    #recreate the edge in the new graph, but replace any occurence
    # of x.  
    u,v = u0,v0
    #if x is in the edge: replace it
    if u == x:
      u = y
    if v == x:
      v == y

    #sometimes u=v=y and can now be pointing to itself, don't add that
    # edge
    if u == v:
      continue

    #add the new/replaced edge into the edge-set.
    E.add( (u,v) )
  return (V,E)

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