Update report.md

Author: JimTsai2

homework1/report.md

@@ -118,7 +118,7 @@ int main()
 
 ## 解題說明
 
-本題要求實現輸出集合 $S$ 的所有子集合，假設 $S = '{'a, b, c'}'$ 。  
+本題要求實現輸出集合 $S$ 的所有子集合，假設 $S = {{a, b, c}}$ 。  
 
 ### 解題策略
 
@@ -128,8 +128,8 @@ int main()
 
 ### 解題範例
    
-假設集合 $S = {a, b, c}$，其所有子集合為：  
-${}, {a}, {b}, {c}, {a, b}, {a, c}, {b, c}, {a, b, c}$  
+假設集合 $S = {a, b, c}$，其所有子集合為： 
+```{}, {a}, {b}, {c}, {a, b}, {a, c}, {b, c}, {a, b, c}```
 共 $2^3 = 8$ 種子集合。
 
 ## 程式實作
@@ -138,26 +138,27 @@ ${}, {a}, {b}, {c}, {a, b}, {a, c}, {b, c}, {a, b, c}$
 
 ```cpp
 #include <iostream>
+#include <cmath>
 using namespace std;
-int A(int m, int n)
-{
-    if (m == 0)
-        return n + 1;
-    else if (n == 0)
-        return A(m - 1, 1);
-    else
-        return A(m - 1, A(m, n - 1));
-}
 
-int main()
-{
-    int m, n, a;
-    cout << "請輸入m：";
-    cin >> m;
-    cout << "請輸入n：";
-    cin >> n;
-    a = A(m, n);
-    cout << "A = " << a;
+int main() {
+    char S[] = { 'a', 'b', 'c' };
+    int n = 3;
+    int total = pow(2, n);
+
+    for (int i = 0; i < total; ++i) {
+        cout << "{";
+        bool first = true;
+        for (int j = 0; j < n; ++j) {
+            if (i & (1 << j)) {
+                if (!first) cout << ", ";
+                cout << S[j];
+                first = false;
+            }
+        }
+        cout << "}" << endl;
+    }
+    return 0;
 }
 ```
 
@@ -170,14 +171,16 @@ int main()
 
 ### 測試輸出
 
-${}$
-${a}$
-${b}$
-${a, b}$
-${c}$
-${a, c}$
-${b, c}$
-${a, b, c}$
+```
+{}
+{a}
+{b}
+{a, b}
+{c}
+{a, c}
+{b, c}
+{a, b, c}
+```
 
 ### 結論
 
@@ -191,12 +194,12 @@ ${a, b, c}$
 
 在本程式中，使用遞迴來實現阿克曼函數的主要原因如下：
 
-1. **程式邏輯簡單直觀**  
-   Ackermann 函數的遞迴寫法明確表達了「將問題拆解為更小的子問題」的核心概念。
-   根據其數學定義，每一次呼叫 $A(m, n)$ 都會轉化為更簡單的子問題，直到遇到邊界條件 $m$ 為 $0$ 為止。
+1. **結構簡單、貼近子集的定義**  
+   遞迴自然符合「選擇與不選擇」的兩分策略，程式碼易於理解與實作。
 
-2. **遞迴語意清楚、結構分明**  
-   每一次 $A(m, n)$ 的遞迴呼叫都代表著一個「子問題的解」，且其回傳值會逐層傳遞回原本的呼叫點，組合成最終結果。
-   這種設計讓程式結構簡潔，能夠清楚地追蹤問題的拆解與合併過程。
+2. **適合列舉所有組合情形**  
+   遞迴結構可完整走訪所有可能的子集合，不會遺漏也不重複。
+   
 
-本程式缺點主要表現在遞迴深度限制，當函數遞迴層數過深時，每一層的呼叫都會佔用一部分的記憶體（堆疊空間）。如果超出所允許的堆疊大小限制，就會發生Stack Overflow，導致程式中斷運行或崩潰。
+效能瓶頸：
+若集合元素超過 20 個，子集合數量達 $2^{20} = 1048576$，執行效率將明顯下降。