生成前 N 个自然数的排列，其唯一相邻差异的计数等于 K

给定两个正整数N和K ，任务是构造前N 个自然数的排列，使得相邻元素之间所有可能的绝对差为K 。

例子：

Input: N = 3, K = 1
Output: 1 2 3
Explanation: Considering the permutation {1, 2, 3}, all possible unique absolute difference of adjacent elements is {1}. Since the count is 1(= K), print the sequence {1, 2, 3} as the resultant permutation.

Input: N = 3, K = 2
Output: 1 3 2

朴素的方法：解决给定问题的最简单的方法是创建一个数组，其中元素从1到N按升序排列，然后遍历数组的前 K 个元素并反转子数组，从当前索引开始到最后一个结束指数。完成上述步骤后，打印得到的结果数组。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to reverse the given list
void reverse(int list[], int start, int end)
{
     
    // Iterate until start < end
    while (start < end)
    {
         
        // Swap operation
        int temp = list[start];
        list[start] = list[end];
        list[end] = temp;
 
        start++;
        end--;
    }
}
 
// Function to construct a list with
// exactly K unique adjacent element
// differences
void makeList(int N, int K)
{
     
    // Stores the resultant array
    int list[N];
     
    // Add initial value to array
    for(int i = 1; i <= N; i++)
    {
        list[i - 1] = i;
    }
 
    // Reverse the list k-1 times
    // from index i to n-1
    for(int i = 1; i < K; i++)
    {
        reverse(list, i, N - 1);
    }
 
    // Print the resultant array
    for(int i = 0; i < N; i++)
    {
        cout << list[i] << " ";
    }
}
 
// Driver code
int main()
{
    int N = 6, K = 3;
    makeList(N, K);
     
    return 0;
}
 
// This code is contributed by mohit kumar 29

Java

// Java program for the above approach
 
class GFG {
 
    // Function to construct a list with
    // exactly K unique adjacent element
    // differences
    public static void makeList(int N, int K)
    {
        // Stores the resultant array
        int[] list = new int[N];
 
        // Add initial value to array
        for (int i = 1; i <= N; i++) {
            list[i - 1] = i;
        }
 
        // Reverse the list k-1 times
        // from index i to n-1
        for (int i = 1; i < K; i++) {
            reverse(list, i, N - 1);
        }
 
        // Print the resultant array
        for (int i = 0;
             i < list.length; i++) {
            System.out.print(list[i] + " ");
        }
    }
 
    // Function to reverse the given list
    public static void reverse(
        int[] list, int start, int end)
    {
        // Iterate until start < end
        while (start < end) {
 
            // Swap operation
            int temp = list[start];
            list[start] = list[end];
            list[end] = temp;
 
            start++;
            end--;
        }
    }
 
    // Driver Code
    public static void main(
        String[] args)
    {
        int N = 6, K = 3;
        makeList(N, K);
    }
}

Python3

# Python 3 program for the above approach
 
# Function to reverse the given lst
def reverse(lst, start,  end):
   
    # Iterate until start < end
    while (start < end):
       
        # Swap operation
        temp = lst[start]
        lst[start] = lst[end]
        lst[end] = temp
 
        start += 1
        end -= 1
 
# Function to construct a lst with
# exactly K unique adjacent element
# differences
def makelst(N, K):
   
    # Stores the resultant array
    lst = [0 for i in range(N)]
     
    # Add initial value to array
    for i in range(1, N + 1, 1):
        lst[i - 1] = i
 
    # Reverse the lst k-1 times
    # from index i to n-1
    for i in range(1, K, 1):
        reverse(lst, i, N - 1)
 
    # Print the resultant array
    for i in range(N):
        print(lst[i], end = " ")
 
# Driver code
if __name__ == '__main__':
    N = 6
    K = 3
    makelst(N, K)
     
    # This code is contributed by SURENDRA_GANGWAR.

C#

// C# program for the above approach
using System;
 
class GFG{
 
// Function to construct a list with
// exactly K unique adjacent element
// differences
public static void makeList(int N, int K)
{
     
    // Stores the resultant array
    int[] list = new int[N];
 
    // Add initial value to array
    for(int i = 1; i <= N; i++)
    {
        list[i - 1] = i;
    }
 
    // Reverse the list k-1 times
    // from index i to n-1
    for(int i = 1; i < K; i++)
    {
        reverse(list, i, N - 1);
    }
 
    // Print the resultant array
    for(int i = 0; i < list.Length; i++)
    {
        Console.Write(list[i] + " ");
    }
}
 
// Function to reverse the given list
public static void reverse(int[] list, int start,
                           int end)
{
     
    // Iterate until start < end
    while (start < end)
    {
         
        // Swap operation
        int temp = list[start];
        list[start] = list[end];
        list[end] = temp;
 
        start++;
        end--;
    }
}
 
// Driver Code
static public void Main()
{
    int N = 6, K = 3;
     
    makeList(N, K);
}
}
 
// This code is contributed by Dharanendra L V.

Javascript

 
// Javascript program for the above approach
 
    // Function to construct a list with
    // exactly K unique adjacent element
    // differences
    function makeList(N, K)
    {
        // Stores the resultant array
        let list = Array.from(Array(N), ()=>Array(0));
 
        // Add initial value to array
        for (let i = 1; i <= N; i++) {
            list[i - 1] = i;
        }
 
        // Reverse the list k-1 times
        // from index i to n-1
        for (let i = 1; i < K; i++) {
            reverse(list, i, N - 1);
        }
 
        // Print the resultant array
        for (let i = 0;
             i < list.length; i++) {
            document.write(list[i] + " ");
        }
    }
 
    // Function to reverse the given list
    function reverse(
        list, start, end)
    {
        // Iterate until start < end
        while (start < end) {
 
            // Swap operation
            let temp = list[start];
            list[start] = list[end];
            list[end] = temp;
 
            start++;
            end--;
        }
    }
 
