Hướng dẫn next permutation interviewbit solution python - hoán vị tiếp theo giải pháp phỏng vấn bit giải pháp python

Permalink

Không thể lấy lại những người đóng góp tại thời điểm này

Tệp này chứa văn bản unicode hai chiều có thể được giải thích hoặc biên dịch khác với những gì xuất hiện dưới đây. Để xem xét, hãy mở tệp trong một trình soạn thảo cho thấy các ký tự Unicode ẩn. Tìm hiểu thêm về các ký tự unicode hai chiều

Giải pháp lớp học:
# @param A: Danh sách số nguyên
# @return cùng một danh sách số nguyên sau khi sửa đổi
DEF NEXTPERMUNT (tự, A):
i = len (a) - 2
Trong khi A [i]> = a [i+1]:
i = i - 1
Nếu tôi <0:
phá vỡ
Nếu tôi <0:
phá vỡ
A = A [::-1]
trả lại a
khác:
j = len (a) - 1
Trong khi một [J]
J -= 1
A [i], a [j] = a [j], a [i]
A = A [::-1]

  • Cách tiếp cận 1: Lực lượng vũ phu
  • Cách tiếp cận 2: Giải pháp tuyến tính
    • Mã C ++
    • Mã Java
    • Mã Python
  • Câu hỏi thường gặp

Điều gì sẽ xảy ra nếu mảng đầu vào được sắp xếp theo thứ tự giảm? Nếu mảng được sắp xếp theo thứ tự giảm, chỉ cần sắp xếp nó theo thứ tự tăng dần, vì không thể hoán vị nào lớn hơn đối với một mảng như vậy.A[] of N distinct integers. The task is to return the lexicographically greater permutation than the given arrangement. If no such arrangement is possible, return the array sorted in non-decreasing order.

Examples:

Cách tiếp cận để giải quyết vấn đề hoán vị tiếp theo là gì? Ý tưởng là tìm ra hậu tố không tăng dài nhất và trao đổi nó với phần tử trục được tìm thấy. Phần tử pivot là chỉ mục trong đó a [i] = [1, 2, 3]
Output: [1, 3, 2]
Explanation: The lexicographically greater permutation than A[] is [1, 3, 2]

Cách tiếp cận 1: Lực lượng vũ phu A[] = [4, 3, 2, 1]

Cách tiếp cận 2: Giải pháp tuyến tính [1, 2, 3, 4]

Cách tiếp cận 1: Lực lượng vũ phu

Cách tiếp cận 2: Giải pháp tuyến tính
But this approach is very naive and won’t work for N > 10.

Cho một mảng một [] của n số nguyên riêng biệt. Nhiệm vụ là trả lại hoán vị từ vựng lớn hơn so với sự sắp xếp đã cho. Nếu không có sự sắp xếp như vậy, hãy trả lại mảng được sắp xếp theo thứ tự không giảm.

Đầu vào: A [] = [1, 2, 3] Đầu ra: [1, 3, 2] Giải thích: hoán vị lớn hơn về mặt từ vựng so với [] là [1, 3, 2]



Đầu vào: & nbsp; a [] = [4, 3, 2, 1]


Đầu ra: [1, 2, 3, 4]: O(N * N!), since total possible permutations are N!
Space Complexity: O(N), since the permutation is stored.

Cách tiếp cận 2: Giải pháp tuyến tính

Cho một mảng một [] của n số nguyên riêng biệt. Nhiệm vụ là trả lại hoán vị từ vựng lớn hơn so với sự sắp xếp đã cho. Nếu không có sự sắp xếp như vậy, hãy trả lại mảng được sắp xếp theo thứ tự không giảm.

Đầu vào: A [] = [1, 2, 3] Đầu ra: [1, 3, 2] Giải thích: hoán vị lớn hơn về mặt từ vựng so với [] là [1, 3, 2]

Đầu vào: & nbsp; a [] = [4, 3, 2, 1]

Hướng dẫn next permutation interviewbit solution python - hoán vị tiếp theo giải pháp phỏng vấn bit giải pháp python

Đầu ra: [1, 2, 3, 4]

Trường hợp cơ sở sẽ là, nếu mảng theo thứ tự giảm, sẽ không tìm thấy hoán vị tiếp theo, do đó trả lại mảng theo thứ tự được sắp xếp.

Thực hiện phương pháp:
So, if we traverse from the end of the array, there will be an index where the current element is smaller than the previous element. This ensures that all the elements to its right are larger than the current element.
Now, to get the next greater arrangement, the most optimal approach would be to find the element which is just greater than the current found element.

Hướng dẫn next permutation interviewbit solution python - hoán vị tiếp theo giải pháp phỏng vấn bit giải pháp python

Vì vậy, bây giờ sau khi hoán đổi, chúng tôi đã tìm thấy yếu tố trục. Nhưng chúng tôi vẫn chưa có hoán vị cần thiết. Do đó, chỉ cần sắp xếp các yếu tố từ trục cho đến cuối để có được hoán vị cần thiết.

Ví dụ sau đây sẽ làm cho cách tiếp cận rõ ràng hơn.

Hướng dẫn next permutation interviewbit solution python - hoán vị tiếp theo giải pháp phỏng vấn bit giải pháp python

Thuật toán:

Thực hiện phương pháp:

Mã C ++

void nextPermutation(vector < int > & nums) {
  int n = nums.size(), k, l;
  for (k = n - 2; k >= 0; k--) {
    if (nums[k] < nums[k + 1]) {
      break;
    }
  }
  if (k < 0) {
    reverse(nums.begin(), nums.end());
  } else {
    for (l = n - 1; l > k; l--) {
      if (nums[l] > nums[k]) {
        break;
      }
    }
    swap(nums[k], nums[l]);
    reverse(nums.begin() + k + 1, nums.end());
  }
}

Mã Java

 public void nextPermutation(int[] A) {
  if (A == null || A.length <= 1) return;
  int i = A.length - 2;
  while (i >= 0 && A[i] >= A[i + 1]) i--; 
  if (i >= 0) { 
    int j = A.length - 1; 
    while (A[j] <= A[i]) j--; 
    swap(A, i, j); 
  }
  reverse(A, i + 1, A.length - 1); 
}
 
public void swap(int[] A, int i, int j) {
  int tmp = A[i];
  A[i] = A[j];
  A[j] = tmp;
}
 
public void reverse(int[] A, int i, int j) {
  while (i < j) swap(A, i++, j--);
}

Mã Python

def nextPermutation(self, nums):
    i = j = len(nums) - 1
    while i > 0 and nums[i - 1] >= nums[i]:
        i -= 1
    if i == 0:
        nums.reverse()
        return
    k = i - 1
    while nums[j] <= nums[k]:
        j -= 1
    nums[k], nums[j] = nums[j], nums[k]
    l, r = k + 1, len(nums) - 1
    while l < r:
        nums[l], nums[r] = nums[r], nums[l]
        l += 1
        r -= 1

Độ phức tạp về thời gian: O (n), trong đó n là tổng kích thước của mảng O(N), where N is the total size of the array

Độ phức tạp không gian: O (1), vì không có thêm không gian được sử dụng. O(1), as no extra space is used.

Câu hỏi thực hành:

Hoán vị tiếp theo

Câu hỏi thường gặp