OEIS ลำดับA020872นับจำนวนของป่าไม้ จำกัด ในการMöbiusบันได M n

ความท้าทาย

ความท้าทายคือการเขียนโปรแกรมที่ใช้เวลาเป็นจำนวนเต็มใส่n > 1และผลตอบแทนA020872(n)จำนวน จำกัด ป่าบนMöbiusบันไดเอ็มn นี่คือรหัส - กอล์ฟดังนั้นรหัสที่สั้นที่สุดจึงชนะ (แรงจูงใจที่ซ่อนเร้นคือการขยายความยาวของลำดับนี้โดยเล็กน้อย)

คำนิยาม

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

Möbiusบันได M _nเป็นกราฟซึ่งสามารถจะคิดว่าเป็น 2n-gon กับเส้นทแยงมุมวาดระหว่างจุดตรงข้ามทั้งหมด

ตัวอย่าง

นี่คือป่าที่ถูก จำกัด 34 แห่งใน M ₂ (สี่เหลี่ยมจัตุรัสที่มีเส้นทแยงมุมวาด) โปรดสังเกตว่ากราฟแรกถูกแบ่งเป็นจุดยอดแยกสี่จุดส่วนที่สองถูกแบ่งเป็นหนึ่งเส้นทางและสองจุดยอดแยกเป็นต้น

CJam ( 58 56 ตัวอักษร)

อักขระบางตัวไม่สามารถพิมพ์ได้และตัวหนึ่งคือแท็บซึ่งจะถูกจัดการด้วยซอฟต์แวร์ StackExchange:

"¶3¬î¿Á·    7ÛÈmÈÚÚ¡"256b454b212f-{__W%.*A<1b+}qi*-4=

สาธิตออนไลน์ สิ่งนี้จะทำงานออนไลน์เป็นเวลา n = 400 ในประมาณสามวินาที

เข้ารหัสโดยxxd:

0000000: 22b6 0233 93ac eebf c1b7 0609 3794 dbc8  "..3........7...
0000010: 6dc8 1015 dada a122 3235 3662 3435 3462  m......"256b454b
0000020: 3231 3266 2d7b 5f5f 5725 2e2a 413c 3162  212f-{__W%.*A<1b
0000030: 2b7d 7169 2a2d 343d                      +}qi*-4=

คำอธิบาย

บันไดMöbiusนั้นเป็นบันไดที่มีขอบพิเศษสองอัน เนื่องจากป่าที่ถูก จำกัด บนบันไดสามารถยกขึ้นไปที่ป่าที่ถูก จำกัด ระหว่าง 1 และ 4 บนบันไดMöbius สามารถเพิ่มขอบได้หากไม่ได้สร้างจุดสุดยอดของระดับ 3 หรือวัฏจักร องศาของมุมทั้งสี่และการเชื่อมต่อระหว่างกันของพวกเขาก่อให้เกิด 116 ชั้นเรียนของป่าที่ถูก จำกัด บนบันไดแม้ว่าบางส่วนของพวกเขาจะเทียบเท่ากันเนื่องจากสมมาตรของสี่เหลี่ยมผืนผ้า ฉันเขียนโปรแกรมเพื่อวิเคราะห์ส่วนขยายของบันไดความยาว n เป็นหนึ่งในความยาว n + 1 จากนั้นจึงรวมคลาสเป็น 26 คลาสที่เท่าเทียมกัน สิ่งนี้ทำให้ฟอร์มปิด

$$\begin{bmatrix} 1 \\ 1 \\ 1 \\ 1\end{bmatrix}^T \begin{bmatrix} 1 & 2 & 2 & 0 \\ 1 & 2 & 1 & 1 \\ 2 & 3 & 4 & 1 \\ 0 & 0 & 1 & 0 \\ \end{bmatrix}^{n-2} \begin{bmatrix} 0 \\ 1 \\ 0 \\ 0\end{bmatrix} +$$

