LeetCode题练习与总结：排列序列--60

最新推荐文章于 2024-11-10 21:43:58 发布

一直学习永不止步

最新推荐文章于 2024-11-10 21:43:58 发布

阅读量796

点赞数 31

分类专栏： LeetCode Java 困难文章标签：算法数据结构 LeetCode Java 递归数学

本文链接：https://blog.csdn.net/weixin_62860386/article/details/137061411

版权

LeetCode 同时被 3 个专栏收录

321 篇文章 0 订阅

订阅专栏

Java

306 篇文章 0 订阅

订阅专栏

困难

58 篇文章 0 订阅

订阅专栏

本文介绍了一种用Java实现的算法，用于生成给定整数n和k的排列问题，通过ArrayList存储数字，计算(n-1)!并迭代找到第k个排列。文章详细分析了时间复杂度和空间复杂度，涉及数据结构、循环、算术运算和字符串操作等知识点。

摘要由CSDN通过智能技术生成

一、题目描述

给出集合 [1,2,3,...,n]，其所有元素共有 n! 种排列。

按大小顺序列出所有排列情况，并一一标记，当 n = 3 时, 所有排列如下：

"123"
"132"
"213"
"231"
"312"
"321"

给定 n 和 k，返回第 k 个排列。

示例 1：

输入：n = 3, k = 3
输出："213"

示例 2：

输入：n = 4, k = 9
输出："2314"

示例 3：

输入：n = 3, k = 1
输出："123"

提示：

1 <= n <= 9
1 <= k <= n!

二、解题思路

创建一个列表 nums，其中包含从 1 到 n 的所有数字。
计算 (n-1)! 的值，因为这是每个数字开头的排列数量。
从 k-1（因为我们的列表是从 0 开始的）中减去 (n-1)! 的整数倍，得到剩余的值 offset。
offset / (n-2)! 将给出当前位的数字在 nums 中的索引。
使用该索引从 nums 中获取数字，并将其添加到结果字符串中。
从 nums 中移除该数字。
重复步骤 2-6，直到找到第 k 个排列。

三、具体代码

import java.util.ArrayList;
import java.util.List;

public class Solution {
    public String getPermutation(int n, int k) {
        // Step 1: 创建一个列表 nums，其中包含从 1 到 n 的所有数字
        List<Integer> nums = new ArrayList<>();
        for (int i = 1; i <= n; i++) {
            nums.add(i);
        }

        // 计算 (n-1)!
        int fact = 1;
        for (int i = 1; i <= n - 1; i++) {
            fact *= i;
        }

        // 从 k-1 中减去 (n-1)! 的整数倍
        k--;

        StringBuilder result = new StringBuilder();

        // 重复步骤 2-6，直到找到第 k 个排列
        for (int i = n; i >= 1; i--) {
            // 计算 offset
            int index = k / fact;
            k %= fact;

            // Step 4: 使用该索引从 nums 中获取数字，并将其添加到结果字符串中
            result.append(nums.get(index));

            // Step 6: 从 nums 中移除该数字
            nums.remove(index);

            // 更新 (n-1)!
            if (i > 1) {
                fact /= (i - 1);
            }
        }

        return result.toString();
    }
}

四、时间复杂度和空间复杂度

1. 时间复杂度

初始化列表 nums 的时间复杂度是 O(n)，因为需要遍历从 1 到 n 的所有数字。
计算 (n-1)! 的时间复杂度是 O(n)，因为需要循环 n-1 次。
主循环中，每次迭代都会从列表 nums 中移除一个元素，并且更新 (n-1)! 的值。这个循环会执行 n 次，每次操作的时间复杂度是 O(1)，因为列表 nums 的长度在不断减少，而且更新 (n-1)! 的值是常数时间操作。
因此，总的时间复杂度是 O(n) + O(n) + O(n) * O(1) = O(n)。