การนับหมู่เกาะในเมทริกซ์บูลีน

ได้รับ $n \times m$ บูลีนเมทริกซ์ $\mathrm X$, ปล่อย $0$ รายการเป็นตัวแทนของทะเลและ $1$รายการหมายถึงที่ดิน กำหนดเกาะเป็นแนวตั้งหรือแนวนอน (แต่ไม่ใช่แนวทแยงมุม) ที่อยู่ติดกัน$1$ รายการ.

คำถามเดิมคือการนับจำนวนเกาะในเมทริกซ์ที่กำหนด ผู้เขียนอธิบายถึงวิธีแก้ปัญหาแบบเรียกซ้ำ ($\mathcal{O}(nm)$ หน่วยความจำ)

แต่ฉันไม่ประสบความสำเร็จในการพยายามหาวิธีการสตรีม (จากซ้ายไปขวาและจากนั้นลงไปที่แถวถัดไป) โซลูชันที่นับเกาะแบบไดนามิกด้วย $\mathcal{O}(m)$ หรือ $\mathcal{O}(n)$ หรือ $\mathcal{O}(n+m)$หน่วยความจำ (ไม่มีข้อ จำกัด สำหรับความซับซ้อนของเวลา) เป็นไปได้ไหม ถ้าไม่ฉันจะพิสูจน์ได้อย่างไร

ตัวอย่างของเอาต์พุตที่คาดไว้สำหรับอินพุตบางอย่างสำหรับcountฟังก์ชัน:

$count\begin{pmatrix} 010\\ 111\\ 010\\ \end{pmatrix} = 1; % count\begin{pmatrix} 101\\ 010\\ 101\\ \end{pmatrix} = 5; % count\begin{pmatrix} 111\\ 101\\ 111\\ \end{pmatrix} = 1;$

$count\begin{pmatrix} 1111100\\ 1000101\\ 1010001\\ 1011111\\ \end{pmatrix} = 2$

$count\begin{pmatrix} 101\\ 111\\ \end{pmatrix} = 1$

นี่คือภาพร่างของอัลกอริทึมที่เก็บสองแถวในหน่วยความจำในแต่ละครั้งเท่านั้น $O(m)$หน่วยความจำ แต่เนื่องจากคุณสามารถเรียกใช้อัลกอริทึมนี้บนทรานสดิวเซอร์ของเมทริกซ์โดยไม่มีปัญหาความซับซ้อนที่แท้จริงคือ$O(\min(m, n))$หน่วยความจำ เวลาประมวลผลคือ$O(mn)$.

1. การเริ่มต้น. สแกนแถวแรกและค้นหาสตริงย่อยที่เชื่อมต่อทั้งหมดของแถวนั้น กำหนดแต่ละสตริงย่อยที่ไม่รวมกันของรหัสบวกที่ไม่ซ้ำกันและบันทึกเป็นเวกเตอร์ซึ่งเป็นศูนย์ที่ไหน$X$ เป็นศูนย์และรหัสบวกที่ไม่ซ้ำกันเป็นอย่างอื่น

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

   $$\begin{array}0010402220333300\\ 506607080009990\end{array} \rightarrow \begin{array}0010402220333300\\ 504402020003330\end{array}$$

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

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

   ตอนนี้คุณสามารถยกเลิกแถวก่อนหน้าและกำหนดแถวปัจจุบันให้กับแถวก่อนหน้าและดำเนินการต่อ

3. หากต้องการจัดการแถวสุดท้ายอย่างถูกต้องจะมีศูนย์อีกหนึ่งแถวที่ด้านล่างของ $X$ และเรียกใช้ขั้นตอนที่ 2 อีกครั้ง

Orlp ให้ทางออกโดยใช้ $O(n)$ คำของพื้นที่ซึ่งเป็น $O(n\log n)$ บิตของพื้นที่ (สมมติว่าความเรียบง่ายนั้น $n=m$) ตรงกันข้ามมันง่ายที่จะแสดงให้เห็นว่า$\Omega(n)$ จำเป็นต้องใช้พื้นที่บิตโดยการลดความไม่ลงรอยกันที่กำหนดให้กับปัญหาของคุณ

สมมติว่าอลิซถือไบนารีเวกเตอร์ $x_1,\ldots,x_n$ และ Bob ถือเวกเตอร์ไบนารี่ $y_1,\ldots,y_n$และพวกเขาต้องการทราบว่ามีดัชนีอยู่หรือไม่ $i$ ดังนั้น $x_i=y_i=1$. พวกเขาเรียกใช้อัลกอริทึมของคุณสำหรับ$2\times(2n-1)$ เมทริกซ์ซึ่งมีแถวอยู่ $x_1,0,x_2,0,\ldots,0,x_n$ และ $y_1,0,y_2,0,\ldots,0,y_n$. หลังจากอ่านแถวแรกแล้วอลิซก็ส่งบ๊อบ$\sum_i x_i$ เช่นเดียวกับเนื้อหาของหน่วยความจำเพื่อให้ Bob สามารถทำอัลกอริทึมและเปรียบเทียบให้เสร็จสมบูรณ์ $\sum_i (x_i+y_i)$ถึงจำนวนของส่วนประกอบที่เชื่อมต่อ หากตัวเลขสองตัวตรงกันทั้งสองเวกเตอร์จะแยกกัน (ไม่มีดัชนี$i$), และในทางกลับกัน. เนื่องจากโพรโทคอลใด ๆ สำหรับชุดความไม่ต่อเนื่องนั้นต้องการ$\Omega(n)$ บิต (แม้ว่ามันจะผิดพลาดกับความน่าจะเป็นคงที่เล็ก ๆ ) เราก็อนุมาน $\Omega(n)$ ขอบเขตล่างซึ่งเก็บไว้สำหรับโปรโตคอลแบบสุ่มซึ่งอนุญาตให้ทำผิดพลาดด้วยความน่าจะเป็นคงที่เล็กน้อย

เราสามารถปรับปรุงวิธีการแก้ปัญหาของ Orlp โดยใช้พาร์ทิชันที่ไม่ข้าม เราอ่านเมทริกซ์ทีละแถว สำหรับแต่ละแถวเราจำได้ว่า 1s ใดที่เชื่อมต่อผ่านเส้นทางที่ผ่านแถวก่อนหน้า พาร์ติชันที่สอดคล้องกันนั้นไม่มีการข้ามและสามารถเข้ารหัสได้โดยใช้$O(n)$บิต (เนื่องจากพาร์ทิชันที่ไม่ข้ามจะถูกนับโดยหมายเลขคาตาลันซึ่งมีอัตราการเติบโตเป็นเลขชี้กำลังแทนแฟกทอเรียล) เมื่ออ่านแถวต่อไปนี้เรายังคงเป็นตัวแทนนี้และเพิ่มตัวนับเมื่อใดก็ตามที่จุดสิ้นสุดของบางส่วนไม่ได้เชื่อมต่อกับแถวปัจจุบัน (ตัวนับจะเพิ่ม$O(\log n)$บิต) เช่นเดียวกับในโซลูชันของ Orlp เราเพิ่มแถวดัมมี่สุดท้ายของเลขศูนย์เพื่อสิ้นสุดการประมวลผลเมทริกซ์ วิธีนี้ใช้$O(n)$ บิตซึ่งเป็นค่าที่เหมาะสมที่สุดเนื่องจากขอบเขตล่างของเรา