序列的最大混乱

给定任何序列$S = \{a_1, a_2 \dots a_n \}$ , 找到最大的混乱$S$ .
精神错乱$D$是任何排列$S$ ，使得没有两个元素在同一位置$S$和$D$是平等的。
最大的混乱是这样的$D_i > D_{i+1}, \forall i$ .

例子：

Input : seq[] = {5, 4, 3, 2, 1}
Output : 4 5 2 1 3

Input : seq[] = {56, 21, 42, 67, 23, 74}
Output : 74, 67, 56, 42, 21, 23

由于我们对产生最大的混乱感兴趣，我们开始将更大的元素放在更重要的位置。
从左边开始，在任何位置$i$将下一个最大的元素放在序列的值中，这些值尚未放置在之前的位置$i$ .
扫描所有位置需要 N 次迭代。在每次迭代中，我们都需要找到一个最大数字，因此一个简单的实现将是$O(N^2)$复杂，
然而，如果我们使用像 max-heap 这样的数据结构来寻找最大元素，那么复杂度就会降低到$O(N * log{N})$

下面是实现。

C++

// C++ program to find the largest derangement
#include 
using namespace std;
 
void printLargest(int seq[], int N)
{
    int res[N]; // Stores result
 
    // Insert all elements into a priority queue
    std::priority_queue pq;
    for (int i = 0; i < N; i++)
        pq.push(seq[i]);   
 
    // Fill Up res[] from left to right
    for (int i = 0; i < N; i++) {
        int d = pq.top();
        pq.pop();
        if (d != seq[i] || i == N - 1) {
            res[i] = d;
        } else {
 
            // New Element poped equals the element
            // in original sequence. Get the next
            // largest element
            res[i] = pq.top();
            pq.pop();
            pq.push(d);
        }
    }
 
    // If given sequence is in descending order then
    // we need to swap last two elements again
    if (res[N - 1] == seq[N - 1]) {
        res[N - 1] = res[N - 2];
        res[N - 2] = seq[N - 1];
    }
 
    printf("\nLargest Derangement \n");
    for (int i = 0; i < N; i++)
        printf("%d ", res[i]);
}
 
// Driver code
int main()
{
    int seq[] = { 92, 3, 52, 13, 2, 31, 1 };
    int n = sizeof(seq)/sizeof(seq[0]);
    printLargest(seq, n);
    return 0;
}

Java

// Java program to find the largest derangement
import java.io.*;
import java.util.Collections;
import java.util.PriorityQueue;
 
class GFG{
     
public static void printLargest(int a[],int n)
{
     PriorityQueue pq = new PriorityQueue<>(
         Collections.reverseOrder());
       
      // Insert all elements into a priority queue
      for(int i = 0; i < n; i++)
    {
        pq.add(a[i]);
    }
     
    // Stores result
      int res[] = new int[n];
       
      // Fill Up res[] from left to right
    for(int i = 0; i < n; i++)
    {
        int p = pq.peek();
        pq.remove();
         
        if (p != a[i] || i == n - 1)
        {
            res[i] = p;
        }
        else
        {
             
            // New Element poped equals the element
            // in original sequence. Get the next
            // largest element
            res[i] = pq.peek();
            pq.remove();
            pq.add(p);
        }
    }
     
      // If given sequence is in descending
      // order then we need to swap last two
      // elements again
      if (res[n - 1] == a[n - 1])
    {
        res[n - 1] = res[n - 2];
        res[n - 2] = a[n - 1];
    }
   
      System.out.println("Largest Derangement");
    for(int i = 0; i < n; i++)
    {
        System.out.print(res[i] + " ");
    }
}
 
// Driver code
public static void main(String[] args)
{
      int n = 7;
    int seq[] = { 92, 3, 52, 13, 2, 31, 1 };
     
      printLargest(seq, n);
}
}
 
// This code is contributed by aditya7409

Python3