$$\begin{bmatrix} 2 \\ 2 \\ 1 \\ 1 \\ 1 \\ 1 \\ 1 \\ 2 \\ 2\end{bmatrix}^T \begin{bmatrix} 2 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 0 & 1 & 0 & 0 & 1 & 0 & 1 & 0 \\ 0 & 0 & 2 & 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 1 \\ 1 & 1 & 0 & 0 & 0 & 0 & 0 & 1 & 1 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 1 & 1 \\ 3 & 2 & 2 & 1 & 1 & 2 & 1 & 4 & 2 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 2 \\ \end{bmatrix}^{n-2} \begin{bmatrix} 0 \\ 0 \\ 2 \\ 2 \\ 0 \\ 0 \\ 0 \\ 0 \\ 0\end{bmatrix} +$$

$$\begin{bmatrix} 1 \\ 2 \\ 4 \\ 4 \\ 1 \\ 1 \\ 3 \\ 2 \\ 2 \\ 2 \\ 3 \\ 4 \\ 4\end{bmatrix}^T \begin{bmatrix} 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 2 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 2 & 0 & 1 & 1 & 0 & 1 & 1 & 0 & 1 & 1 & 1 \\ 1 & 0 & 0 & 4 & 0 & 0 & 3 & 0 & 0 & 2 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 2 & 1 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 \\ 1 & 0 & 0 & 1 & 0 & 0 & 2 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 1 & 2 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 1 & 2 \\ 0 & 1 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 2 & 0 & 0 & 2 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 2 & 2 & 0 \\ 0 & 2 & 3 & 0 & 1 & 1 & 0 & 2 & 1 & 0 & 1 & 2 & 4 \\ \end{bmatrix}^{n-2} \begin{bmatrix} 1 \\ 0 \\ 1 \\ 1 \\ 2 \\ 0 \\ 1 \\ 0 \\ 0 \\ 0 \\ 1 \\ 2 \\ 1\end{bmatrix}$$

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

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

วิธีการก่อสร้าง (58 ตัวอักษร)

