diff --git a/problems/0416.分割等和子集.md b/problems/0416.分割等和子集.md
index 5419fc1f..83b267ac 100644
--- a/problems/0416.分割等和子集.md
+++ b/problems/0416.分割等和子集.md
@@ -183,7 +183,7 @@ public:
 ## 其他语言版本
 
 
-Java：
+### Java：
 ```Java
 class Solution {
     public boolean canPartition(int[] nums) {
@@ -316,7 +316,7 @@ class Solution {
     }
 }
 ```
-Python：
+### Python：
 ```python
 class Solution:
     def canPartition(self, nums: List[int]) -> bool:
@@ -329,7 +329,7 @@ class Solution:
                 dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])
         return target == dp[target]
 ```
-Go：
+### Go：
 ```go
 // 分割等和子集 动态规划
 // 时间复杂度O(n^2) 空间复杂度O(n)
@@ -397,7 +397,7 @@ func canPartition(nums []int) bool {
 }
 ```
 
-javaScript: 
+### javaScript: 
 
 ```js
 var canPartition = function(nums) {
@@ -417,27 +417,11 @@ var canPartition = function(nums) {
 ```
 
 
-TypeScript:
-
-```ts
-function canPartition(nums: number[]): boolean {
-    const sum: number = nums.reduce((a: number, b: number): number => a + b);
-    if (sum % 2 === 1) return false;
-    const target: number = sum / 2;
-    // dp[j]表示容量（总数和）为j的背包所能装下的数（下标[0, i]之间任意取）的总和（<= 容量）的最大值
-    const dp: number[] = new Array(target + 1).fill(0);
-    const n: number = nums.length;
-    for (let i: number = 0; i < n; i++) {
-        for (let j: number = target; j >= nums[i]; j--) {
-            dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
-        }
-    }
-    return dp[target] === target;
-};
-```
 
 
-C:
+
+### C:
+
 二维dp：
 ```c
 /**
@@ -538,7 +522,7 @@ bool canPartition(int* nums, int numsSize){
 }
 ```
 
-TypeScript:
+### TypeScript:
 
 > 一维数组，简洁
 
@@ -593,7 +577,50 @@ function canPartition(nums: number[]): boolean {
 };
 ```
 
+### Scala
 
+滚动数组:
+```scala
+object Solution {
+  def canPartition(nums: Array[Int]): Boolean = {
+    var sum = nums.sum
+    if (sum % 2 != 0) return false
+    var half = sum / 2
+    var dp = new Array[Int](half + 1)
+
+    // 遍历
+    for (i <- 0 until nums.length; j <- half to nums(i) by -1) {
+      dp(j) = math.max(dp(j), dp(j - nums(i)) + nums(i))
+    }
+
+    if (dp(half) == half) true else false
+  }
+}
+```
+
+二维数组:
+```scala
+object Solution {
+  def canPartition(nums: Array[Int]): Boolean = {
+    var sum = nums.sum
+    if (sum % 2 != 0) return false
+    var half = sum / 2
+    var dp = Array.ofDim[Int](nums.length, half + 1)
+    
+    // 初始化
+    for (j <- nums(0) to half) dp(0)(j) = nums(0)
+
+    // 遍历
+    for (i <- 1 until nums.length; j <- 1 to half) {
+      if (j - nums(i) >= 0) dp(i)(j) = nums(i) + dp(i - 1)(j - nums(i))
+      dp(i)(j) = math.max(dp(i)(j), dp(i - 1)(j))
+    }
+    
+    // 如果等于half就返回ture，否则返回false
+    if (dp(nums.length - 1)(half) == half) true else false
+  }
+}
+```
 
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>
diff --git a/problems/1049.最后一块石头的重量II.md b/problems/1049.最后一块石头的重量II.md
index 46777642..b08f4b15 100644
--- a/problems/1049.最后一块石头的重量II.md
+++ b/problems/1049.最后一块石头的重量II.md
@@ -152,7 +152,7 @@ public:
 ## 其他语言版本
 
 
-Java：
+### Java：
 
 一维数组版本
 ```Java
@@ -212,7 +212,7 @@ class Solution {
 
 ```
 
-Python：
+### Python：
 ```python
 class Solution:
     def lastStoneWeightII(self, stones: List[int]) -> int:
@@ -225,7 +225,7 @@ class Solution:
         return sumweight -  2 * dp[target]
 ```
 
-Go：
+### Go：
 ```go
 func lastStoneWeightII(stones []int) int {
 	// 15001 = 30 * 1000 /2 +1
@@ -254,7 +254,7 @@ func max(a, b int) int {
 }
 ```
 
-JavaScript版本
+### JavaScript
 
 ```javascript
 /**
@@ -277,7 +277,7 @@ var lastStoneWeightII = function (stones) {
 };
 ```
 
-C版本
+### C
 ```c
 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
 
@@ -308,8 +308,7 @@ int lastStoneWeightII(int* stones, int stonesSize){
 }
 ```
 
-
-TypeScript版本
+### TypeScript：
 
 ```ts
 function lastStoneWeightII(stones: number[]): number {
@@ -327,7 +326,47 @@ function lastStoneWeightII(stones: number[]): number {
 };
 ```
 
+### Scala
 
+滚动数组:
+```scala
+object Solution {
+  def lastStoneWeightII(stones: Array[Int]): Int = {
+    var sum = stones.sum
+    var half = sum / 2
+    var dp = new Array[Int](half + 1)
+
+    // 遍历
+    for (i <- 0 until stones.length; j <- half to stones(i) by -1) {
+      dp(j) = math.max(dp(j), dp(j - stones(i)) + stones(i))
+    }
+
+    sum - 2 * dp(half)
+  }
+}
+```
+
+二维数组:
+```scala
+object Solution {
+  def lastStoneWeightII(stones: Array[Int]): Int = {
+    var sum = stones.sum
+    var half = sum / 2
+    var dp = Array.ofDim[Int](stones.length, half + 1)
+
+    // 初始化
+    for (j <- stones(0) to half) dp(0)(j) = stones(0)
+
+    // 遍历
+    for (i <- 1 until stones.length; j <- 1 to half) {
+      if (j - stones(i) >= 0) dp(i)(j) = stones(i) + dp(i - 1)(j - stones(i))
+      dp(i)(j) = math.max(dp(i)(j), dp(i - 1)(j))
+    }
+    
+    sum - 2 * dp(stones.length - 1)(half)
+  }
+}
+```