# Python3 program to find the largest derangement
def printLargest(seq, N) :
 
    res = [0]*N # Stores result
   
    # Insert all elements into a priority queue
    pq = []
    for i in range(N) :
        pq.append(seq[i])  
   
    # Fill Up res[] from left to right
    for i in range(N) :   
        pq.sort()
        pq.reverse()
        d = pq[0]
        del pq[0]
        if (d != seq[i] or i == N - 1) :
            res[i] = d       
        else :       
   
            # New Element poped equals the element
            # in original sequence. Get the next
            # largest element
            res[i] = pq[0]
            del pq[0]
            pq.append(d)
   
    # If given sequence is in descending order then
    # we need to swap last two elements again
    if (res[N - 1] == seq[N - 1]) :   
        res[N - 1] = res[N - 2]
        res[N - 2] = seq[N - 1]
          
    print("Largest Derangement")
    for i in range(N) :
        print(res[i], end = " ")
 
# Driver code
seq = [ 92, 3, 52, 13, 2, 31, 1 ]
n = len(seq)
printLargest(seq, n)
 
# This code is contributed by divyesh072019.

C#

// C# program to find the largest derangement
using System;
using System.Collections.Generic;
class GFG
{
     
    static void printLargest(int[] seq, int N)
    {
        int[] res = new int[N]; // Stores result
      
        // Insert all elements into a priority queue
        List pq = new List();
        for (int i = 0; i < N; i++)
            pq.Add(seq[i]);   
      
        // Fill Up res[] from left to right
        for (int i = 0; i < N; i++)
        {
            pq.Sort();
            pq.Reverse();
            int d = pq[0];
            pq.RemoveAt(0);
            if (d != seq[i] || i == N - 1)
            {
                res[i] = d;
            }
          else
            {
      
                // New Element poped equals the element
                // in original sequence. Get the next
                // largest element
                res[i] = pq[0];
                pq.RemoveAt(0);
                pq.Add(d);
            }
        }
      
        // If given sequence is in descending order then
        // we need to swap last two elements again
        if (res[N - 1] == seq[N - 1])
        {
            res[N - 1] = res[N - 2];
            res[N - 2] = seq[N - 1];
        }    
        Console.WriteLine("Largest Derangement");
        for (int i = 0; i < N; i++)
            Console.Write(res[i] + " ");
    }
 
  // Driver code
  static void Main()
  {
    int[] seq = { 92, 3, 52, 13, 2, 31, 1 };
    int n = seq.Length;
    printLargest(seq, n);
  }
}
 
// This code is contributed by divyeshrabadiya07

Javascript

 
// JavaScript program to find the largest derangement
 
 
function printLargest(seq, N) {
    let res = new Array(N); // Stores result
 
    // Insert all elements into a priority queue
    let pq = new Array();
    for (let i = 0; i < N; i++)
        pq.push(seq[i]);
 
    // Fill Up res[] from left to right
    for (let i = 0; i < N; i++) {
        pq.sort((a, b) => a - b);
        pq.reverse();
        let d = pq[0];
        pq.shift();
        if (d != seq[i] || i == N - 1) {
            res[i] = d;
        }
        else {
 
            // New Element poped equals the element
            // in original sequence. Get the next
            // largest element
            res[i] = pq[0];
            pq.shift();
            pq.push(d);
        }
    }
 
    // If given sequence is in descending order then
    // we need to swap last two elements again
    if (res[N - 1] == seq[N - 1]) {
        res[N - 1] = res[N - 2];
        res[N - 2] = seq[N - 1];
    }
    document.write("Largest Derangement<br>");
    for (let i = 0; i < N; i++)
        document.write(res[i] + " ");
}
 
// Driver code
let seq = [92, 3, 52, 13, 2, 31, 1];
let n = seq.length;
printLargest(seq, n);
 
// This code is contributed by gfgking
 

输出：

Largest Derangement
52 92 31 3 13 1 2

时间复杂度： O(n log n)

笔记：
该方法可以很容易地修改以获得最小的混乱。
我们应该使用Min Heap来连续获取最小元素，而不是Max Heap

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。