feat: 实现爬楼梯问题的矩阵算法解法

Author: CC11001100

src/algorithms/dpAlgorithm.ts

@@ -0,0 +1,138 @@
+import { AnimationTimeline } from '../state/animationSlice';
+
+/**
+ * 使用动态规划算法生成爬楼梯问题的解和动画时间线
+ * @param n 楼梯的阶数
+ * @returns 包含结果和动画时间线的对象
+ */
+export function generateDPSolution(n: number): {
+  result: number;
+  timeline: AnimationTimeline[];
+} {
+  // 处理边界情况
+  if (n <= 0) {
+    return {
+      result: 0,
+      timeline: [{
+        timestamp: 0,
+        description: "输入的阶数小于等于0，没有有效的爬楼梯方法",
+        visualChanges: {
+          nodeUpdates: [
+            { index: 0, props: { x: 50, y: 300, value: 0 } }
+          ],
+          matrixUpdates: [],
+          formulaUpdate: "n <= 0，返回0"
+        },
+        interactionPoints: []
+      }]
+    };
+  }
+  
+  if (n === 1) {
+    return {
+      result: 1,
+      timeline: [{
+        timestamp: 0,
+        description: "只有1阶楼梯，只有1种爬法",
+        visualChanges: {
+          nodeUpdates: [
+            { index: 0, props: { x: 50, y: 300, value: 1 } },
+            { index: 1, props: { x: 150, y: 260, value: 1 } }
+          ],
+          matrixUpdates: [],
+          formulaUpdate: "n = 1，返回1"
+        },
+        interactionPoints: []
+      }]
+    };
+  }
+  
+  // 初始化DP数组
+  const dp: number[] = new Array(n + 1).fill(0);
+  dp[0] = 1;
+  dp[1] = 1;
+  
+  // 初始化时间线
+  const timeline: AnimationTimeline[] = [];
+  
+  // 初始化阶段的时间线
+  timeline.push({
+    timestamp: 0,
+    description: "初始化阶段，第 0 阶和第 1 阶各有 1 种爬法",
+    visualChanges: {
+      nodeUpdates: [
+        { index: 0, props: { x: 50, y: 300, value: 1 } },
+        { index: 1, props: { x: 150, y: 300, value: 1 } }
+      ],
+      matrixUpdates: [],
+      formulaUpdate: "f(0)=1, f(1)=1"
+    },
+    interactionPoints: []
+  });
+  
+  // 状态转移阶段
+  for (let i = 2; i <= n; i++) {
+    // 计算当前阶的值
+    dp[i] = dp[i - 1] + dp[i - 2];
+    
+    // 添加到时间线
+    timeline.push({
+      timestamp: i * 1000, // 时间戳按步骤递增
+      description: `计算第 ${i} 阶的爬法数量`,
+      visualChanges: {
+        nodeUpdates: [
+          { 
+            index: i, 
+            props: { 
+              x: 50 + i * 100, 
+              y: 300 - Math.min(i * 50, 200), 
+              value: dp[i] 
+            } 
+          }
+        ],
+        matrixUpdates: [],
+        formulaUpdate: `f(${i})=f(${i-1})+f(${i-2})=${dp[i-1]}+${dp[i-2]}=${dp[i]}`
+      },
+      interactionPoints: []
+    });
+  }
+  
+  // 滚动数组优化阶段
+  timeline.push({
+    timestamp: (n + 1) * 1000,
+    description: "通过滚动数组，我们将空间复杂度从 O(n) 优化到 O(1)",
+    visualChanges: {
+      nodeUpdates: [],
+      matrixUpdates: [],
+      formulaUpdate: "空间优化：只需保存前两个状态，p=f(n-2), q=f(n-1), r=p+q"
+    },
+    interactionPoints: []
+  });
+  
+  return {
+    result: dp[n],
+    timeline
+  };
+}
+
+/**
+ * 使用滚动数组优化的动态规划算法计算爬楼梯问题
+ * @param n 楼梯的阶数
+ * @returns 到达第n阶的方法数
+ */
+export function climbStairsDP(n: number): number {
+  if (n <= 0) return 0;
+  if (n === 1) return 1;
+  
+  let p = 1; // f(0)
+  let q = 1; // f(1)
+  let r = 0;
+  
+  for (let i = 2; i <= n; i++) {
+    r = p + q;
+    p = q;
+    q = r;
+  }
+  
+  return r;
+} 

