Problem: Lexicographically smallest permutation of a string that can be reduced to length K by removing K-length prefixes from palindromic substrings of length 2K
Given a binary string str of length N, and an integer K, the task is to find the lexicographically smallest permutation of the string str that can be reduced to length K by removal of every K-length prefix from palindromic substrings of length 2K. If no such permutation exists, print "Not Possible".

Sample Input: str = "0000100001100001”, K = 4
Sample Output: 0001100000011000
Explanation: In the string "0001100000011000", every 2K length substring becomes a palindrome whenever a K-length prefix is removed, until string length reduces to K.

Solution (cpp14):
// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to count the number of
// zeroes present in the string
int count_zeroes(int n, string str)
{
    int cnt = 0;

    // Traverse the string
    for (int i = 0; i < str.size(); i++) {
        if (str[i] == '0')
            cnt++;
    }

    // Return the count
    return cnt;
}

// Function to rearrange the string s.t
// the string can be reduced to a length
// K as per the given rules
string kReducingStringUtil(
    int n, int k, string str,
    int no_of_zeroes)
{

    // Distribute the count of 0s and
    // 1s in segment of length 2k
    int zeroes_in_2k = ((no_of_zeroes)
                        * (2 * k))
                       / n;

    int ones_in_2k = 2 * k - zeroes_in_2k;

    // Store string that are initially
    // have formed lexicographically
    // smallest 2k length substring
    string temp_str = "";

    for (int i = 0;
         i < (zeroes_in_2k) / 2; i++) {
        temp_str.push_back('0');
    }
    for (int i = 0; i < ones_in_2k; i++) {
        temp_str.push_back('1');
    }
    for (int i = 0;
         i < (zeroes_in_2k) / 2; i++) {
        temp_str.push_back('0');
    }

    // Store the lexicographically
    // smallest string of length n
    // that satisfy the condition
    string final_str = "";

    // Insert temp_str into final_str
    // (n/2k) times and add (n%2k)
    // characters of temp_str at end
    for (int i = 0;
         i < n / (2 * k); i++) {
        final_str += (temp_str);
    }

    for (int i = 0;
         i < n % (2 * k); i++) {
        final_str.push_back(temp_str[i]);
    }

    // Return the final string
    return final_str;
}

// Function to reduce the string to
// length K that follows the given
// conditions
string kReducingString(int n, int k,
                       string str)
{
    // If the string contains either
    // 0s or 1s then it always be
    // reduced into a K length string
    int no_of_zeroes = count_zeroes(n, str);

    int no_of_ones = n - no_of_zeroes;

    // If the string contains only 0s
    // 1s then it always reduces to
    // a K length string
    if (no_of_zeroes == 0
        || no_of_zeroes == n) {
        return str;
    }

    // If K = 1
    if (k == 1) {
        if (no_of_zeroes == 0
            || no_of_zeroes == n) {
            return str;
        }
        else {
            return "Not Possible";
        }
    }

    // Check whether the given string
    // is K reducing string or not
    bool check = 0;

    for (int i = (n / k);
         i < n; i += (n / k)) {

        if (no_of_zeroes == i
            || no_of_ones == i) {
            check = 1;
            break;
        }
    }

    if (check == 0) {
        return "Not Possible";
    }

    // Otherwise recursively find
    // the string
    return kReducingStringUtil(n, k,
                               str,
                               no_of_zeroes);
}

// Driver Code
int main()
{
    string str = "0000100001100001";
    int K = 4;
    int N = str.length();

    // Function Call
    cout << kReducingString(N, K, str);

    return 0;
}