力扣第 77 题 组合

题目描述

给定两个整数 nk,返回范围 [1, n] 中所有可能的 k 个数的组合。

  • 你可以按任意顺序返回答案。

示例

示例 1

输入

plaintext 复制代码
n = 4, k = 2

输出

plaintext 复制代码
[[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]
示例 2

输入

plaintext 复制代码
n = 1, k = 1

输出

plaintext 复制代码
[[1]]

解题思路

1. 回溯法

回溯法是解决组合问题的经典方法,通过递归构建所有可能的组合。

算法步骤

  1. 定义一个函数 backtrack(start, path),其中 start 表示搜索的起点,path 是当前构建的组合。
  2. 如果当前组合 path 的长度等于 k,将其加入结果集中。
  3. 遍历从 startn 的所有数字:
    • 将当前数字加入组合。
    • 递归构建下一个数字的组合。
    • 回溯,移除当前数字。

回溯法的时间复杂度是 O(C(n, k)) ,其中 C ( n , k ) = n ! k ! ( n − k ) ! C(n, k) = \frac{n!}{k!(n-k)!} C(n,k)=k!(n−k)!n!。


实现代码

C语言实现
c 复制代码
#include <stdio.h>
#include <stdlib.h>

// 动态数组结构
typedef struct {
    int** data;
    int size;
    int capacity;
} Array;

void initArray(Array* arr, int capacity) {
    arr->data = (int**)malloc(sizeof(int*) * capacity);
    arr->size = 0;
    arr->capacity = capacity;
}

void addToArray(Array* arr, int* combination, int k) {
    if (arr->size == arr->capacity) {
        arr->capacity *= 2;
        arr->data = (int**)realloc(arr->data, sizeof(int*) * arr->capacity);
    }
    arr->data[arr->size] = (int*)malloc(sizeof(int) * k);
    for (int i = 0; i < k; i++) {
        arr->data[arr->size][i] = combination[i];
    }
    arr->size++;
}

void backtrack(int n, int k, int start, int* combination, int combSize, Array* result) {
    if (combSize == k) {
        addToArray(result, combination, k);
        return;
    }
    for (int i = start; i <= n; i++) {
        combination[combSize] = i;
        backtrack(n, k, i + 1, combination, combSize + 1, result);
    }
}

int** combine(int n, int k, int* returnSize, int** returnColumnSizes) {
    Array result;
    initArray(&result, 16);
    int* combination = (int*)malloc(sizeof(int) * k);
    backtrack(n, k, 1, combination, 0, &result);

    *returnSize = result.size;
    *returnColumnSizes = (int*)malloc(sizeof(int) * result.size);
    for (int i = 0; i < result.size; i++) {
        (*returnColumnSizes)[i] = k;
    }

    free(combination);
    return result.data;
}

int main() {
    int n = 4, k = 2;
    int returnSize;
    int* returnColumnSizes;

    int** combinations = combine(n, k, &returnSize, &returnColumnSizes);

    printf("Combinations:\n");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", combinations[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(", ");
        }
        printf("]\n");
        free(combinations[i]); // 释放每个组合的内存
    }

    free(combinations); // 释放结果数组的内存
    free(returnColumnSizes); // 释放列大小数组的内存

    return 0;
}

代码解析

  1. 动态数组

    • 使用 Array 结构来动态存储组合结果。
    • initArray 初始化数组,addToArray 动态增加组合。
  2. 回溯函数

    • backtrack 函数递归构建所有可能的组合。
    • 使用 start 控制数字范围,避免重复组合。
  3. 主函数

    • combine 是主函数,调用回溯并返回结果。
    • 动态分配 returnColumnSizes 以存储每个组合的列数。
  4. 内存管理

    • 在主函数中释放动态分配的内存,避免内存泄漏。

时间复杂度和空间复杂度

  • 时间复杂度

    • 回溯构造所有组合的复杂度是 O(C(n, k)) ,即 n ! k ! ( n − k ) ! \frac{n!}{k!(n-k)!} k!(n−k)!n!。
  • 空间复杂度

    • 临时数组 combination 的空间复杂度为 O(k)
    • 存储结果的空间复杂度为 O ( C ( n , k ) ⋅ k ) O(C(n, k) \cdot k) O(C(n,k)⋅k)
相关推荐
YuTaoShao2 分钟前
【LeetCode 热题 100】73. 矩阵置零——(解法一)空间复杂度 O(M + N)
算法·leetcode·矩阵
dying_man1 小时前
LeetCode--42.接雨水
算法·leetcode
vortex51 小时前
算法设计与分析 知识总结
算法
艾莉丝努力练剑2 小时前
【C语言】学习过程教训与经验杂谈:思想准备、知识回顾(三)
c语言·开发语言·数据结构·学习·算法
ZZZS05162 小时前
stack栈练习
c++·笔记·学习·算法·动态规划
黑听人2 小时前
【力扣 困难 C】115. 不同的子序列
c语言·leetcode
hans汉斯2 小时前
【人工智能与机器人研究】基于力传感器坐标系预标定的重力补偿算法
人工智能·算法·机器人·信号处理·深度神经网络
vortex54 小时前
算法设计与分析:分治、动态规划与贪心算法的异同与选择
算法·贪心算法·动态规划
前端拿破轮4 小时前
🤡🤡🤡面试官:就你这还每天刷leetcode?连四数相加和四数之和都分不清!
算法·leetcode·面试
地平线开发者5 小时前
征程 6|工具链量化简介与代码实操
算法·自动驾驶