src/algorithms/formulaAlgorithm.ts

@@ -0,0 +1,125 @@
+import { AnimationTimeline } from '../state/animationSlice';
+
+/**
+ * 使用通项公式算法生成爬楼梯问题的解和动画时间线
+ * @param n 楼梯的阶数
+ * @returns 包含结果和动画时间线的对象
+ */
+export function generateFormulaSolution(n: number): {
+  result: number;
+  timeline: AnimationTimeline[];
+} {
+  // 处理边界情况
+  if (n <= 0) return { result: 0, timeline: [] };
+  if (n === 1) return { result: 1, timeline: [] };
+  
+  // 初始化时间线
+  const timeline: AnimationTimeline[] = [];
+  
+  // 特征方程推导阶段
+  timeline.push({
+    timestamp: 0,
+    description: "特征方程推导",
+    visualChanges: {
+      nodeUpdates: [],
+      matrixUpdates: [],
+      formulaUpdate: "f(n) = f(n-1) + f(n-2) 对应的特征方程：x² - x - 1 = 0"
+    },
+    interactionPoints: []
+  });
+  
+  // 求解特征方程阶段
+  const phi = (1 + Math.sqrt(5)) / 2;
+  const psi = (1 - Math.sqrt(5)) / 2;
+  
+  timeline.push({
+    timestamp: 1000,
+    description: "求解特征方程",
+    visualChanges: {
+      nodeUpdates: [],
+      matrixUpdates: [],
+      formulaUpdate: `解得特征根：λ₁ = (1+√5)/2 ≈ ${phi.toFixed(3)}，λ₂ = (1-√5)/2 ≈ ${psi.toFixed(3)}`
+    },
+    interactionPoints: []
+  });
+  
+  // 通项公式推导阶段
+  timeline.push({
+    timestamp: 2000,
+    description: "通项公式推导",
+    visualChanges: {
+      nodeUpdates: [],
+      matrixUpdates: [],
+      formulaUpdate: "通项公式：f(n) = c₁λ₁ⁿ + c₂λ₂ⁿ = c₁((1+√5)/2)ⁿ + c₂((1-√5)/2)ⁿ"
+    },
+    interactionPoints: []
+  });
+  
+  // 确定系数阶段
+  timeline.push({
+    timestamp: 3000,
+    description: "确定系数",
+    visualChanges: {
+      nodeUpdates: [],
+      matrixUpdates: [],
+      formulaUpdate: "根据f(0)=1, f(1)=1，解得c₁=1/√5, c₂=-1/√5"
+    },
+    interactionPoints: []
+  });
+  
+  // 最终公式阶段
+  timeline.push({
+    timestamp: 4000,
+    description: "最终公式",
+    visualChanges: {
+      nodeUpdates: [],
+      matrixUpdates: [],
+      formulaUpdate: "f(n) = (1/√5)·((1+√5)/2)ⁿ - (1/√5)·((1-√5)/2)ⁿ"
+    },
+    interactionPoints: []
+  });
+  
+  // 最终结果计算阶段
+  const result = calculateBinetFormula(n);
+  timeline.push({
+    timestamp: 5000,
+    description: "计算结果",
+    visualChanges: {
+      nodeUpdates: [],
+      matrixUpdates: [],
+      formulaUpdate: `代入n=${n}，得到结果：f(${n}) = ${result}`
+    },
+    interactionPoints: []
+  });
+  
+  return {
+    result,
+    timeline
+  };
+}
+
+/**
+ * 使用比内公式（Binet's Formula）计算爬楼梯问题
+ * @param n 楼梯的阶数
+ * @returns 到达第n阶的方法数
+ */
+export function climbStairsFormula(n: number): number {
+  if (n <= 0) return 0;
+  if (n === 1) return 1;
+  
+  return calculateBinetFormula(n);
+}
+
+/**
+ * 计算比内公式 (Binet's Formula)
+ * @param n 阶数
+ * @returns 计算结果
+ */
+function calculateBinetFormula(n: number): number {
+  const sqrt5 = Math.sqrt(5);
+  const phi = (1 + sqrt5) / 2;
+  const psi = (1 - sqrt5) / 2;
+  
+  // 使用精确计算，避免浮点数误差
+  return Math.round((Math.pow(phi, n) - Math.pow(psi, n)) / sqrt5);
+}