diff --git a/problems/0222.完全二叉树的节点个数.md b/problems/0222.完全二叉树的节点个数.md
index ba7acc5a..746d45cc 100644
--- a/problems/0222.完全二叉树的节点个数.md
+++ b/problems/0222.完全二叉树的节点个数.md
@@ -646,5 +646,68 @@ func countNodes(_ root: TreeNode?) -> Int {
}
```
+## Scala
+
+递归:
+```scala
+object Solution {
+ def countNodes(root: TreeNode): Int = {
+ if(root == null) return 0
+ 1 + countNodes(root.left) + countNodes(root.right)
+ }
+}
+```
+
+层序遍历:
+```scala
+object Solution {
+ import scala.collection.mutable
+ def countNodes(root: TreeNode): Int = {
+ if (root == null) return 0
+ val queue = mutable.Queue[TreeNode]()
+ var node = 0
+ queue.enqueue(root)
+ while (!queue.isEmpty) {
+ val len = queue.size
+ for (i <- 0 until len) {
+ node += 1
+ val curNode = queue.dequeue()
+ if (curNode.left != null) queue.enqueue(curNode.left)
+ if (curNode.right != null) queue.enqueue(curNode.right)
+ }
+ }
+ node
+ }
+}
+```
+
+利用完全二叉树性质:
+```scala
+object Solution {
+ def countNodes(root: TreeNode): Int = {
+ if (root == null) return 0
+ var leftNode = root.left
+ var rightNode = root.right
+ // 向左向右往下探
+ var leftDepth = 0
+ while (leftNode != null) {
+ leftDepth += 1
+ leftNode = leftNode.left
+ }
+ var rightDepth = 0
+ while (rightNode != null) {
+ rightDepth += 1
+ rightNode = rightNode.right
+ }
+ // 如果相等就是一个满二叉树
+ if (leftDepth == rightDepth) {
+ return (2 << leftDepth) - 1
+ }
+ // 如果不相等就不是一个完全二叉树，继续向下递归
+ countNodes(root.left) + countNodes(root.right) + 1
+ }
+}
+```
+
-----------------------
diff --git a/problems/0257.二叉树的所有路径.md b/problems/0257.二叉树的所有路径.md
index 1362897c..70a3c66f 100644
--- a/problems/0257.二叉树的所有路径.md
+++ b/problems/0257.二叉树的所有路径.md
@@ -702,5 +702,35 @@ func binaryTreePaths(_ root: TreeNode?) -> [String] {
}
```
+Scala:
+
+递归:
+```scala
+object Solution {
+ import scala.collection.mutable.ListBuffer
+ def binaryTreePaths(root: TreeNode): List[String] = {
+ val res = ListBuffer[String]()
+ def traversal(curNode: TreeNode, path: ListBuffer[Int]): Unit = {
+ path.append(curNode.value)
+ if (curNode.left == null && curNode.right == null) {
+ res.append(path.mkString("->")) // mkString函数: 将数组的所有值按照指定字符串拼接
+ return // 处理完可以直接return
+ }
+
+ if (curNode.left != null) {
+ traversal(curNode.left, path)
+ path.remove(path.size - 1)
+ }
+ if (curNode.right != null) {
+ traversal(curNode.right, path)
+ path.remove(path.size - 1)
+ }
+ }
+ traversal(root, ListBuffer[Int]())
+ res.toList
+ }
+}
+```
+
-----------------------
diff --git a/problems/0416.分割等和子集.md b/problems/0416.分割等和子集.md
index eb6601e1..7347cd6f 100644
--- a/problems/0416.分割等和子集.md
+++ b/problems/0416.分割等和子集.md
@@ -417,6 +417,26 @@ 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:
二维dp：
```c
@@ -575,6 +595,5 @@ function canPartition(nums: number[]): boolean {
-
-----------------------
diff --git a/problems/0494.目标和.md b/problems/0494.目标和.md
index 8ce1f6f1..0cdae393 100644
--- a/problems/0494.目标和.md
+++ b/problems/0494.目标和.md
@@ -351,22 +351,26 @@ const findTargetSumWays = (nums, target) => {
};
```
-TypeScript：
-```typescript
+TypeScript:
+
+```ts
function findTargetSumWays(nums: number[], target: number): number {
- const sum: number = nums.reduce((pre, cur) => pre + cur);
- if (Math.abs(target) > sum) return 0;
- if ((target + sum) % 2 === 1) return 0;
- const bagSize: number = (target + sum) / 2;
- const dp: number[] = new Array(bagSize + 1).fill(0);
- dp[0] = 1;
- for (let i = 0; i < nums.length; i++) {
- for (let j = bagSize; j >= nums[i]; j--) {
+ // 把数组分成两个组合left, right.left + right = sum, left - right = target.
+ const sum: number = nums.reduce((a: number, b: number): number => a + b);
+ if ((sum + target) % 2 || Math.abs(target) > sum) return 0;
+ const left: number = (sum + target) / 2;
+
+ // 将问题转化为装满容量为left的背包有多少种方法
+ // dp[i]表示装满容量为i的背包有多少种方法
+ const dp: number[] = new Array(left + 1).fill(0);
+ dp[0] = 1; // 装满容量为0的背包有1种方法（什么也不装）
+ for (let i: number = 0; i < nums.length; i++) {
+ for (let j: number = left; j >= nums[i]; j--) {
dp[j] += dp[j - nums[i]];
}
}
- return dp[bagSize];
+ return dp[left];
};
```
diff --git a/problems/1049.最后一块石头的重量II.md b/problems/1049.最后一块石头的重量II.md
index 3d256c3d..f3e7909c 100644
--- a/problems/1049.最后一块石头的重量II.md
+++ b/problems/1049.最后一块石头的重量II.md
@@ -277,26 +277,29 @@ var lastStoneWeightII = function (stones) {
};
```
-TypeScript：
-```typescript
+TypeScript版本
+
+```ts
function lastStoneWeightII(stones: number[]): number {
- const sum: number = stones.reduce((pre, cur) => pre + cur);
- const bagSize: number = Math.floor(sum / 2);
- const weightArr: number[] = stones;
- const valueArr: number[] = stones;
- const goodsNum: number = weightArr.length;
- const dp: number[] = new Array(bagSize + 1).fill(0);
- for (let i = 0; i < goodsNum; i++) {
- for (let j = bagSize; j >= weightArr[i]; j--) {
- dp[j] = Math.max(dp[j], dp[j - weightArr[i]] + valueArr[i]);
+ const sum: number = stones.reduce((a: number, b:number): number => a + b);
+ const target: number = Math.floor(sum / 2);
+ const n: number = stones.length;
+ // dp[j]表示容量（总数和）为j的背包所能装下的数（下标[0, i]之间任意取）的总和（<= 容量）的最大值
+ const dp: number[] = new Array(target + 1).fill(0);
+ for (let i: number = 0; i < n; i++ ) {
+ for (let j: number = target; j >= stones[i]; j--) {
+ dp[j] = Math.max(dp[j], dp[j - stones[i]] + stones[i]);
}
}
- return sum - dp[bagSize] * 2;
+ return sum - dp[target] - dp[target];
};
```
+
+
+
-----------------------
diff --git a/problems/1365.有多少小于当前数字的数字.md b/problems/1365.有多少小于当前数字的数字.md
index 78fa84c0..ce1e77df 100644
--- a/problems/1365.有多少小于当前数字的数字.md
+++ b/problems/1365.有多少小于当前数字的数字.md
@@ -217,6 +217,46 @@ var smallerNumbersThanCurrent = function(nums) {
};
```
+TypeScript:
+
+> 暴力法：
+
+```typescript
+function smallerNumbersThanCurrent(nums: number[]): number[] {
+ const length: number = nums.length;
+ const resArr: number[] = [];
+ for (let i = 0; i < length; i++) {
+ let count: number = 0;
+ for (let j = 0; j < length; j++) {
+ if (nums[j] < nums[i]) {
+ count++;
+ }
+ }
+ resArr[i] = count;
+ }
+ return resArr;
+};
+```
+
+> 排序+hash
+
+```typescript
+function smallerNumbersThanCurrent(nums: number[]): number[] {
+ const length: number = nums.length;
+ const sortedArr: number[] = [...nums];
+ sortedArr.sort((a, b) => a - b);
+ const hashMap: Map = new Map();
+ for (let i = length - 1; i >= 0; i--) {
+ hashMap.set(sortedArr[i], i);
+ }
+ const resArr: number[] = [];
+ for (let i = 0; i < length; i++) {
+ resArr[i] = hashMap.get(nums[i]);
+ }
+ return resArr;
+};
+```
+
-----------------------
