From ce5a80aaf7a03e092973db738c854c9606b2623d Mon Sep 17 00:00:00 2001
From: Renkin <906155099@qq.com>
Date: Mon, 13 Nov 2023 16:05:50 +0800
Subject: [PATCH 1/3] feat: i18n update

---
 src/locales/en.js       |  53 ++++++++++++++++++
 src/locales/zh.js       |  58 ++++++++++++++++++++
 src/roadmap/roadmap.jsx | 117 +++++++++++++++++++---------------------
 3 files changed, 165 insertions(+), 63 deletions(-)

diff --git a/src/locales/en.js b/src/locales/en.js
index 804fdd2..fcee689 100644
--- a/src/locales/en.js
+++ b/src/locales/en.js
@@ -60,13 +60,28 @@ const en = {
     notYet: "Not yet",
   },
   problem: {
+    69: "69. Sqrt(x)",
+    278: "278. First Bad Version",
+    "278_desc": "The idea of the leftmost and rightmost is the same. Everyone can practice two questions. The actual situation can use different binary search according to the meaning of the question.",
+    327: "327. Count of Range Sum",
+    493: "493. Reverse Pairs",
     743: "743. Network Delay Time",
+    778: "778. Swim in Rising Water",
+    "778_desc": "DFS + binary search, there are many similar questions, such as the 1439th question. This kind of question routine is very similar, and the difficulty is not big.",
     1109: "1109. Corporate Flight Bookings",
     1314: "1314. Matrix Block Sum",
     1462: "1462. Course Schedule IV",
     1480: "1480. Running Sum of 1d Array",
     1584: "1584. Min Cost to Connect All Points",
     2536: "2536. Increment Submatrices by One",
+    minimumLightRadius: "Minimum Light Radius",
+    minimumLightRadius_desc: "Classic ability detection binary search, leetcode also has a similar topic",
+    kthPairDistance: "Kth Smallest Distance Pair",
+    kthPairDistance_desc: "Typical counting binary search, which is essentially an ability test, but the number of questions is large, so it is separated.",
+    JZ51: "Sword Offer 51. Reverse pairs in an array",
+
+    longestIncreasingSubsequence: "Longest Increasing Subsequence Series",
+    longestIncreasingSubsequence_desc: "Series classic topic, worth doing",
   },
   codeTemplate: {
     name: "Code Template",
@@ -137,6 +152,44 @@ const en = {
   },
   learningRoute: {
     name: "Learning Route",
+    dp: "Dynamic Programming",
+    binarySearch: "Binary Search",
+    binarySearchDesc:`
+    If you ask me to summarize binary search in one sentence, I would say that binary search is an algorithm that makes the unknown world inorganic. That is, no matter what, we can discard half of the solutions, that is, we can cut the solution space in half.
+    The difficulty is two points: **what conditions** and **which part to discard**. This is the core problem that binary search needs to solve.
+
+    There are two basic types of tactics, namely the leftmost insertion binary search and the rightmost insertion binary search.
+
+    There are four basic types of strategies: ability detection binary search, prefix sum binary search, insertion sort binary search, and counting binary search.
+
+    These two parts are very practical. While understanding these two parts, please keep in mind a central point **half**.
+
+    For more information, please visit: https://lucifer.ren/blog/2021/03/08/binary-search-1`,
+    binarySearch_item1: "Leftmost/Rightmost Binary Search",
+    binarySearch_item1_text: "Code reference: Code templates - Binary",
+    binarySearch_item1_keys: `
+    1. shrink the right boundary continuously and finally return the left boundary
+    2. shrink the left boundary continuously and finally return the right boundary
+    `,
+    binarySearch_item2: "Ability Detection Binary Search",
+    binarySearch_item2_keys: `Define the function that the possible argument is mid and the return value is a Boolean value. The outer layer adjusts according to the return value "; Solution space" . The sample code is an example of the leftmost binary.
+    `,
+    binarySearch_item3: "Prefix Sum Binary Search",
+    binarySearch_item3_keys: `
+    If the array is non-negative, then the prefix sum is a monotone non-decrement array, and we can sometimes make dichotomies based on it.
+    `,
+    binarySearch_item4: "Insertion Sort Binary Search",
+    binarySearch_item4_keys: `
+    Continuously insert and maintain the ordered sequence, and then use the ordered sequence to do something.
+    `,
+    binarySearch_item5: "Counting Binary Search",
+    binarySearch_item5_keys: `The essence is also ability detection, so it is basically the same as the ability detection framework. Everyone compares and understands.
+    `,
+
+    tree: "Tree",
+    linkedList: "Linked List",
+    clickToEnlarge: "Click to enlarge",
+    recommendedProblems:"Recommended Problems",
   },
   checkForUpdates: {
     name: "Check for Updates",
diff --git a/src/locales/zh.js b/src/locales/zh.js
index 615d071..80fe3dc 100644
--- a/src/locales/zh.js
+++ b/src/locales/zh.js
@@ -57,13 +57,31 @@ const zh = {
     notYet: "暂无",
   },
   problem: {
+    69: "69. x 的平方根",
+    278: "278. 第一个错误的版本",
+    "278_desc":
+      "最左最右思路一样，大家练习两道，实际情况根据题意使用不同的二分即可。",
+    327: "327. 区间和的个数",
+    493: "493. 翻转对",
     743: "743. 网络延迟时间",
+    778: "778. 水位上升的泳池中游泳",
+    "778_desc":
+      "DFS + 二分，类似的题目有很多，比如第 1439 题。这种题套路都很像，难度其实也不算大。",
     1109: "1109. 航班预订统计",
     1314: "1314. 矩阵区域和",
     1462: "1462. 课程表 IV",
     1480: "1480. 一维数组的动态和",
     1584: "1584. 连接所有点的最小费用",
     2536: "2536. 子矩阵元素加 1",
+
+    minimumLightRadius: "最小光照半径",
+    minimumLightRadius_desc: "经典能力检测二分，力扣也有一道类似题",
+    kthPairDistance: "第 K 小的距离对",
+    kthPairDistance_desc: "典型的计数二分，本质上也是能力检测，只不过题量大，单独拆出来。",
+    JZ51: "剑指 Offer 51. 数组中的逆序对",
+
+    longestIncreasingSubsequence: "最长上升子序列系列",
+    longestIncreasingSubsequence_desc: "系列经典题目，值得一做",
   },
   codeTemplate: {
     name: "代码模板",
@@ -130,6 +148,46 @@ const zh = {
   },
   learningRoute: {
     name: "学习路线",
+    dp: "动态规划",
+    binarySearch: "二分查找",
+    binarySearchDesc: `
+    如果让我用一句话总结二分法，我会说**二分法是一种让未知世界无机可乘的算法**。即二分法无论如何我们都可以舍弃一半解，也就是无论如何都可以将解空间砍半。
+    难点就是两点：**什么条件** 和 **舍弃哪部分**。这是二分法核心要解决的问题。
+    
+    从战术上有两种基本类型，分别是最左插入二分和最右插入二分。
+    
+    从战略上有四种基本类型，能力检测二分，前缀和二分，插入排序二分和计数二分。
+    
+    两种类型（最左和最右插入）主要解决的的是：**解空间已经明确出来了，如何用代码找出具体的解**。而四大应用主要解决的是：**如何构造解空间**。更多的情况则是如何构建有序序列。
+
+    这两部分都是实操性很强的内容，在理解这两部分内容的同时，请大家务必牢记一个中心**折半**。
+    
+    更多内容请访问：https://lucifer.ren/blog/2021/03/08/binary-search-1`,
+    binarySearch_item1: "最左/最右二分",
+    binarySearch_item1_text: "代码参考：代码模板 - 二分法",
+    binarySearch_item1_keys: `
+    1. 最左二分不断收缩右边界，最终返回左边界
+    2. 最右二分不断收缩左边界，最终返回右边界
+    `,
+    binarySearch_item2: "能力检测二分",
+    binarySearch_item2_keys: `定义函数 possible 参数是 mid，返回值是布尔值。外层根据返回值调整"解空间"。示例代码是以最左二分为例的。
+    `,
+    binarySearch_item3: "前缀和二分",
+    binarySearch_item3_keys: `
+    如果数组是非负的，那么前缀和就是一个单调不递减数组，我们有时候可以基于它来做二分。
+    `,
+    binarySearch_item4: "插入排序二分",
+    binarySearch_item4_keys: `
+    不断插入并维护序列有序，进而利用有序做一些事情。
+    `,
+    binarySearch_item5: "计数二分",
+    binarySearch_item5_keys: `本质也是能力检测，因此和能力检测框架基本一致，大家对比理解一下。
+    `,
+
+    tree: "树",
+    linkedList: "链表",
+    clickToEnlarge: "单击可放大",
+    recommendedProblems: "推荐题目",
   },
   checkForUpdates: {
     name: "检查更新",
diff --git a/src/roadmap/roadmap.jsx b/src/roadmap/roadmap.jsx
index d8deaa1..3d37c54 100644
--- a/src/roadmap/roadmap.jsx
+++ b/src/roadmap/roadmap.jsx
@@ -3,7 +3,7 @@ import { Radio, Image } from "antd";
 
 import Codes from "../components/codes";
 import TagOrLink from "../components/TagOrLink";
-
+import { t, auto_detect_languange } from "../locales"
 const dpSingleCode = `
   dp = [0] * (n + 1)
   for i in range(1, n + 1):
@@ -15,7 +15,7 @@ const dpDoubleCode = `
         dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
         for i in range(1, m + 1):
             for j in range(1, n + 1):
-                if 一定条件:
+                if Certain conditions:
                   dp[i][j] = dp[i - 1][j - 1] + 1
                 else:
                   dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
@@ -26,12 +26,12 @@ class Solution:
     def solve(self, s):
         n = len(s)
         dp = [[0] * n for _ in range(n)]
-        # 右边界倒序遍历
+        # Traverse in reverse order from the right boundary
         for i in range(n - 1, -1, -1):
-            # 左边界正序遍历
+            # Traverse in forward order from the left boundary
             for j in range(i + 1, n):
                 # do something
-        return  dp[0][m-1] # 一般都是使用这个区间作为答案
+        return  dp[0][m-1] # Typically, this interval is used as the answer.
 `;
 const dpRangeCodeRecur = `
 class Solution:
@@ -48,60 +48,43 @@ class Solution:
 
 const roadmaps = {
   "binary-search": {
-    desc: `
-    如果让我用一句话总结二分法，我会说**二分法是一种让未知世界无机可乘的算法**。即二分法无论如何我们都可以舍弃一半解，也就是无论如何都可以将解空间砍半。
-    难点就是两点：**什么条件** 和 **舍弃哪部分**。这是二分法核心要解决的问题。
-    
-    从战术上有两种基本类型，分别是最左插入二分和最右插入二分。
-    
-    从战略上有四种基本类型，能力检测二分，前缀和二分，插入排序二分和计数二分。
-    
-    两种类型（最左和最右插入）主要解决的的是：**解空间已经明确出来了，如何用代码找出具体的解**。而四大应用主要解决的是：**如何构造解空间**。更多的情况则是如何构建有序序列。
-
-    这两部分都是实操性很强的内容，在理解这两部分内容的同时，请大家务必牢记一个中心**折半**。
-    
-    更多内容请访问：https://lucifer.ren/blog/2021/03/08/binary-search-1`,
+    desc: t("Locale.learningRoute.binarySearchDesc"),
     items: [
       {
-        title: "最左/最右二分",
+        title: t("Locale.learningRoute.binarySearch_item1"),
         pic: void 0,
         problems: [
           {
             link: "https://leetcode-cn.com/problems/sqrtx",
-            text: "69. x 的平方根",
+            text: t("Locale.problem.69"),
           },
           {
             link: "https://leetcode-cn.com/problems/first-bad-version/",
-            text: "278. 第一个错误的版本",
-            desc:
-              "最左最右思路一样，大家练习两道，实际情况根据题意使用不同的二分即可。",
+            text: t("Locale.problem.278"),
+            desc: t("Locale.problem.278_desc"),
           },
         ],
         code: {
           language: "py",
-          text: "代码参考：代码模板 - 二分法",
+          text: t("Locale.learningRoute.binarySearch_item1_text"),
         },
         keys: [
-          `
-      1. 最左二分不断收缩右边界，最终返回左边界
-      2. 最右二分不断收缩左边界，最终返回右边界
-      `,
+          t("Locale.learningRoute.binarySearch_item1_keys"),
         ],
       },
       {
-        title: "能力检测二分",
+        title: t("Locale.learningRoute.binarySearch_item2"),
         pic: void 0,
         problems: [
           {
             link: "https://binarysearch.com/problems/Minimum-Light-Radius",
-            text: "最小灯半径",
-            desc: "经典能力检测二分，力扣也有一道类似题",
+            text: t("Locale.problem.minimumLightRadius"),
+            desc: t("Locale.problem.minimumLightRadius_desc"),
           },
           {
             link: "https://leetcode-cn.com/problems/swim-in-rising-water",
-            text: "778. 水位上升的泳池中游泳",
-            desc:
-              "DFS + 二分，类似的题目有很多，比如第 1439 题。这种题套路都很像，难度其实也不算大。",
+            text: t("Locale.problem.778"),
+            desc: t("Locale.problem.778_desc"),
           },
         ],
         code: {
@@ -113,50 +96,55 @@ def ability_test_bs(nums):
   l, r = 0, len(A) - 1
   while l <= r:
       mid = (l + r) // 2
-      # 只有这里和最左二分不一样
+      # The only difference is here and in the leftmost binary search.
       if possible(mid): l = mid + 1
       else: r = mid - 1
   return l
           `,
         },
         keys: [
-          `定义函数 possible 参数是 mid，返回值是布尔值。外层根据返回值调整"解空间"。示例代码是以最左二分为例的。
-      `,
+      //     `定义函数 possible 参数是 mid，返回值是布尔值。外层根据返回值调整"解空间"。示例代码是以最左二分为例的。
+          // `,
+          t("Locale.learningRoute.binarySearch_item2_keys")
         ],
       },
       {
-        title: "前缀和二分",
+        title: t("Locale.learningRoute.binarySearch_item3"),
         pic: void 0,
         problems: [
           {
             link: "https://leetcode-cn.com/problems/count-of-range-sum/",
-            text: "327. 区间和的个数",
+            text: t("Locale.problem.327"),
           },
         ],
 
         keys: [
-          `
-      如果数组是非负的，那么前缀和就是一个单调不递减数组，我们有时候可以基于它来做二分。
-      `,
+      //     `
+      // 如果数组是非负的，那么前缀和就是一个单调不递减数组，我们有时候可以基于它来做二分。
+          // `,
+          t("Locale.learningRoute.binarySearch_item3_keys"),
+          
         ],
       },
       {
-        title: "插入排序二分",
+        title: t("Locale.learningRoute.binarySearch_item4"),
         pic: void 0,
         problems: [
           {
             link: "https://leetcode-cn.com/problems/reverse-pairs",
-            text: "493. 翻转对",
+            text: t("Locale.problem.493"),
           },
           {
             link:
               "https://leetcode-cn.com/problems/shu-zu-zhong-de-ni-xu-dui-lcof",
-            text: "剑指 Offer 51. 数组中的逆序对",
+            // text: "剑指 Offer 51. 数组中的逆序对",
+            text:t("Locale.problem.JZ51")
           },
           {
             link: "https://lucifer.ren/blog/2020/06/20/LIS/",
-            text: "最长上升子序列系列",
-            desc: "系列经典题目，值得一做",
+            // text: "最长上升子序列系列",
+            text: t("Locale.problem.longestIncreasingSubsequence"),
+            desc: t("Locale.problem.longestIncreasingSubsequence_desc"),
           },
         ],
         code: {
@@ -171,20 +159,22 @@ def ability_test_bs(nums):
           d.append(a)`,
         },
         keys: [
-          `
-      不断插入并维护序列有序，进而利用有序做一些事情。
-      `,
+      //     `
+      // 不断插入并维护序列有序，进而利用有序做一些事情。
+          // `,
+          t("Locale.learningRoute.binarySearch_item4_keys")
         ],
       },
       {
-        title: "计数二分",
+        // title: "计数二分",
+        title: t("Locale.learningRoute.binarySearch_item5"),
         pic: void 0,
         problems: [
           {
             link: "https://binarysearch.com/problems/Kth-Pair-Distance",
-            text: "第k小的距离对",
-            desc:
-              "典型的计数二分，本质上也是能力检测，只不过题量大，单独拆出来。",
+            // text: "第k小的距离对",
+            text: t("Locale.problem.kthPairDistance"),
+            desc:t("Locale.problem.kthPairDistance_desc"),
           },
         ],
         code: {
@@ -196,15 +186,16 @@ def count_bs(nums, k):
   l, r = 0, len(A) - 1
   while l <= r:
       mid = (l + r) // 2
-      # 只有这里和最左二分不一样
+      # Only this is different from the leftmost binary
       if count_not_greater(mid) > k: r = mid - 1
       else: l = mid + 1
   return l
           `,
         },
         keys: [
-          `本质也是能力检测，因此和能力检测框架基本一致，大家对比理解一下。
-      `,
+      //     `本质也是能力检测，因此和能力检测框架基本一致，大家对比理解一下。
+          // `,
+          t("Locale.learningRoute.binarySearch_item5_keys")
         ],
       },
     ],
@@ -548,13 +539,13 @@ export default function RoadMap() {
         value={topic}
         buttonStyle="solid"
       >
-        <Radio.Button value="dp">动态规划</Radio.Button>
-        <Radio.Button value="binary-search">二分</Radio.Button>
+        <Radio.Button value="dp">{t("Locale.learningRoute.dp")}</Radio.Button>
+        <Radio.Button value="binary-search">{t("Locale.learningRoute.binarySearch")}</Radio.Button>
         <Radio.Button value="tree" disabled>
-          树
+          {t("Locale.learningRoute.tree")}
         </Radio.Button>
         <Radio.Button value="linked-list" disabled>
-          链表
+          {t("Locale.learningRoute.linkedList")}
         </Radio.Button>
       </Radio.Group>
       <div>
@@ -571,11 +562,11 @@ export default function RoadMap() {
               {item.pic && (
                 <>
                   <Image src={item.pic} width={400} height={200} />
-                  (单击可放大)
+                  ({t("Locale.learningRoute.clickToEnlarge")})
                 </>
               )}
               {item.code && <Codes codes={[item.code]}></Codes>}
-              推荐题目：
+              { t("Locale.learningRoute.recommendedProblems")}：
               <ul>
                 {item.problems.map(({ link, text, desc }) => {
                   return (

From 52a8f02b165d5b9967286377f31208cab4231c19 Mon Sep 17 00:00:00 2001
From: Renkin <906155099@qq.com>
Date: Mon, 13 Nov 2023 16:12:36 +0800
Subject: [PATCH 2/3] chore: delete unused code

---
 src/roadmap/roadmap.jsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/roadmap/roadmap.jsx b/src/roadmap/roadmap.jsx
index 3d37c54..c84483f 100644
--- a/src/roadmap/roadmap.jsx
+++ b/src/roadmap/roadmap.jsx
@@ -3,7 +3,7 @@ import { Radio, Image } from "antd";
 
 import Codes from "../components/codes";
 import TagOrLink from "../components/TagOrLink";
-import { t, auto_detect_languange } from "../locales"
+import { t } from "../locales"
 const dpSingleCode = `
   dp = [0] * (n + 1)
   for i in range(1, n + 1):

From 7b8f357f80053d1447cf345c25b71f99ec24a0bb Mon Sep 17 00:00:00 2001
From: Renkin <906155099@qq.com>
Date: Tue, 14 Nov 2023 09:58:05 +0800
Subject: [PATCH 3/3] feat: i18n update

---
 src/locales/en.js       | 121 +++++++++++++++++++++++--
 src/locales/zh.js       | 112 ++++++++++++++++++++++-
 src/roadmap/roadmap.jsx | 195 +++++++++++++++++++++-------------------
 3 files changed, 327 insertions(+), 101 deletions(-)

diff --git a/src/locales/en.js b/src/locales/en.js
index fcee689..8311409 100644
--- a/src/locales/en.js
+++ b/src/locales/en.js
@@ -60,28 +60,81 @@ const en = {
     notYet: "Not yet",
   },
   problem: {
+    10: "10. Regular Expression Matching",
+    44: "44. Wildcard Matching",
+    62: "62. Unique Paths",
+    63: "63. Unique Paths II",
+    64: "64. Minimum Path Sum",
     69: "69. Sqrt(x)",
+    70: "70. Climbing Stairs",
+    72: "72. Edit Distance",
+    174: "174. Dungeon Game",
+    198: "198. House Robber",
+    233: "233. Number of Digit One",
     278: "278. First Bad Version",
-    "278_desc": "The idea of the leftmost and rightmost is the same. Everyone can practice two questions. The actual situation can use different binary search according to the meaning of the question.",
+    "278_desc":
+      "The idea of the leftmost and rightmost is the same. Everyone can practice two questions. The actual situation can use different binary search according to the meaning of the question.",
+    292: "292. Nim Game",
     327: "327. Count of Range Sum",
+    322: "322. Coin Change",
+    337: "337. House Robber III",
+    357: "357. Count Numbers with Unique Digits",
+    416: "416. Partition Equal Subset Sum",
+    464: "464. Can I Win",
     493: "493. Reverse Pairs",
+    518: "518. Coin Change 2",
+    576: "576. Out of Boundary Paths(changed from selecting two directions to selecting four directions)",
+    698: "698. Partition to K Equal Sum Subsets",
     743: "743. Network Delay Time",
     778: "778. Swim in Rising Water",
-    "778_desc": "DFS + binary search, there are many similar questions, such as the 1439th question. This kind of question routine is very similar, and the difficulty is not big.",
+    "778_desc":
+      "DFS + binary search, there are many similar questions, such as the 1439th question. This kind of question routine is very similar, and the difficulty is not big.",
+    808: "808. Soup Servings",
+    837: "837. New 21 Game",
+    877: "877. Stone Game",
+    902: "902. Numbers At Most N Given Digit Set",
+    935: "935. Knight Dialer(Changed from selecting two directions to selecting eight directions)",
+    1015: "1015. Smallest Integer Divisible by K",
+    1140: "1140. Stone Game II",
     1109: "1109. Corporate Flight Bookings",
     1314: "1314. Matrix Block Sum",
+    1406: "1406. Stone Game III",
     1462: "1462. Course Schedule IV",
     1480: "1480. Running Sum of 1d Array",
+    1510: "1510. Stone Game IV",
+    1563: "1563. Stone Game V",
     1584: "1584. Min Cost to Connect All Points",
+    1681: "1681. Minimum Incompatibility",
+    1686: "1686. Stone Game VI",
+    "1686_desc":
+      "Except for this one, the other \"Stone Game\" ideas are basically the same",
+    1690: "1690. Stone Game VII",
     2536: "2536. Increment Submatrices by One",
+
+    // https://binarysearch.com/problems
     minimumLightRadius: "Minimum Light Radius",
-    minimumLightRadius_desc: "Classic ability detection binary search, leetcode also has a similar topic",
+    minimumLightRadius_desc:
+      "Classic ability detection binary search, leetcode also has a similar topic",
     kthPairDistance: "Kth Smallest Distance Pair",
-    kthPairDistance_desc: "Typical counting binary search, which is essentially an ability test, but the number of questions is large, so it is separated.",
+    kthPairDistance_desc:
+      "Typical counting binary search, which is essentially an ability test, but the number of questions is large, so it is separated.",
+    increasingDigits: "Increasing Digits",
+    palindromicInsertions: "Palindromic Insertions",
+    palindromicInsertions_desc:
+      "For interval dynamic programming, it is necessary to proceed simultaneously from both ends of the sequence, rather than from one end of the sequence to the other.",
+
+    // 剑指 Offer 系列
     JZ51: "Sword Offer 51. Reverse pairs in an array",
 
+    // 面试题系列
+    interview17_13: "Interview 17.13. Re-Space LCCI",
+    interview17_13__desc:
+      "CHow to practice the details? 1? - 1? How to initialize? You can learn through this question ~",
+
     longestIncreasingSubsequence: "Longest Increasing Subsequence Series",
     longestIncreasingSubsequence_desc: "Series classic topic, worth doing",
+    littleRabbitsChessboard: "Little Rabbit's Chessboard",
+    shopeesOffice: "Shopee's Office",
   },
   codeTemplate: {
     name: "Code Template",
@@ -152,9 +205,8 @@ const en = {
   },
   learningRoute: {
     name: "Learning Route",
-    dp: "Dynamic Programming",
     binarySearch: "Binary Search",
-    binarySearchDesc:`
+    binarySearchDesc: `
     If you ask me to summarize binary search in one sentence, I would say that binary search is an algorithm that makes the unknown world inorganic. That is, no matter what, we can discard half of the solutions, that is, we can cut the solution space in half.
     The difficulty is two points: **what conditions** and **which part to discard**. This is the core problem that binary search needs to solve.
 
@@ -186,10 +238,65 @@ const en = {
     binarySearch_item5_keys: `The essence is also ability detection, so it is basically the same as the ability detection framework. Everyone compares and understands.
     `,
 
+    dp: "Dynamic Programming",
+    dp_desc: `The basic framework for different problems of the same type is generally consistent, but with slight variations in details. The template code is explained using a specific type as an example, and individuals should make adjustments based on the actual situation.
+
+    The three key points for dynamic programming are: state, enumeration, and transition equations (choices). For each type of problem, I try to provide hints based on these three points.
+    
+    Of course, this learning path is intended for those with some foundation. If you don't have a foundation yet, you can refer to related articles. I will also write a comprehensive routine article in the future.`,
+    dp_item1: "Single string type",
+    dp_item1_keys1: `
+    State: 1. dp[i] represents the xxxx ending with s[i]
+           2. dp[i] represents the xxxx up to s[i]`,
+    dp_item1_keys2:
+      "Enumeration: It usually involves two nested loops, where one loop fixes the left endpoint and the other loop fixes the right endpoint for enumeration.",
+    dp_item1_keys3:
+      "Transition equation: Based on the problem, choose whether to combine with s[j], then take the maximum, minimum, or count as required.",
+
+    dp_item2: "Double string type",
+    dp_item2_keys1: `
+    State: 1. dp[i][j] represents the xxxx ending with s1[i], s2[j]
+           2. dp[i][j] represents the xxxx up to s1[i], s2[j]`,
+    dp_item2_keys2:
+      "Enumeration: Typically, it involves two nested loops, where one loop fixes the right endpoint of s1, and the other loop fixes the right endpoint of s2 for enumeration.",
+    dp_item2_keys3:
+      "State transition: Based on the problem and the relationship between s[i] and s[j], take the maximum, minimum, or count as required.",
+
+    dp_item3: "Sequence type",
+    dp_item3_keys1: `
+    State: 1. In one-dimensional arrays, dp[i] usually represents the xxxx ending with nums[i]
+           2. In two-dimensional arrays, dp[i][j] usually represents the xxxx ending with grid[i][j]`,
+    dp_item3_keys2:
+      "Enumeration: One-dimensional involves a single loop to enumerate all nums, while two-dimensional involves two loops to enumerate all grid.",
+    dp_item3_keys3: `
+    State transition: 1. In one dimension, it usually involves the relationship between the current cell and the preceding two cells, possibly involving maximum, minimum, or counting.
+                      dp[i] = dp[i - 1] + dp[i - 2]" This is also called a recurrence relation because it does not involve decision-making.
+                      2. In two dimensions, it usually involves the relationship between the current cell and its upper and left adjacent cells, possibly involving maximum, minimum, or counting.
+                      dp[i][j] = dp[i - 1][j] + dp[i][j-1]" This is also called a recurrence relation because it does not involve decision-making.
+                      3. From the transition equation, it's not difficult to see that this type of problem can usually be optimized using rolling arrays.
+    `,
+
+    dp_item4: "Backpack type(List only the problems)",
+    dp_item5: "Number type(List only the problems)",
+    dp_item5_keys1:
+      "The common definition of dynamic programming is represented as dp[i][j], where i stands for the length of the number, and j represents the last digit. For example, dp[3][2] denotes a number with a total of three digits, with 2 as the last digit.",
+    dp_item6: "Probability type(List only the problems)",
+    dp_item7: "Game type(List only the problems)",
+
+    dp_item8: "Interval DP",
+    dp_item8_text_comment:
+      "Using memoization might lead to better code writing. For example, the above DP code can be transformed into memoized recursion as:",
+    dp_item8_keys1: `
+    Traversing in reverse from the right boundary and in forward from the left boundary
+            `,
+    dp_item8_keys2:
+      "Typically, the return value is dp[0][n], rather than other common dp[-1][-1].",
+    dp_item9: "State compression type(List only the problems)",
+
     tree: "Tree",
     linkedList: "Linked List",
     clickToEnlarge: "Click to enlarge",
-    recommendedProblems:"Recommended Problems",
+    recommendedProblems: "Recommended Problems",
   },
   checkForUpdates: {
     name: "Check for Updates",
diff --git a/src/locales/zh.js b/src/locales/zh.js
index 80fe3dc..2486017 100644
--- a/src/locales/zh.js
+++ b/src/locales/zh.js
@@ -57,31 +57,79 @@ const zh = {
     notYet: "暂无",
   },
   problem: {
+    10: "10. 正则表达式匹配",
+    44: "44. 通配符匹配",
+    62: "62. 不同路径",
+    63: "63. 不同路径 II",
+    64: "64. 最小路径和",
     69: "69. x 的平方根",
+    70: "70. 爬楼梯",
+    72: "72. 编辑距离",
+    174: "174. 地下城游戏",
+    198: "198. 打家劫舍",
+    233: "233. 数字 1 的个数",
     278: "278. 第一个错误的版本",
     "278_desc":
       "最左最右思路一样，大家练习两道，实际情况根据题意使用不同的二分即可。",
+    292: "292. Nim 游戏",
     327: "327. 区间和的个数",
+    322: "322. 零钱兑换",
+    337: "337. 打家劫舍 III",
+    357: "357. 计算各个位数不同的数字个数",
+    416: "416. 分割等和子集",
+    464: "464. 我能赢吗",
     493: "493. 翻转对",
+    518: "518. 零钱兑换 II",
+    576: "576. 出界的路径数(只能选两个方向变成了只能选四个方向而已)",
+    698: "698. 划分为 k 个相等的子集",
     743: "743. 网络延迟时间",
     778: "778. 水位上升的泳池中游泳",
     "778_desc":
       "DFS + 二分，类似的题目有很多，比如第 1439 题。这种题套路都很像，难度其实也不算大。",
+    808: "808. 分汤",
+    837: "837. 新21点",
+    877: "877. 石子游戏",
+    902: "902. 最大为 N 的数字组合",
+    935: "935. 骑士拨号器(只能选两个方向变成了只能选八个方向而已)",
+    1015: "1015. 可被 K 整除的最小整数",
     1109: "1109. 航班预订统计",
+    1140: "1140. 石子游戏 II",
     1314: "1314. 矩阵区域和",
+    1406: "1406. 石子游戏 III",
     1462: "1462. 课程表 IV",
     1480: "1480. 一维数组的动态和",
+    1510: "1510. 石子游戏 IV",
+    1563: "1563. 石子游戏 V",
     1584: "1584. 连接所有点的最小费用",
+    1681: "1681. 最小不兼容性",
+    1686: "1686. 石子游戏 VI",
+    "1686_desc": "除了这个，其他《石子游戏》思路基本都一样",
+    1690: "1690. 石子游戏 VII",
     2536: "2536. 子矩阵元素加 1",
 
+    // https://binarysearch.com/problems
     minimumLightRadius: "最小光照半径",
     minimumLightRadius_desc: "经典能力检测二分，力扣也有一道类似题",
     kthPairDistance: "第 K 小的距离对",
-    kthPairDistance_desc: "典型的计数二分，本质上也是能力检测，只不过题量大，单独拆出来。",
+    kthPairDistance_desc:
+      "典型的计数二分，本质上也是能力检测，只不过题量大，单独拆出来。",
+    increasingDigits: "递增的数位",
+    palindromicInsertions: "回文插入",
+    palindromicInsertions_desc:
+      "区间 dp 需要从序列两头同时进行，而不是从序列的某一端到另一端",
+
+    // 剑指 Offer 系列
     JZ51: "剑指 Offer 51. 数组中的逆序对",
 
+    // 面试题系列
+    interview17_13: "面试题 17.13. 恢复空格",
+    interview17_13__desc:
+      "细节怎么练？+1？ -1? 怎么初始化？大家可以通过这道题学习一下~",
+
     longestIncreasingSubsequence: "最长上升子序列系列",
     longestIncreasingSubsequence_desc: "系列经典题目，值得一做",
+    littleRabbitsChessboard: "小兔的棋盘",
+    shopeesOffice: "Shopee 的办公室",
   },
   codeTemplate: {
     name: "代码模板",
@@ -148,7 +196,6 @@ const zh = {
   },
   learningRoute: {
     name: "学习路线",
-    dp: "动态规划",
     binarySearch: "二分查找",
     binarySearchDesc: `
     如果让我用一句话总结二分法，我会说**二分法是一种让未知世界无机可乘的算法**。即二分法无论如何我们都可以舍弃一半解，也就是无论如何都可以将解空间砍半。
@@ -184,6 +231,67 @@ const zh = {
     binarySearch_item5_keys: `本质也是能力检测，因此和能力检测框架基本一致，大家对比理解一下。
     `,
 
+    dp: "动态规划",
+    dp_desc: `
+    同一类型的不同题目框架基本一致，但细节略有不同，模板代码仅以某一种为例进行讲述，大家根据实际情况微调。
+    
+    动态规划三把斧：状态，枚举，转移方程（选择）。对于每一种题目，我都尽量按照这三点给大家提示。
+    
+    当然这个学习路线是给有一些基础的人看的，如果你还没有基础，可以看下相关文章，之后我也会写一篇硬核套路文。
+    `,
+    dp_item1: "单字符串型",
+    dp_item1_keys1: `
+    状态：1. dp[i] 表示以 s[i] 结尾的 xxxx
+         2. dp[i] 表示到 s[i] 为止的 xxxx
+    `,
+
+    dp_item1_keys2:
+      "枚举：通常都是两层循环，一层循环固定左端点，另一层循环固定右端点进行枚举",
+    dp_item1_keys3:
+      "转移方程：根据题目选择是否和 s[j] 结合，取最大，最小或计数即可",
+
+    dp_item2: "双字符串型",
+    dp_item2_keys1: `
+    状态：1. dp[i][j] 表示以 s1[i],s2[j] 结尾的 xxxx
+         2. dp[i][j] 表示到 s1[i],s2[j] 为止的 xxxx
+    `,
+    dp_item2_keys2:
+      "枚举：通常都是两层循环，一层循环固定 s1 的右端点，另一层循环固定 s2 的右端点进行枚举",
+    dp_item2_keys3:
+      "状态转移：根据题目以及 s[i]， s[j] 的关系，取最大，最小或计数即可",
+
+    dp_item3: "爬楼梯型",
+    dp_item3_keys1: `
+    状态：1. 一维通常是 dp[i] 表示以 nums[i] 结尾的 xxxx
+         2. 二维通常是 dp[i][j] 表示以 grid[i][j] 结尾的 xxxx
+    `,
+    dp_item3_keys2:
+      "枚举：一维就是一层循环枚举所有的 nums，二维就是两层循环枚举所有的 grid",
+    dp_item3_keys3: `
+    状态转移：1. 一维通常是当前格子和前面的两个格子的关系，可能是最大最小或计数。 
+            dp[i] = dp[i - 1] + dp[i - 2]，这也叫递推式，因为不涉及决策。
+            2. 二维通常是当前格子和上方以及左方的两个格子的关系，可能是最大最小或计数。
+            dp[i][j] = dp[i - 1][j] + dp[i][j-1]，这也叫递推式，因为不涉及决策。
+            3. 根转移方程不难看出， 这种题目通常都可以滚动数组优化
+            `,
+
+    dp_item4: "背包型（仅列举题目）",
+    dp_item5: "数位型（仅列举题目）",
+    dp_item5_keys1:
+      "常见的 dp 定义为 dp[i][j] 其中 i 为数字的长度， j 为最后一位的数。比如 dp[3][2] 表示这个数一共三位，最后一位是 2 的情况",
+
+    dp_item6: "概率型（仅列举题目）",
+    dp_item7: "博弈型（仅列举题目）",
+
+    dp_item8: "区间 DP",
+    dp_item8_text_comment:
+      "使用记忆化可能会更好书写，比如上面的 dp 代码改成记忆化递归就是：",
+    dp_item8_keys1: `
+    右边界倒序遍历，左边界正序遍历
+    `,
+    dp_item8_keys2: "通常都是返回 dp[0][n]，而不是其他常见的 dp[-1][-1]",
+    dp_item9: "状态压缩型（仅列举题目）",
+
     tree: "树",
     linkedList: "链表",
     clickToEnlarge: "单击可放大",
diff --git a/src/roadmap/roadmap.jsx b/src/roadmap/roadmap.jsx
index c84483f..9f9ef54 100644
--- a/src/roadmap/roadmap.jsx
+++ b/src/roadmap/roadmap.jsx
@@ -201,29 +201,25 @@ def count_bs(nums, k):
     ],
   },
   dp: {
-    desc: `
-  同一类型的不同题目框架基本一致，但细节略有不同，模板代码仅以某一种为例进行讲述，大家根据实际情况微调。
-  
-  动态规划三把斧：状态，枚举，转移方程（选择）。对于每一种题目，我都尽量按照这三点给大家提示。
-  
-  当然这个学习路线是给有一些基础的人看的，如果你还没有基础，可以看下相关文章，之后我也会写一篇硬核套路文。
-  `,
+    desc: t("Locale.learningRoute.dp_desc"),
     items: [
       {
-        title: "单字符串型",
+        title: t("Locale.learningRoute.dp_item1"),
         pic:
           "https://p.ipic.vip/575fs3.jpg",
         problems: [
           {
             link: "https://leetcode-cn.com/problems/re-space-lcci/",
-            text: "面试题 17.13. 恢复空格",
+            // text: "面试题 17.13. 恢复空格",
+            text: t("Locale.problem.interview17_13"),
             desc:
-              "细节怎么练？+1？ -1? 怎么初始化？大家可以通过这道题学习一下~",
+            // "细节怎么练？+1？ -1? 怎么初始化？大家可以通过这道题学习一下~",
+            t("Locale.problem.interview17_13__desc")
           },
           {
             link: "https://lucifer.ren/blog/2020/06/20/LIS/",
-            text: "最长上升子序列系列",
-            desc: "系列经典题目，值得一做",
+            text: t("Locale.problem.longestIncreasingSubsequence")  ,
+            desc: t("Locale.problem.longestIncreasingSubsequence_desc"),
           },
         ],
         code: {
@@ -231,38 +227,41 @@ def count_bs(nums, k):
           text: dpSingleCode,
         },
         keys: [
-          `
-状态：1. dp[i] 表示以 s[i] 结尾的 xxxx
-     2. dp[i] 表示到 s[i] 为止的 xxxx
-        `,
-          "枚举： 通常都是两层循环，一层循环固定左端点，另一层循环固定右端点进行枚举",
-          "转移方程：根据题目选择是否和 s[j] 结合，取最大，最小或计数即可",
+//           `
+// 状态：1. dp[i] 表示以 s[i] 结尾的 xxxx
+//      2. dp[i] 表示到 s[i] 为止的 xxxx
+          //         `,
+          t("Locale.learningRoute.dp_item1_keys1"),
+          // "枚举： 通常都是两层循环，一层循环固定左端点，另一层循环固定右端点进行枚举",
+          t("Locale.learningRoute.dp_item1_keys2"),
+          // "转移方程：根据题目选择是否和 s[j] 结合，取最大，最小或计数即可",
+          t("Locale.learningRoute.dp_item1_keys3")
         ],
       },
 
       {
-        title: "双字符串型",
+        title: t("Locale.learningRoute.dp_item2"),
         pic:
           "https://p.ipic.vip/f5uljj.jpg",
         problems: [
           {
             link: "https://lucifer.ren/blog/2020/07/01/LCS/",
-            text: "最长公共子序列系列",
-            desc: "系列经典题目，值得一做",
+            text: t("Locale.problem.longestIncreasingSubsequence")  ,
+            desc: t("Locale.problem.longestIncreasingSubsequence_desc"),
           },
           {
             link: "https://leetcode-cn.com/problems/edit-distance/",
-            text: "72. 编辑距离",
+            text: t("Locale.problem.72"),
           },
           {
             link:
               "https://leetcode-cn.com/problems/regular-expression-matching/solution/chao-jian-dan-de-ji-yi-hua-di-gui-ji-bai-9010-zhen/",
-            text: "10. 正则表达式匹配",
+            text: t("Locale.problem.10"),
           },
           {
             link:
               "https://leetcode-cn.com/problems/wildcard-matching/solution/chao-ji-xiang-xi-ji-yi-hua-di-gui-tu-jie-dai-ni-yi/",
-            text: "44. 通配符匹配",
+            text: t("Locale.problem.44"),
           },
         ],
         code: {
@@ -270,66 +269,69 @@ def count_bs(nums, k):
           text: dpDoubleCode,
         },
         keys: [
-          `
-状态：1. dp[i][j] 表示以 s1[i],s2[j] 结尾的 xxxx
-     2. dp[i][j] 表示到 s1[i],s2[j] 为止的 xxxx
-        `,
-          "枚举：通常都是两层循环，一层循环固定 s1 的右端点，另一层循环固定 s2 的右端点进行枚举",
-          "状态转移：根据题目以及 s[i]， s[j] 的关系，取最大，最小或计数即可",
+//           `
+// 状态：1. dp[i][j] 表示以 s1[i],s2[j] 结尾的 xxxx
+//      2. dp[i][j] 表示到 s1[i],s2[j] 为止的 xxxx
+          //         `,
+          t("Locale.learningRoute.dp_item2_keys1"),
+          // "枚举：通常都是两层循环，一层循环固定 s1 的右端点，另一层循环固定 s2 的右端点进行枚举",
+          t("Locale.learningRoute.dp_item2_keys2"),
+          // "状态转移：根据题目以及 s[i]， s[j] 的关系，取最大，最小或计数即可",
+          t("Locale.learningRoute.dp_item2_keys3")
         ],
       },
       {
-        title: "爬楼梯型",
+        title: t("Locale.learningRoute.dp_item3"),
         pic:
           "https://p.ipic.vip/gr1c58.jpg",
         problems: [
           {
-            text: "70. 爬楼梯",
+            text: t("Locale.problem.70"),
             link: "https://leetcode-cn.com/problems/climbing-stairs/",
           },
           {
-            text: "198. 打家劫舍",
+            text: t("Locale.problem.198"),
             link:
               "https://github.com/azl397985856/leetcode/blob/master/problems/198.house-robber.md",
           },
           {
-            text: "337. 打家劫舍 III",
+            text: t("Locale.problem.337"),
             link:
               "https://github.com/azl397985856/leetcode/blob/master/problems/337.house-robber-iii.md",
           },
           {
-            text: "62. 不同路径",
+            text: t("Locale.problem.62"),
             link:
               "https://github.com/azl397985856/leetcode/blob/master/problems/62.unique-paths.md",
           },
           {
-            text: "63. 不同路径 II",
+            text: t("Locale.problem.63"),
             link:
               "https://github.com/azl397985856/leetcode/blob/master/problems/63.unique-paths-ii.md",
           },
           {
-            text: "64. 最小路径和",
+            text: t("Locale.problem.64"),
             link: "https://leetcode-cn.com/problems/minimum-path-sum/",
           },
           {
-            text: "174. 地下城游戏",
+            text: t("Locale.problem.174"),
             link: "https://leetcode-cn.com/problems/dungeon-game/",
           },
           {
-            text: "576. 出界的路径数(只能选两个方向变成了只能选四个方向而已)",
+            text: t("Locale.problem.576"),
             link: "https://leetcode-cn.com/problems/out-of-boundary-paths/",
           },
           {
-            text: "935. 骑士拨号器(只能选两个方向变成了只能选八个方向而已)",
+            text: t("Locale.problem.935"),
             link:
               "https://github.com/azl397985856/leetcode/blob/master/problems/935.knight-dialer.md",
           },
           {
-            text: "小兔的棋盘",
+            text: t("Locale.problem.littleRabbitsChessboard"),
             link: "https://github.com/azl397985856/leetcode/issues/429",
           },
           {
-            text: "Shopee的办公室",
+            text: t("Locale.problem.shopeesOffice"),
             link:
               "https://www.nowcoder.com/questionTerminal/a71f3bd890734201986cd1e171807d30?commentTags=Python",
           },
@@ -337,10 +339,10 @@ def count_bs(nums, k):
         code: {
           language: "py",
           text: `
-      # 一维
+      # one-dimensional
       for i in range(2, n):
         cur, prev = max(prev + nums[i], cur), cur
-      # 二维
+      # two-dimensional.
       def uniquePaths(self, m: int, n: int) -> int:
           dp = [1] * n
           for _ in range(1, m):
@@ -349,36 +351,39 @@ def count_bs(nums, k):
         `,
         },
         keys: [
-          `
-状态： 1. 一维通常是 dp[i] 表示以 nums[i] 结尾的 xxxx
-      2. 二维通常是 dp[i][j] 表示以 grid[i][j] 结尾的 xxxx
-      `,
-          "枚举：一维就是一层循环枚举所有的 nums，二维就是两层循环枚举所有的 grid",
-          `
-状态转移：1. 一维通常是当前格子和前面的两个格子的关系，可能是最大最小或计数。 
-        dp[i] = dp[i - 1] + dp[i - 2]，这也叫递推式，因为不涉及决策。
-        2. 二维通常是当前格子和上方以及左方的两个格子的关系，可能是最大最小或计数。
-        dp[i][j] = dp[i - 1][j] + dp[i][j-1]，这也叫递推式，因为不涉及决策。
-        3. 根转移方程不难看出， 这种题目通常都可以滚动数组优化
-        `,
+//           `
+// 状态： 1. 一维通常是 dp[i] 表示以 nums[i] 结尾的 xxxx
+//       2. 二维通常是 dp[i][j] 表示以 grid[i][j] 结尾的 xxxx
+          //       `,
+          t("Locale.learningRoute.dp_item3_keys1"),
+          // "枚举：一维就是一层循环枚举所有的 nums，二维就是两层循环枚举所有的 grid",
+          t("Locale.learningRoute.dp_item3_keys2"),
+//           `
+// 状态转移：1. 一维通常是当前格子和前面的两个格子的关系，可能是最大最小或计数。 
+//         dp[i] = dp[i - 1] + dp[i - 2]，这也叫递推式，因为不涉及决策。
+//         2. 二维通常是当前格子和上方以及左方的两个格子的关系，可能是最大最小或计数。
+//         dp[i][j] = dp[i - 1][j] + dp[i][j-1]，这也叫递推式，因为不涉及决策。
+//         3. 根转移方程不难看出， 这种题目通常都可以滚动数组优化
+          //         `,
+          t("Locale.learningRoute.dp_item3_keys3")
         ],
       },
       {
-        title: "背包型（仅列举题目）",
+        title: t("Locale.learningRoute.dp_item4"),
         pic: "",
         problems: [
           {
-            text: "416. 分割等和子集",
+            text: t("Locale.problem.416"),
             link:
               "https://github.com/azl397985856/leetcode/blob/master/problems/416.partition-equal-subset-sum.md",
           },
           {
-            text: "322. 零钱兑换",
+            text: t("Locale.problem.322"),
             link:
               "https://github.com/azl397985856/leetcode/blob/master/problems/322.coin-change.md",
           },
           {
-            text: "518. 零钱兑换 II",
+            text: t("Locale.problem.518"),
             link:
               "https://github.com/azl397985856/leetcode/blob/master/problems/518.coin-change-2.md",
           },
@@ -387,48 +392,49 @@ def count_bs(nums, k):
         keys: [],
       },
       {
-        title: "数位型（仅列举题目）",
+        title: t("Locale.learningRoute.dp_item5"),
         pic: "",
         problems: [
           {
-            text: "233. 数字 1 的个数",
+            text: t("Locale.problem.233"),
             link: "https://leetcode-cn.com/problems/number-of-digit-one/",
           },
           {
-            text: "357. 计算各个位数不同的数字个数",
+            text: t("Locale.problem.357"),
             link:
               "https://leetcode-cn.com/problems/count-numbers-with-unique-digits/",
           },
           {
-            text: "902. 最大为 N 的数字组合",
+            text: t("Locale.problem.902"),
             link:
               "https://leetcode-cn.com/problems/numbers-at-most-n-given-digit-set/",
           },
           {
-            text: "1015. 可被 K 整除的最小整数",
+            text: t("Locale.problem.1015"),
             link:
               "https://github.com/azl397985856/leetcode/blob/master/problems/1015.smallest-integer-divisible-by-k.md",
           },
           {
-            text: "递增的数位",
+            text: t("Locale.problem.increasingDigits"),
             link: "https://binarysearch.com/problems/Increasing-Digits",
           },
         ],
         code: void 0,
         keys: [
-          "常见的 dp 定义为 dp[i][j] 其中 i 为数字的长度， j 为最后一位的数。比如 dp[3][2] 表示这个数一共三位，最后一位是 2 的情况",
+          // "常见的 dp 定义为 dp[i][j] 其中 i 为数字的长度， j 为最后一位的数。比如 dp[3][2] 表示这个数一共三位，最后一位是 2 的情况",
+          t("Locale.learningRoute.dp_item5_keys1")
         ],
       },
       {
-        title: "概率型（仅列举题目）",
+        title: t("Locale.learningRoute.dp_item6"),
         pic: "",
         problems: [
           {
-            text: "808. 分汤",
+            text: t("Locale.problem.808"),
             link: "https://leetcode-cn.com/problems/soup-servings/",
           },
           {
-            text: "837. 新21点",
+            text: t("Locale.problem.837"),
             link: "https://leetcode-cn.com/problems/new-21-game/",
           },
         ],
@@ -436,41 +442,41 @@ def count_bs(nums, k):
         keys: [],
       },
       {
-        title: "博弈型（仅列举题目）",
+        title: t("Locale.learningRoute.dp_item7"),
         pic: "",
         problems: [
           {
-            text: "292. Nim 游戏",
+            text: t("Locale.problem.292"),
             link: "https://leetcode-cn.com/problems/nim-game/",
           },
           {
-            text: "877. 石子游戏",
+            text: t("Locale.problem.877"),
             link:
               "https://github.com/azl397985856/leetcode/blob/master/problems/877.stone-game.md",
           },
           {
-            text: "1140. 石子游戏 II",
+            text: t("Locale.problem.1140"),
             link: "https://leetcode-cn.com/problems/stone-game-ii/",
           },
           {
-            text: "1406. 石子游戏 III",
+            text: t("Locale.problem.1406"),
             link: "https://leetcode-cn.com/problems/stone-game-iii/",
           },
           {
-            text: "1510. 石子游戏 IV",
+            text: t("Locale.problem.1510"),
             link: "https://leetcode-cn.com/problems/stone-game-iv/",
           },
           {
-            text: "1563. 石子游戏 V",
+            text: t("Locale.problem.1563"),
             link: "https://leetcode-cn.com/problems/stone-game-v/",
           },
           {
-            text: "1686. 石子游戏 VI",
-            desc: "除了这个，其他《石子游戏》思路基本都一样",
+            text: t("Locale.problem.1686"),
+            desc: t("Locale.problem.1686_desc"),
             link: "https://leetcode-cn.com/problems/stone-game-vi/",
           },
           {
-            text: "1690. 石子游戏 VII",
+            text: t("Locale.problem.1690"),
             link: "https://leetcode-cn.com/problems/stone-game-vii/",
           },
         ],
@@ -478,16 +484,17 @@ def count_bs(nums, k):
         keys: [],
       },
       {
-        title: "区间 DP",
+        title: t("Locale.learningRoute.dp_item8"),
         // pic:
         //   "https://p.ipic.vip/575fs3.jpg",
         problems: [
           {
             link:
               "https://binarysearch.com/problems/Make-a-Palindrome-by-Inserting-Characters",
-            text: "回文插入",
+            text: t("Locale.problem.palindromicInsertions"),
             desc:
-              "区间 dp 需要从序列两头同时进行，而不是从序列的某一端到另一端",
+            // "区间 dp 需要从序列两头同时进行，而不是从序列的某一端到另一端",
+            t("Locale.problem.palindromicInsertions_desc")
           },
         ],
         code: {
@@ -495,31 +502,35 @@ def count_bs(nums, k):
           text: `
           
 ${dpRangeCode}
-# 使用记忆化可能会更好书写，比如上面的 dp 代码改成记忆化递归就是：
+# ${
+  // 使用记忆化可能会更好书写，比如上面的 dp 代码改成记忆化递归就是：
+t("Locale.learningRoute.dp_item8_text_comment")}
 ${dpRangeCodeRecur}`,
         },
         keys: [
-          `
-右边界倒序遍历，左边界正序遍历
-        `,
-          "通常都是返回 dp[0][n]，而不是其他常见的 dp[-1][-1]",
+//           `
+// 右边界倒序遍历，左边界正序遍历
+          //         `,
+          t("Locale.learningRoute.dp_item8_keys1"),
+          // "通常都是返回 dp[0][n]，而不是其他常见的 dp[-1][-1]",
+          t("Locale.learningRoute.dp_item8_keys2")
         ],
       },
       {
-        title: "状态压缩型（仅列举题目）",
+        title: t("Locale.learningRoute.dp_item9"),
         pic: "",
         problems: [
           {
-            text: "464. 我能赢吗",
+            text: t("Locale.problem.464"),
             link: "https://leetcode-cn.com/problems/can-i-win/",
           },
           {
-            text: "698. 划分为k个相等的子集",
+            text: t("Locale.problem.698"),
             link:
               "https://leetcode-cn.com/problems/partition-to-k-equal-sum-subsets/",
           },
           {
-            text: "1681. 最小不兼容性",
+            text: t("Locale.problem.1681"),
             link: "https://leetcode-cn.com/problems/minimum-incompatibility/",
           },
         ],