Merge branch 'master' into add_1079

Author: iammarkps

md/1021.md

@@ -0,0 +1,96 @@
+โจทย์ข้อนี้มีคำสั่ง $N$ คำสั่ง โดยคำสั่งจะมีสองแบบ
+
+1. ใส่สินค้ามูลค่า $i$ เข้าไปในเครื่อง
+2. ถามว่าสินค้าที่มีมูลค่ามากสุดในเครื่องมีมูลค่าเท่าใดหากมีและเอาออกจากเครื่อง
+
+โจทย์ข้อนี้แก้ได้ด้วย Priority Queue ซึ่งเป็นโครงสร้างข้อมูลที่มีประสิทธิภาพในการหาค่าสูงสุดของชุดข้อมูลที่อาจมีการเพิ่มเข้าหรือลบออก
+
+ทั้งนี้ Priority Queue เป็นโครงสร้างข้อมูลที่มีอยู่ใน STL ซึ่งทำให้ข้อนี้แก้ได้ง่ายมากหากใช้ `std::priority_queue` โดยเพียงต้องใช้ฟังก์ชัน `push` เพื่อคำสั่งประเภทแรก และ `top` กับ `pop` สำหรับคำสั่งประเภทสอง
+
+เนื่องจากโจทย์ข้อนี้เป็นโจทย์ที่ต้องการสอนให้รู้จักการใช้ Priority Queue เฉลยนี้จะอธิบายโครงสร้าง Binary Heap ซึ่งเป็นวิธีที่พื้นฐานที่สุดสำหรับการเขียน Priority Queue (Priority Queue มีความหมายที่กว้างกว่า Binary Heap นอกจาก Binary Heap ยังมีโครงสร้างข้อมูลอื่นที่สามารถใช้เขียน Priority Queue เช่น Fibonacci Heap หรือ Binomial Heap)
+
+## Binary Heap
+
+Binary Heap ที่ต้องการในข้อนี้จะต้องรองรับ Operation สองแบบคือ:
+1. Push($i$) ใส่ข้อมูลที่มีค่า $i$ เข้าไปใน Heap
+2. Pop() return ค่าสูงสุดใน Heap และเอาข้อมูลนั้นออกจาก Heap 
+โดย Operation ทั้งสองมี Time Complexity $\mathcal{O}(\log{}N)$ และการเก็บ Heap มี Memory Complexity $\mathcal{O}(N)$ (เมื่อ $N$ คือขนาดของ Heap)
+
+### หลักการทำงานของ Heap
+
+Heap เป็นโครงสร้างข้อมูลที่เก็บในลักษณะ Complete Binary Tree ซึ่งเป็น Binary Tree ประเภทหนึ่ง
+
+Binary Tree เป็น Tree ที่แต่ละ Node มีลูกอย่างมาก 2 ตัว 
+
+Complete Binary Tree คือ Binary Tree ที่แต่ละชั้นจะมีจำนวน Node มากสุดที่เป็นไปได้ยกเว้นชั้นสุดท้ายซึ่งจะเก็บ Node ไว้ด้านซ้ายสุดก่อน นั่นคือในชั้นที่ $h$ ของ Binary Tree ที่มีชั้น $H$ เป็นชั้นสุดท้าย จะมี Node $2^h$ ตัวหาก $h < H$ และในชั้น $H$ มีได้ตั้งแต่ $1$ ถึง $2^H$ ตัว 
+
+นอกจากนี้ Heap จะรักษาคุณสมบัติว่าสำหรับ Node $x$ ใดๆ ลูกของ Node $x$ จะมีค่าไม่เกินค่าของ Node $x$ ซึ่งจะทำให้ Node รากที่อยู่สูงสุดใน Heap เป็นค่าสูงสุดในทั้ง Heap
+
+![](../media/1021/1.png)
+
+ในการ Implement โครงสร้างข้อมูล Binary Heap โดยทั่วไปจะเก็บเป็น Array จากช่องที่ $1$ ถึง $N$ โดยรากอยู่ที่ $1$ และให้ลูกขวาของ Node ที่ช่อง $x$ ที่ช่อง $2x$ และลูกซ้ายอยู่ที่ $2x+1$ (สังเกตตัวเลขแดงในภาพประกอบซึ่งแทนตำแหน่งของแต่ละ Node ใน Array)
+
+เนื่องจาก Binary Heap จัดเป็น Complete Binary Tree จะทำให้จำนวนชั้นของ Heap เป็น $\mathcal{O}(\log N)$ เมื่อ $N$ คือจำนวนสมาชิกใน Heap
+
+#### Push
+
+สำหรับการ Push ค่า $i$ จะใส่ค่า $i$ เข้าไปที่ตำแหน่งซ้ายสุดของชั้นสุดท้ายที่ยังว่าง หากชั้นสุดท้ายเต็มแล้วจะใส่ในช่องซ้ายสุดของชั้นใหม่ จากนั้นจะสลับค่าที่เพิ่งใส่ไปกับ Node พ่อของมันจนกว่ามันมีค่าไม่เกิน Node พ่อ 
+
+เนื่องจากมีเพียง $\mathcal{O}(\log N)$ ชั้น จะมีการสลับอย่างมาก $\mathcal{O}(\log N)$ ครั้ง ซึ่งหมายความว่า Push มี Time Complexity $\mathcal{O}(\log N)$
+
+ตัวอย่างการใส่ 84 เข้าไปใน Heap ตัวอย่างด้านบน
+
+![](../media/1021/push_1.png)
+
+84 มีค่ามากกว่า 15 จึงต้องสลับ
+
+![](../media/1021/push_2.png)
+
+84 มีค่ามากกว่า 78 จึงสลับอีกรอล
+
+![](../media/1021/push_3.png)
+
+84 มีค่าไม่เกิน 90 จึงจบขั้นตอนการ Push
+
+#### Pop
+
+สำหรับการ Pop ค่าที่ต้องการ return คือค่าสูงสุดกล่าวคือค่าที่อยู่ที่ราก 
+
+สำหรับการเอาค่านั้นออกจาก Heap จะสลับ Node ในตำแหน่งขวาสุดของชั้นสุดท้ายมาแทนรากเก่า และสลับ Node ที่ถูกสลับขึ้นมากับลูกที่มีค่ามากสุดจน Node นั้นมีค่าไม่ต่ำกว่าลูกทั้งสอง 
+
+Pop มี Time Complexity $\mathcal{O}(\log N)$ เช่นเดียวกับ Push เนื่องจาก Heap มีเพียง $\mathcal{O}(\log N)$ ชั้น
+
+
+ตัวอย่างการ Pop จาก Heap ตัวอย่างด้านบน
+
+![](../media/1021/push_3.png)
+
+ค่าที่รากคือ 90 ซึ่งเป็นค่าที่ต้องการ return
+
+![](../media/1021/pop_1.png)
+
+สลับ Node ขวาสุดของชั้นสุดท้ายขึ้นมาเป็นรากใหม่
+
+![](../media/1021/pop_2.png)
+
+15 มีค่าน้อยกว่า 90 จึงสลับลงไป
+
+![](../media/1021/pop_3.png)
+
+15 มีค่าน้อยกว่า 85 จึงสลับลงไปอีก
+
+![](../media/1021/pop_4.png)
+
+15 มีค่าน้อยกว่า 30 จึงสลับลงไปอีก
+
+![](../media/1021/pop_5.png)
+
+จบขั้นตอนการ Pop เนื่องจากไม่มีลูกให้สลับลงไปอีก
+
+## Solution
+
+เมื่อมี Priority Queue แล้วสำหรับแต่ละคำสั่งใน $N$ คำสั่งที่ได้ เพียวต้อง Push สำหรับ P และ Pop สำหรับ Q
+
+แต่ละคำสั่งใช้เวลา $\mathcal{O}(\log{}N)$ ไม่ว่าจะเป็น P หรือ Q ดังนั้น Time Complexity ของข้อนี้คือ $\mathcal{O}(N\log{}N)$ 
+
+ภาพประกอบทำใน https://visualgo.net/en 

