Merge pull request #1443 from wzqwtt/backtracking05

添加(0078.子集、0090.子集II、0491.递增子序列) Scala版本
This commit is contained in:
程序员Carl
2022-07-12 08:26:26 +08:00
committed by GitHub
3 changed files with 145 additions and 0 deletions

View File

@ -373,6 +373,60 @@ func subsets(_ nums: [Int]) -> [[Int]] {
}
```
## Scala
思路一: 使用本题解思路
```scala
object Solution {
import scala.collection.mutable
def subsets(nums: Array[Int]): List[List[Int]] = {
var result = mutable.ListBuffer[List[Int]]()
var path = mutable.ListBuffer[Int]()
def backtracking(startIndex: Int): Unit = {
result.append(path.toList) // 存放结果
if (startIndex >= nums.size) {
return
}
for (i <- startIndex until nums.size) {
path.append(nums(i)) // 添加元素
backtracking(i + 1)
path.remove(path.size - 1) // 删除
}
}
backtracking(0)
result.toList
}
}
```
思路二: 将原问题转换为二叉树,针对每一个元素都有**选或不选**两种选择,直到遍历到最后,所有的叶子节点即为本题的答案:
```scala
object Solution {
import scala.collection.mutable
def subsets(nums: Array[Int]): List[List[Int]] = {
var result = mutable.ListBuffer[List[Int]]()
def backtracking(path: mutable.ListBuffer[Int], startIndex: Int): Unit = {
if (startIndex == nums.length) {
result.append(path.toList)
return
}
path.append(nums(startIndex))
backtracking(path, startIndex + 1) // 选择元素
path.remove(path.size - 1)
backtracking(path, startIndex + 1) // 不选择元素
}
backtracking(mutable.ListBuffer[Int](), 0)
result.toList
}
}
```
-----------------------
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

View File

@ -434,6 +434,63 @@ func subsetsWithDup(_ nums: [Int]) -> [[Int]] {
}
```
### Scala
不使用userd数组:
```scala
object Solution {
import scala.collection.mutable
def subsetsWithDup(nums: Array[Int]): List[List[Int]] = {
var result = mutable.ListBuffer[List[Int]]()
var path = mutable.ListBuffer[Int]()
var num = nums.sorted // 排序
def backtracking(startIndex: Int): Unit = {
result.append(path.toList)
if (startIndex >= num.size){
return
}
for (i <- startIndex until num.size) {
// 同一树层重复的元素不进入回溯
if (!(i > startIndex && num(i) == num(i - 1))) {
path.append(num(i))
backtracking(i + 1)
path.remove(path.size - 1)
}
}
}
backtracking(0)
result.toList
}
}
```
使用Set去重:
```scala
object Solution {
import scala.collection.mutable
def subsetsWithDup(nums: Array[Int]): List[List[Int]] = {
var result = mutable.Set[List[Int]]()
var num = nums.sorted
def backtracking(path: mutable.ListBuffer[Int], startIndex: Int): Unit = {
if (startIndex == num.length) {
result.add(path.toList)
return
}
path.append(num(startIndex))
backtracking(path, startIndex + 1) // 选择
path.remove(path.size - 1)
backtracking(path, startIndex + 1) // 不选择
}
backtracking(mutable.ListBuffer[Int](), 0)
result.toList
}
}
```
-----------------------
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

View File

@ -522,5 +522,39 @@ func findSubsequences(_ nums: [Int]) -> [[Int]] {
```
## Scala
```scala
object Solution {
import scala.collection.mutable
def findSubsequences(nums: Array[Int]): List[List[Int]] = {
var result = mutable.ListBuffer[List[Int]]()
var path = mutable.ListBuffer[Int]()
def backtracking(startIndex: Int): Unit = {
// 集合元素大于1添加到结果集
if (path.size > 1) {
result.append(path.toList)
}
var used = new Array[Boolean](201)
// 使用循环守卫,当前层没有用过的元素才有资格进入回溯
for (i <- startIndex until nums.size if !used(nums(i) + 100)) {
// 如果path没元素或 当前循环的元素比path的最后一个元素大则可以进入回溯
if (path.size == 0 || (!path.isEmpty && nums(i) >= path(path.size - 1))) {
used(nums(i) + 100) = true
path.append(nums(i))
backtracking(i + 1)
path.remove(path.size - 1)
}
}
}
backtracking(0)
result.toList
}
}
```
-----------------------
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>