2つの整数nおよびkを指定すると、kの数値のすべての可能な組み合わせを1 ... nに返します。
1.対象要件
输入: n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]
2、アルゴリズムの例
迅速
- 結果セットはすべて小さいものから小さいものへと並べ替えられるため、繰り返しを考慮する必要がないため、プロセスははるかに単純になります。
- 配列tを使用して、現在アクセスされているデータを記録します。配列内の要素の数がkに等しい場合は、回答のセットが見つかり、resに格納されていることを意味します。
- 各パスでデータを記録するとき、開始要素はt配列の最後の+1であり、残りの未通過データのデータが十分であるかどうかが判断されます。
- 十分でない場合は、トラバースを継続して直接戻る必要はありません。
var res = [[Int]]()
func bt(_ n:Int, _ count:Int, _ t:[Int]){
let tLen = t.count
if tLen == count {
res.append(t);
return;
}
let minT = t.count > 0 ? t.last!+1 : 1
if minT > n || n-minT+1 < count-tLen {
return;
}
var tmp = t
for i in minT ... n {
tmp.append(i)
bt(n,count,tmp)
tmp.removeLast()
}
}
func combine(_ n: Int, _ k: Int) -> [[Int]] {
let tmp = [Int]()
bt(n, k, tmp)
return res
}
ジャワ
- Javaの実装：これはツリーの問題を深さ優先で走査するため、最初にツリー構造を描画します。たとえば、入力：n = 4、k = 2、次の再帰構造を見つけることができます。
- 組み合わせに1がある場合は、[2、3、4]で別の数値を見つける必要があります。
- 組み合わせに2がある場合は、[3、4]で別の数値を見つける必要があります。
- 注：1を含む組み合わせは最初のケースにすでに含まれているため、1はここでは考慮できません。
- 類推（後の部分は省略されます）により、上記の説明で具体化された再帰的な構造は次のとおりです。nで終わる候補配列で、いくつかの要素を選択します。以下に示すように再帰構造を描画します。
- 説明：
- リーフノードの情報は、ルートノードからリーフノードへのパスに組み込まれているため、パスを表す変数パスが必要です。これはリストであり、特にパスはスタックです。
- 各ノードは同じことを再帰的に実行しており、違いは検索の開始点にあるため、間隔[begin、n]で選択されたいくつかの数値の組み合わせを表すには変数startが必要です。
- Javaアルゴリズム1：
public List<List<Integer>> combine(int n, int k) {
List<List<Integer>> res = new ArrayList<>();
if (k <= 0 || n < k) {
return res;
}
// 从 1 开始是题目的设定
Deque<Integer> path = new ArrayDeque<>();
dfs(n, k, 1, path, res);
return res;
}
private void dfs(int n, int k, int begin, Deque<Integer> path, List<List<Integer>> res) {
// 递归终止条件是：path 的长度等于 k
if (path.size() == k) {
res.add(new ArrayList<>(path));
return;
}
// 遍历可能的搜索起点
for (int i = begin; i <= n; i++) {
// 向路径变量里添加一个数
path.addLast(i);
// 下一轮搜索，设置的搜索起点要加 1，因为组合数理不允许出现重复的元素
dfs(n, k, i + 1, path, res);
// 重点理解这里：深度优先遍历有回头的过程，因此递归之前做了什么，递归之后需要做相同操作的逆向操作
path.removeLast();
}
}
- Javaアルゴリズム2：
public List<List<Integer>> combine(int n, int k) {
List<List<Integer>> res = new ArrayList<>();
if (k <= 0 || n < k) {
return res;
}
Deque<Integer> path = new ArrayDeque<>();
dfs(n, k, 1, path, res);
return res;
}
private void dfs(int n, int k, int begin, Deque<Integer> path, List<List<Integer>> res) {
if (path.size() == k) {
res.add(new ArrayList<>(path));
return;
}
for (int i = begin; i <= n; i++) {
path.addLast(i);
System.out.println("递归之前 => " + path);
dfs(n, k, i + 1, path, res);
path.removeLast();
System.out.println("递归之后 => " + path);
}
}
public static void main(String[] args) {
Solution solution = new Solution();
int n = 5;
int k = 3;
List<List<Integer>> res = solution.combine(n, k);
System.out.println(res);
}
- 最適化：プルーニングの検索開始点の上限を分析します
- 上記のコードでは、検索の開始点はnに移動します。つまり、次の再帰関数のコードフラグメントです。
// 从当前搜索起点 begin 遍历到 n
for (int i = begin; i <= n; i++) {
path.addLast(i);
dfs(n, k, i + 1, path, res);
path.removeLast();
}
- 実際、n = 7、k = 4の場合、5から検索しても意味がありません。これは、5を選択しても、次の数は6と7に過ぎず、合計3つの候補があり、構成できないためです。 4つの数字の組み合わせ。したがって、検索の開始点には上限があります。この上限とは何ですか？分析の例をいくつか挙げてください。
- 検索開始点の上限を分析すると、実際には深さ優先のトラバーサルプロセス中にプルーニングが行われます。プルーニングにより、不要なトラバーサルを回避できます。プルーニングとプルーニングをうまく行うと、アルゴリズムの実行時間を大幅に節約できます。
- 下の図の緑色の部分は、切り取られた枝と葉です。nが非常に大きい場合、多くのノードをたどることが少なくなり、時間を節約できます。
-
簡単に知ることができます。検索の開始点は、現在選択する必要がある数字の数に関連し、現在選択する必要がある数字の数は、選択した数字の数に関連しています。つまり、パスの長さに関連しています。いくつかの例を分析してください：
-
たとえば、n = 6およびk = 4です。
- path.size（）== 1の場合、次に3つの数値を選択し、最大検索開始点は4、最後に選択した組み合わせは[4、5、6]です。
- path.size（）== 2の場合、次に2つの数値を選択します。最大検索開始点は5で、最後に選択した組み合わせは[5、6]です。
- path.size（）== 3の場合、次に1つの数値を選択し、最大検索開始点は6、最後に選択した組み合わせは[6]です。
-
別の例：n = 15、k = 4：
- path.size（）== 1の場合、次に3つの数値を選択します。最大検索開始点は13で、最後に選択されたものは[13、14、15]です。
- path.size（）== 2の場合、次に2つの数値を選択します。最大検索開始点は14で、最後に選択されたのは[14、15]です。
- path.size（）== 3の場合、次に1つの数値を選択します。最大検索開始点は15で、最後に選択されたものは[15]です。
-
結論：検索開始点の上限+選択される要素の数next-1 = n。
-
次に選択される要素の数= k-path.size（）、並べ替え：
搜索起点的上界 = n - (k - path.size()) + 1
- したがって、プルーニングプロセスは次のとおりです。i<= nをi <= n-（k-path.size（））+ 1に変更します。
public List<List<Integer>> combine(int n, int k) {
List<List<Integer>> res = new ArrayList<>();
if (k <= 0 || n < k) {
return res;
}
Deque<Integer> path = new ArrayDeque<>();
dfs(n, k, 1, path, res);
return res;
}
private void dfs(int n, int k, int index, Deque<Integer> path, List<List<Integer>> res) {
if (path.size() == k) {
res.add(new ArrayList<>(path));
return;
}
// 只有这里 i <= n - (k - path.size()) + 1 与参考代码 1 不同
for (int i = index; i <= n - (k - path.size()) + 1; i++) {
path.addLast(i);
dfs(n, k, i + 1, path, res);
path.removeLast();
}
}