md/1061.md

@@ -0,0 +1,121 @@
+ข้อนี้ให้ค่าอุณหภูมิในตาราง $N \times N$ $(N \leq  20)$ และกำหนดว่าจากช่องใดๆ จะสามารถขยับไปช่องรอบๆ ที่มีอุณหภูมิที่สูงกว่าเท่านั้น โดยมีบางช่องที่ค่าอุณหภูมิเป็น 100 ซึ่งจะเข้าไม่ได้เลย
+
+### แนวคิด
+
+สำหรับข้อนี้เราสามารถมองว่าแต่ละช่องของเป็นตารางที่ไม่ได้มีค่าอุณหภูมิเป็น 100 เป็น Node และระหว่างสองช่องที่ติดกันจะมี Edge ที่มีทิศทางจากช่องที่มีอุณหภูมิน้อยกว่าไปยังช่องที่มีอุณหภูมิมากกว่า
+
+จากนั้นหากทำ State Space Search เพื่อหาว่า Node ใดในตารางบ้างที่มี Path ที่เป็นไปได้จากช่องเริ่มต้นและเอาอันที่มีอุณหภูมิสูงสุดจะได้คำตอบที่ต้องการ
+
+เช่นในตัวอย่างประกอบในโจทย์สามารถวาด Edge ได้ดังในรูป
+
+![](../media/1061/0.png)
+
+### State Space Search
+
+State Space Search (การค้นหาในปริภูมิสถานะ) เป็นรูปแบบขั้นตอนวิธีที่จะแทน State (สถานะ) เป็น Node ใน Graph โดย Node $A$ จะมี Edge ไปยัง Node $B$ ก็ต่อเมื่อสามารถเปลี่ยนจาก State $A$ ไป $B$ ได้ในหนึ่งขั้น ใน State Space Search เราจะเริ่มจาก Node ใดๆ แล้วพิจารณา Node รอบข้างที่มี Edge เชื่อมเพื่อพิจารณาแต่ละ State ที่สามารถไปถึงจาก State เริ่ม สำหรับข้อนี้จะต้องหา State ที่มีค่าอุณหภูมิสูงสุด
+
+รูปประกอบต่อไปนี้เป็นตัวอย่างของ State Space 
+
+![](../media/1061/1.png)
+
+ในตัวอย่างนี้จะเห็นได้ว่า State $B$ สามารถไป $D$ และ $D$ กับ $E$ สามารถไปมาซึ่งกันและกัน
+
+ในการทำ State Space Search จะมีวิธีพื้นฐานหลักๆ สองแบบคือ Depth First Search (DFS) กับ Breadth First Search (BFS)
+
+#### DFS
+
+ใน DFS จะทำการค้นหาในรูปแบบ Recursive โดยสำหรับแต่ละ State ที่พิจารณา จะ DFS ลงไปใน Node ที่มี Edge ที่ยังได้ไม่ถูกพิจารณา
+
+หากทำ DFS จาก State $A$ ในตัวอย่างก่อนหน้านี้จะได้ดังในรูป (ลูกศรสีเขียวแทนการเรียก DFS แบบ Recursive และลูกศรสีแดงแทนการ Return กลับมา)
+
+![](../media/1061/2.png)
+
+ในตัวอย่างนี้จะพิจารณา State ในลำดับ $A,B,D,E,C,F,G$
+
+เมื่อนำมาใช้กับข้อนี้จะได้โค้ดดังนี้
+
+```cpp
+int M;
+int T[22][22];
+int visited[22][22];
+
+int dfs(int x, int y) {
+  visited[x][y] = 1; // visited[x][y] จะแทนว่าช่อง x,y ถูกพิจารณาแล้ว
+
+  int ret = T[x][y];
+
+  int dx[4] = {0, 0, -1, 1};
+  int dy[4] = {1, -1, 0, 0};
+  for (int u = 0; u < 4; u++) { // พิจารณา 4 ทิศทาง
+    int ux = x + dx[u];
+    int uy = y + dy[u];
+
+    if (1 <= ux && ux <= M && 1 <= uy && uy <= M && !visited[ux][uy] &&
+        T[ux][uy] != 100 &&
+        T[ux][uy] > T[x][y]) // ช่องใหม่ต้องอยู่ในกรอบ ยังไม่ถูกพิจารณา และ
+                             // ต้องมีอุณหภูมิที่มากกว่าช่องปัจจุบันและไม่ใช่ 100
+      ret = max(dfs(ux, uy), ret); // ค่าที่มากที่สุดจะเป็นค่าที่มากสุดของช่องนี้หรือช่องที่สามารถไปจากช่องนี้
+  }
+
+  return ret;
+}
+```
+
+ในโค้ดตัวอย่างนี้จะพิจารณาแต่ละช่องที่อยู่ด้าน บน ล่าง ซ้าย หรือ ขวา ว่าเข้าเงื่อนไขที่จะสามารถไปจากช่องปัจจุบันไหมและหากสามารถไปจะเรียก DFS แบบ Recursive 
+
+DFS จะใช้ Memory ใน Stack ตามความยาวของ Path ที่ทำ Recursion ซึ่งสำหรับข้อนี้เป็นได้อย่างมาก $\mathcal{O}(M^2)$ และจะใช้ Time Complexity ตามจำนวน Node และ Edge ที่ถูกพิจารณาซึ่งสำหรับข้อนี้เป็น $\mathcal{O}(M^2)$ เช่นกัน
+
+#### BFS
+
+สำหรับ BFS จะต่างจาก DFS ตรงที่เมื่อเจอ Edge ที่ไปได้แล้วจะไม่นำมาพิจารณาทันทีแต่ละนำเข้า Queue ก่อน โดยการพิจารณาแต่ละ Node จะเรียงตามลำดับใน Queue 
+
+ตัวอย่างดังภาพ
+
+![](../media/1061/3.png)
+
+ในตัวอย่างนี้จะพิจารณาเป็นลำดับ $A,B,C,D,E,F,G$ ตามลูกศรสีเขียว
+
+โค้ด BFS ตัวอย่างสำหรับข้อนี้
+
+```cpp
+int M;
+int T[22][22];
+
+int bfs(int x, int y) {
+  int queued[22][22];
+  queued[x][y] = 1;
+  std::deque<std::pair<int, int>> q; // Queue สำหรับการเก็บแต่ละ Node
+
+  q.push_back(std::make_pair(x, y)); // นำ Node เริ่มต้นเข้า Queue
+
+  int ret = T[x][y];
+
+  while (!q.empty()) {
+    int qx = q[0].first, qy = q[0].second;
+    q.pop_front(); // นำ Node แรกมาพิจารณาและเอาออกจาก Queue
+
+    ret = std::max(ret, T[qx][qy]);
+
+    int dx[4] = {0, 0, -1, 1};
+    int dy[4] = {1, -1, 0, 0};
+    for (int u = 0; u < 4; u++) {
+      int ux = qx + dx[u];
+      int uy = qy + dy[u];
+
+      if (1 <= ux && ux <= M && 1 <= uy && uy <= M && !queued[ux][uy] &&
+          T[ux][uy] != 100 && T[ux][uy] > T[qx][qy]) {
+        q.push_back(std::make_pair(ux, uy)); // ใส่ Node ใหม่ที่เจอเข้า Queue
+        queued[ux][uy] = 1;
+      }
+    }
+  }
+
+  return ret;
+}
+```
+
+สังเกตว่าในโค้ดนี้จะเรียก BFS เพียงรอบเดียวต่างจาก DFS โดยจะนำ Node มาใส่ Queue แทนการใช้ Recursion
+
+BFS จะใช้ Memory ตามจำนวน Node ที่อยู่ใน Queue และเวลาตามจำนวน Node / Edge ที่ถูกพิจารณา
+
+ดังนั้นทั้งคู่จะเป็น $\mathcal{O}(M^2)$ สำหรับข้อนี้