📜  打印给定数组的k个不同排序的排列

📅  最后修改于: 2021-06-25 15:36:05             🧑  作者: Mango

给定一个包含N个整数的数组arr [] ,任务是打印k个索引的不同排列,以使这些索引处的值形成一个非递减序列。如果不可能,则打印-1

例子:

方法:对给定的数组进行排序,并跟踪每个元素的原始索引。这给出了一个必需的排列。现在,如果任意两个连续元素相等,则可以交换它们以获得另一个排列。类似地,可以生成第三排列。

下面是上述方法的实现:

C++
// C++ implementation of the approach
#include 
using namespace std;
 
int next_pos = 1;
// Utility function to print the original indices
// of the elements of the array
void printIndices(int n, pair a[])
{
    for (int i = 0; i < n; i++)
        cout << a[i].second << " ";
    cout << endl;
}
 
// Function to print the required permutations
void printPermutations(int n, int a[], int k)
{
 
    // To keep track of original indices
    pair arr[n];
    for (int i = 0; i < n; i++)
    {
        arr[i].first = a[i];
        arr[i].second = i;
    }
 
    // Sort the array
    sort(arr, arr + n);
 
    // Count the number of swaps that can
    // be made
    int count = 1;
    for (int i = 1; i < n; i++)
        if (arr[i].first == arr[i - 1].first)
            count++;
 
    // Cannot generate 3 permutations
    if (count < k) {
        cout << "-1";
        return;
    }
 
    for (int i = 0; i < k - 1; i++)
    {
        // Print the first permutation
        printIndices(n, arr);
 
        // Find an index to swap and create
        // second permutation
        for (int j = next_pos; j < n; j++)
        {
            if (arr[j].first == arr[j - 1].first)
            {
                swap(arr[j], arr[j - 1]);
                next_pos = j + 1;
                break;
            }
        }
    }
 
    // Print the last permuation
    printIndices(n, arr);
}
 
// Driver code
int main()
{
    int a[] = { 1, 3, 3, 1 };
    int n = sizeof(a) / sizeof(a[0]);
 
    int k = 3;
   
    // Function call
    printPermutations(n, a, k);
 
    return 0;
}


Java
// Java implementation of the approach
import java.util.*;
 
class GFG {
    static int next_pos = 1;
    static class pair {
        int first, second;
        pair()
        {
            first = 0;
            second = 0;
        }
    }
 
    // Utility function to print the original indices
    // of the elements of the array
    static void printIndices(int n, pair a[])
    {
        for (int i = 0; i < n; i++)
            System.out.print(a[i].second + " ");
        System.out.println();
    }
    static class sort implements Comparator
    {
        // Used for sorting in ascending order
        public int compare(pair a, pair b)
        {
            return a.first < b.first ? -1 : 1;
        }
    }
 
    // Function to print the required permutations
    static void printPermutations(int n, int a[], int k)
    {
 
        // To keep track of original indices
        pair arr[] = new pair[n];
        for (int i = 0; i < n; i++)
        {
            arr[i] = new pair();
            arr[i].first = a[i];
            arr[i].second = i;
        }
 
        // Sort the array
        Arrays.sort(arr, new sort());
 
        // Count the number of swaps that can
        // be made
        int count = 1;
        for (int i = 1; i < n; i++)
            if (arr[i].first == arr[i - 1].first)
                count++;
 
        // Cannot generate 3 permutations
        if (count < k)
        {
            System.out.print("-1");
            return;
        }
 
        for (int i = 0; i < k - 1; i++)
        {
            // Print the first permutation
            printIndices(n, arr);
 
            // Find an index to swap and create
            // second permutation
            for (int j = next_pos; j < n; j++)
            {
                if (arr[j].first == arr[j - 1].first)
                {
                    pair t = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = t;
 
                    next_pos = j + 1;
                    break;
                }
            }
        }
 
        // Print the last permuation
        printIndices(n, arr);
    }
 