qi:Q2*,Wa*e!{Wa/{_W%e<}%$}%_&{{,1>},2few:~{:-z(Q(%}%0-!},,

สาธิตออนไลน์ มันจะทำงานออนไลน์n=2โดยไม่เกิดปัญหาและn=3อดทนด้วย สำหรับการn=1เกิดปัญหา แต่ตั้งแต่ OP ได้เลือกที่จะไม่รวมกรณีที่ว่าจากความต้องการก็ไม่ได้เป็นปัญหาพื้นฐาน

การผ่า

qi:Q          e# Take input from stdin, parse to int, store in Q
2*,Wa*e!      e# Take all permutations of (0, -1, 1, -1, 2, -1, ..., -1, 2*Q-1)
{             e# Map to canonical form...
  Wa/         e#   Split around the -1s
  {_W%e<}%    e#   Reverse paths where necessary to get a canonical form
  $           e#   Sort paths
}%
_&            e# Filter to distinct path sets
{             e# Filter to path sets with valid paths:
  {,1>},      e#   Ignore paths with fewer than two elements (can't be invalid; break 2ew)
  2few:~      e#   Break paths into their edges
  {:-z(Q(%}%  e#   The difference between the endpoints of an edge should be +/-1 or Q (mod 2Q)
              e#   So their absolute values should be 1, Q, 2Q-1.
              e#   d => (abs(d)-1) % (Q-1) maps those differences, and no other possible ones, to 0
              e#   NB {:-zQ(%}% to map them all to 1 would save a byte, but wouldn't work for Q=2
  0-!         e#   Test that all values obtained are 0
},
,             e# Count the filtered distinct path sets

---

รุ่นที่มีประสิทธิภาพยิ่งขึ้นใช้เวลา 98 ไบต์:

qi2*:Q{a{__0=[1Q2/Q(]f+Qf%_&1$-\f{+E}~}:E~}/]{_W%>!},:MW=0{_{M\f{__3$_@&@:e<@|^{=}{^j}?}1b}{,)}?}j

การสาธิตออนไลน์

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

JavaScript (ES6),  160 158  146 ไบต์

n=>(g=(e,v,p)=>[...Array(N=2*n),N-1,1,n].reduce((s,x,i)=>(m=1<<(x=i<N?i:(p+x)%N))&v?s:s+g((i>=N)/p?[...e,1<<p|m]:e,v|m,x),g[e.sort()]^(g[e]=1)))``

ลองออนไลน์!

หมายเหตุ:

• $n>4$
• $a(5) = 10204$

แสดงความคิดเห็น

n => (                        // n = input
  g = (                       // g = recursive function taking:
    e,                        //   e[] = array holding visited edges
    v,                        //   v   = bitmask holding visited vertices
    p                         //   p   = previous vertex
  ) =>                        // we iterate over an array of N + 3 entries, where N = 2n:
    [ ...Array(N = 2 * n),    //   - 0...N-1: each vertex of the N-gon (starting points)
      N - 1,                  //   - N      : previous vertex \
      1,                      //   - N+1    : next vertex      }-- connected to p
      n                       //   - N+2    : opposite vertex /
    ].reduce((s, x, i) =>     // reduce() loop with s = accumulator, x = vertex, i = index:
      ( m = 1 << (            //   m is a bitmask where only the x-th bit is set
          x = i < N           //   and x is either:
              ? i             //   - i if i < N
              : (p + x) % N   //   - or (p + x) mod N otherwise
      )) & v ?                //   if this vertex was already visited:
        s                     //     leave s unchanged
      :                       //   else:
        s +                   //     add to s
        g(                    //     the result of a recursive call:
          (i >= N) / p ?      //       if p and x are connected (i >= N and p is defined):
            [ ...e,           //         append to e[]:
              1 << p | m      //           the edge formed by p and x
            ]                 //           and uniquely identified by 1 << p | 1 << x
          :                   //       else:
            e,                //         leave e[] unchanged
          v | m,              //       mark the vertex x as visited
          x                   //       previous vertex = x
        ),                    //     end of recursive call
      g[e.sort()] ^           //   sort the edges and yield 1 if this list of edges has not
      (g[e] = 1)              //   already been encountered; either way, save it in g
    )                         // end of reduce()
)``                           // initial call to g with e = ['']

เยลลี่ , 61 58 ไบต์

®R,³;Ø+
Ḥ©Ḷµ1ị+¢%®ḟ€;€€1¦-Ẏ;€)Ẏ$ƬẎṣ€-Ẉ’ẠƊƇU¹Ø.ị>/Ɗ?€€Ṣ€QL‘

ลองออนไลน์!

นี่เป็นเวอร์ชั่นที่สั้นกว่า มันเหมาะสำหรับความยาวสั้นกว่าเมื่อเทียบกับความซับซ้อนและความเร็วอัลกอริทึม

เยลลี่ 85 ไบต์

%®ḟ
1ị+³;Ø+¤ç,1ị+®_3¤R‘¤Ʋç;€-Ʋ“”2ị>-Ʋ?Ẏ;€
Ḥ©Ḷ;€-Ç€Ẏ$ƬẎṣ€-Ẉ=1ẸƊÐḟU¹1ị>0ị$Ʋ?€€Ṣ€QL‘+=2$

ลองออนไลน์!

ต่อไปนี้เป็นรุ่นที่ยาวกว่าซึ่งเพิ่มรหัสพิเศษเพื่อหลีกเลี่ยงการลองเส้นทางที่ซ้ำซ้อน การตรวจสอบ n = 2 ในตอนท้ายคือการรับมือกับกรณีเฉพาะสำหรับ n = 2 ซึ่งดูเหมือนกากบาทสีแดง / น้ำเงินในตัวอย่างและไม่ได้สร้างขึ้นโดยรหัสนี้ รุ่นที่สองนี้เสร็จสมบูรณ์ n = 4 ในเวลาน้อยกว่า 13 วินาทีใน TIO แต่หมดเวลาสำหรับตัวเลขที่สูงขึ้น