// Driver Code
 
    let N = 6, K = 3;
    makeList(N, K);
  
 // This code is contributed by sanjoy_62.

---

输出：

1 6 2 3 4 5

时间复杂度： O(N ² )
辅助空间： O(N)

高效的方法：上述方法也可以通过使用两点方法进行优化。请按照以下步骤解决问题：

• 初始化一个大小为N的数组ans[] ，用于存储结果排列。
• 创建两个变量，分别说left和right为1和N 。
• 遍历给定数组并执行以下步骤：
  • 如果K 的值为偶数，则将left的值推入数组ans[]并将left的值增加1 。
  • 如果K 的值为奇数，则将右边的值推入 到数组ans[]并将right的值减1 。
  • 如果 K的值大于 1，则将K的值减1 。
• 完成上述步骤后，打印数组ans[] 。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include
using namespace std;
// Function to construct the list
// with exactly K unique adjacent
// element differences
void makeList(int N, int K)
{
    // Stores the resultant array
    int list[N];
 
    // Stores the left and the right
    // most element of the range
    int left = 1;
    int right = N;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // If k is even, the add
        // left to array and
        // increment the left
        if (K % 2 == 0) {
            list[i] = left;
            left = left + 1;
        }
 
        // If k is odd, the add
        // right to array and
        // decrement the right
        else {
            list[i] = right;
            right = right - 1;
        }
 
        // Repeat the steps for
        // k-1 times
        if (K > 1)
            K--;
    }
 
    // Print the resultant list
    for (int i = 0; i < N; i++) {
            cout<

Java

// Java program for the above approach
 
class GFG {
 
    // Function to construct the list
    // with exactly K unique adjacent
    // element differences
    public static void makeList(int N,
                                int K)
    {
        // Stores the resultant array
        int[] list = new int[N];
 
        // Stores the left and the right
        // most element of the range
        int left = 1;
        int right = N;
 
        // Traverse the array
        for (int i = 0; i < N; i++) {
 
            // If k is even, the add
            // left to array and
            // increment the left
            if (K % 2 == 0) {
                list[i] = left;
                left = left + 1;
            }
 
            // If k is odd, the add
            // right to array and
            // decrement the right
            else {
                list[i] = right;
                right = right - 1;
            }
 
            // Repeat the steps for
            // k-1 times
            if (K > 1)
                K--;
        }
 
        // Print the resultant list
        for (int i = 0;
             i < list.length; i++) {
            System.out.print(
                list[i] + " ");
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int N = 6;
        int K = 3;
        makeList(N, K);
    }
}

蟒蛇3

# Python3 program for the above approach
 
# Function to construct the lst
# with exactly K unique adjacent
# element differences
def makelst(N, K):
     
    # Stores the resultant array
    lst = [0 for i in range(N)]
 
    # Stores the left and the right
    # most element of the range
    left = 1
    right = N
 
    # Traverse the array
    for i in range(N):
         
        # If k is even, the add
        # left to array and
        # increment the left
        if (K % 2 == 0):
            lst[i] = left
            left = left + 1
 
        # If k is odd, the add
        # right to array and
        # decrement the right
        else:
            lst[i] = right
            right = right - 1
 
        # Repeat the steps for
        # k-1 times
        if (K > 1):
            K -= 1
 
    # Print the resultant lst
    for i in range(N):
        print(lst[i], end = " ")
         
# Driver Code
if __name__ == '__main__':
     
    N = 6
    K = 3
     
    makelst(N, K)
 
# This code is contributed by bgangwar59

C＃

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to construct the list
// with exactly K unique adjacent
// element differences
public static void makeList(int N, int K)
{
     
    // Stores the resultant array
    int[] list = new int[N];
 
    // Stores the left and the right
    // most element of the range
    int left = 1;
    int right = N;
 
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // If k is even, the add
        // left to array and
        // increment the left
        if (K % 2 == 0)
        {
            list[i] = left;
            left = left + 1;
        }
 
        // If k is odd, the add
        // right to array and
        // decrement the right
        else
        {
            list[i] = right;
            right = right - 1;
        }
 
        // Repeat the steps for
        // k-1 times
        if (K > 1)
            K--;
    }
 
    // Print the resultant list
    for(int i = 0; i < list.Length; i++)
    {
        Console.Write(list[i] + " ");
    }
}
 
// Driver Code
public static void Main(String[] args)
{
    int N = 6;
    int K = 3;
     
    makeList(N, K);
}
}
 
// This code is contributed by 29AjayKumar

Javascript

 
// Javascript program for the above approach
 
// Function to construct the list
// with exactly K unique adjacent
// element differences
function makeList(N, K)
{
     
    // Stores the resultant array
    var list= new Array(N);
 
    // Stores the left and the right
    // most element of the range
    var left = 1;
    var right = N;
 
    // Traverse the array
    for(var i = 0; i < N; i++)
    {
         
        // If k is even, the add
        // left to array and
        // increment the left
        if (K % 2 == 0)
        {
            list[i] = left;
            left = left + 1;
        }
 
        // If k is odd, the add
        // right to array and
        // decrement the right
        else
        {
            list[i] = right;
            right = right - 1;
        }
 
        // Repeat the steps for
        // k-1 times
        if (K > 1)
            K--;
    }
 
    // Print the resultant list
    for(var i = 0; i < N; i++)
    {
        document.write(list[i] + " ");
    }
}
 
// Driver code
var  N = 6;
var K = 3;
 
makeList(N, K);
 
// This code is contributed by SoumikMondal
 

输出：

6 1 5 4 3 2

时间复杂度： O(N)
辅助空间： O(N)