    // Driver code
    public static void main(String arsg[])
    {
        int a[] = { 1, 3, 3, 1 };
        int n = a.length;
 
        int k = 3;
       
        // Function call
        printPermutations(n, a, k);
    }
}
 
// This code is contributed by Arnab Kundu


Python3
# Python 3 implementation of the approach
 
# Utility function to print the original
# indices of the elements of the array
 
 
def printIndices(n, a):
    for i in range(n):
        print(a[i][1], end=" ")
    print("\n", end="")
 
# Function to print the required
# permutations
 
 
def printPermutations(n, a, k):
 
    # To keep track of original indices
    arr = [[0, 0] for i in range(n)]
    for i in range(n):
        arr[i][0] = a[i]
        arr[i][1] = i
 
    # Sort the array
    arr.sort(reverse=False)
 
    # Count the number of swaps that
    # can be made
    count = 1
    for i in range(1, n):
        if (arr[i][0] == arr[i - 1][0]):
            count += 1
 
    # Cannot generate 3 permutations
    if (count < k):
        print("-1", end="")
        return
 
    next_pos = 1
    for i in range(k - 1):
 
        # Print the first permutation
        printIndices(n, arr)
 
        # Find an index to swap and create
        # second permutation
        for j in range(next_pos, n):
            if (arr[j][0] == arr[j - 1][0]):
                temp = arr[j]
                arr[j] = arr[j - 1]
                arr[j - 1] = temp
                next_pos = j + 1
                break
 
    # Print the last permuation
    printIndices(n, arr)
 
 
# Driver code
if __name__ == '__main__':
    a = [1, 3, 3, 1]
    n = len(a)
    k = 3
     
    # Function call
    printPermutations(n, a, k)
 
# This code is contributed by
# Surendra_Gangwar


C#
// C# implementation of the approach
using System;
using System.Collections;
using System.Collections.Generic;
 
class GFG {
  static int next_pos = 1;
  public class pair {
    public int first, second;
    public pair()
    {
      first = 0;
      second = 0;
    }
  }
 
  class sortHelper : IComparer
  {
    int IComparer.Compare(object a, object b)
    {
      pair first = (pair)a;
      pair second = (pair)b;
      return first.first < second.first ? -1 : 1;
    }
  }
 
  // Utility function to print the original indices
  // of the elements of the array
  static void printIndices(int n, pair []a)
  {
    for (int i = 0; i < n; i++)
      Console.Write(a[i].second + " ");
    Console.WriteLine();
  }
 
  // Function to print the required permutations
  static void printPermutations(int n, int []a, int k)
  {
 
    // To keep track of original indices
    pair []arr = new pair[n];
    for (int i = 0; i < n; i++)
    {
      arr[i] = new pair();
      arr[i].first = a[i];
      arr[i].second = i;
    }
 
    // Sort the array
    Array.Sort(arr, new sortHelper());
 
    // Count the number of swaps that can
    // be made
    int count = 1;
    for (int i = 1; i < n; i++)
      if (arr[i].first == arr[i - 1].first)
        count++;
 
    // Cannot generate 3 permutations
    if (count < k)
    {
      Console.Write("-1");
      return;
    }
 
    for (int i = 0; i < k - 1; i++)
    {
 
      // Print the first permutation
      printIndices(n, arr);
 
      // Find an index to swap and create
      // second permutation
      for (int j = next_pos; j < n; j++)
      {
        if (arr[j].first == arr[j - 1].first)
        {
          pair t = arr[j];
          arr[j] = arr[j - 1];
          arr[j - 1] = t;
 
          next_pos = j + 1;
          break;
        }
      }
    }
 
    // Print the last permuation
    printIndices(n, arr);
  }
 
  // Driver code
  public static void Main(string []args)
  {
    int []a = { 1, 3, 3, 1 };
    int n = a.Length;
 
    int k = 3;
 
    // Function call
    printPermutations(n, a, k);
  }
}
 
// This code is contributed by rutvik_56.


输出
0 3 1 2 
3 0 1 2 
3 0 2 1 

时间复杂度: O(N log N + KN)

如果您希望与行业专家一起参加现场课程,请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。