Largest permutation after at most k swaps

// C# program for above approach
using System;
using System.Collections.Generic;
using System.Linq;

public class GFG
{
    class Pair
    {
        public int first, second;
        public Pair(int f, int s)
        {
            first = f;
            second = s;
        }
    }

    // Function returns the minimum number
    // of swaps required to sort the array
    static int minSwapsToSort(int[] arr, int n)
    {
        // Create an array of pairs where first
        // element is array element and second
        // element is position of first element
        List<Pair> arrPos = new List<Pair>();
        for (int i = 0; i < n; i++)
        {
            arrPos.Add(new Pair(arr[i], i));
        }

        // Sort the array by array element
        // values to get right position of
        // every element as second
        // element of pair.
        arrPos.Sort((Pair A, Pair B) => {
            return A.first - B.first;
        });

        // To keep track of visited elements.
        // Initialize all elements as not
        // visited or false.
        bool[] vis = new bool[n];

        // Initialize result
        int ans = 0;

        // Traverse array elements
        for (int i = 0; i < n; i++)
        {
            // Already swapped and corrected or
            // already present at correct pos
            if (vis[i] || arrPos[i].second == i)
                continue;

            // Find out the number of  node in
            // this cycle and add in ans
            int cycle_size = 0;
            int j = i;
            while (!vis[j])
            {
                vis[j] = true;

                // move to next node
                j = arrPos[j].second;
                cycle_size++;
            }

            // Update answer by adding current
            // cycle.
            ans += (cycle_size - 1);
        }

        // Return result
        return ans;
    }

    // method returns minimum number of
    // swap to make array B same as array A
    static int minSwapToMakeArraySame(int[] a, int[] b,
                                      int n)
    {
        // Map to store position of elements
        // in array B we basically store
        // element to index mapping.
        Dictionary<int, int> mp = new Dictionary<int, int>();
        for (int i = 0; i < n; i++)
            mp.Add(b[i], i);

        // now we're storing position of array
        // A elements in array B.
        for (int i = 0; i < n; i++)
            b[i] = mp[a[i]];

        /* We can uncomment this section to
                  print modified b array
            for (int i = 0; i < N; i++)
                  System.out.print(b[i]);
            System.out.println();
            */

        // Returning minimum swap for sorting
        // in modified array B as final answer
        return minSwapsToSort(b, n);
    }

    // Function to calculate largest
    // permutation after atmost K swaps
    static void KswapPermutation(int[] arr, int n, int k)
    {
        int[] a = new int[n];

        // copy the array
        for (int i = 0; i < n; i++)
            a[i] = arr[i];

        // Sort the array in descending order
        // Arrays.sort(arr);
        Array.Sort(arr);
        for (int idx = 0; idx < n / 2; idx++)
        {
            int t = arr[idx];
            arr[idx] = arr[n - idx - 1];
            arr[n - idx - 1] = t;
        }

        // generate permutation in lexicographically
        // decreasing order.
        do
        {
            // copy the array
            int[] a1 = new int[n];
            int[] b1 = new int[n];
            for (int i = 0; i < n; i++)
            {
                a1[i] = arr[i];
                b1[i] = a[i];
            }

            // Check if it can be made same in k steps
            if (minSwapToMakeArraySame(a1, b1, n) <= k)
            {
                // Print the array
                for (int i = 0; i < n; i++)
                    Console.Write(arr[i] + " ");
                break;
            }

            // move to previous permutation
        } while (prev_permutation(arr, n));
    }

    static bool prev_permutation(int[] s, int n)
    {
        // Find the largest index i such that s[i-1] is more
        // than s[i]
        int i = n - 1;
        while (i > 0 && s[i - 1] <= s[i])
        {
            // Return false if i is at the first index of
            // the string.
            if (--i == 0)
            {
                return false;
            }
        }

        // Find the highest index j such that j >= i and
        // s[j] < s[i-1]
        int j = i;
        while (j < n && s[j] <= s[i - 1])
        {
            j++;
        }

        j--;

        // Swap character at index i-1 with index j
        int t = s[i - 1];
        s[i - 1] = s[j];
        s[j] = t;

        // Reverse substring s[i to n-1] and return true
        int l = i;
        int r = n - 1;
        while (l < r)
        {
            t = s[l];
            s[l] = s[r];
            s[r] = t;
            l++;
            r--;
        }

        return true;
    }
    static public void Main()
    {
        int[] arr = { 2, 1, 3 };
        int n = arr.Length;
        int k = 1;
        Console.WriteLine("Largest permutation after " + k
                           + " swaps:");
        KswapPermutation(arr, n, k);
    }
}

// This code is contributed by akashish__

using System;
using System.Collections.Generic;
class GFG {
  static void KswapPermutation(int[] arr, int n, int k)
  {
    for (int i = 0; i < n - 1; i++) {
      if (k > 0) {
        int max = i;
        for (int j = i + 1; j < n; j++)
          if (arr[j] > arr[max]) {
            max = j;
          }

        // this condition checks whether the max
        // value has changed since when we started ,
        // or is it the same. We need to ignore the
        // swap if the value is same. It means that
        // the number ought to be present at the ith
        // position , is already there.
        if (max != i) {
          int temp = arr[max];
          arr[max] = arr[i];
          arr[i] = temp;
          k--;
        }
      }
      else
        break;
    }
  }

  // Driver code
  public static void Main(string[] args)
  {
    int[] arr = { 4, 5, 2, 1, 3 };
    int n = 5;
    int k = 3;
    KswapPermutation(arr, n, k);
    Console.WriteLine("Largest permutation after " + k
                      + " swaps:");
    for (int i = 0; i < n; i++)
      Console.Write(arr[i] + " ");
  }
}

// This code is contributed by garg28harsh.