Käännöt

#include <bits/stdc++.h>
using namespace std;
 
void k2(int n, int luvut[])
{
    int maara = 0;
    vector<int> siirrot = {};
 
    int eka;
    for (int i = n - 1; i >= 0; i--)
    {
        for (int j = 0; j < i; j++)
        {
            eka = luvut[j];
            if (eka > luvut[j + 1])
            {
                maara++;
                siirrot.push_back(j);
                luvut[j] = luvut[j + 1];
                luvut[j + 1] = eka;
            }
        }
    }
 
    cout << "YES\n"
         << maara << "\n";
    for (int siirto : siirrot)
    {
        cout << siirto + 1 << " ";
    }
}
 
void k3(int n, int luvut[])
{
    int maara = 0;
    vector<int> siirrot = {};
 
    int parittomia = (n + 1) / 2;
    int parillisia = n / 2;
    int parittomat[parittomia];
    int parilliset[parillisia];
 
    // lisätään omiin listoihin
    for (int i = 0; i < parillisia; i++)
    {
        parittomat[i] = luvut[2 * i];
        parilliset[i] = luvut[2 * i + 1];
    }
 
    if (parillisia != parittomia)
    {
        parittomat[parillisia] = luvut[n - 1];
    }
 
    // järjestetään listat
    int eka;
    for (int i = parittomia - 1; i >= 0; i--)
    {
        for (int j = 0; j < i; j++)
        {
            eka = parittomat[j];
            if (eka > parittomat[j + 1])
            {
                maara++;
                siirrot.push_back(2 * j);
                parittomat[j] = parittomat[j + 1];
                parittomat[j + 1] = eka;
            }
        }
    }
 
    for (int i = parillisia - 1; i >= 0; i--)
    {
        for (int j = 0; j < i; j++)
        {
            eka = parilliset[j];
            if (eka > parilliset[j + 1])
            {
                maara++;
                siirrot.push_back(2 * j + 1);
                parilliset[j] = parilliset[j + 1];
                parilliset[j + 1] = eka;
            }
        }
    }
 
    // tarkistetaan onko kaikki suuruusjärjestyksessä.
    if (parittomat[0] > parilliset[0])
    {
        cout << "NO";
        return;
    }
 
    for (int i = 1; i < parillisia; i++)
    {
        if (parittomat[i] > parilliset[i] || parilliset[i - 1] > parittomat[i])
        {
            cout << "NO";
            return;
        }
    }
 
    if (parillisia != parittomia)
    {
        if (parilliset[parillisia - 1] > parittomat[parillisia])
        {
            cout << "NO";
            return;
        }
    }
 
    cout << "YES\n"
         << maara << "\n";
    for (int siirto : siirrot)
    {
        cout << siirto + 1 << " ";
    }
}
 
void k4n5(int luvut[])
{
    vector<int> siirrot = {};
    int temp1, temp2;
 
    int siirto = 0;
    for (int i = 0; i < 11; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            if (luvut[j] != j + 1)
                break;
 
            if (j != 3)
                continue;
 
            cout << "YES\n"
                 << siirrot.size() << "\n";
            for (int siirto1 : siirrot)
            {
                cout << (siirto1 + 1) << " ";
            }
 
            return;
        }
 
        siirrot.push_back(siirto);
 
        temp1 = luvut[3 + siirto];
        temp2 = luvut[2 + siirto];
        luvut[3 + siirto] = luvut[0 + siirto];
        luvut[2 + siirto] = luvut[1 + siirto];
        luvut[0 + siirto] = temp1;
        luvut[1 + siirto] = temp2;
 
        siirto ^= 1;
    }
 
    cout << "NO";
}
 
void k4n6(int luvut[])
{
    vector<int> siirrot = {};
    int temp1, temp2;
 
    if (luvut[0] == 6)
    {
        siirrot.push_back(0);
 
        temp1 = luvut[3];
        temp2 = luvut[2];
        luvut[3] = luvut[0];
        luvut[2] = luvut[1];
        luvut[0] = temp1;
        luvut[1] = temp2;
    }
 
    if (luvut[3] == 6 || luvut[4] == 6)
    {
        siirrot.push_back(1);
 
        temp1 = luvut[4];
        temp2 = luvut[3];
        luvut[4] = luvut[1];
        luvut[3] = luvut[2];
        luvut[1] = temp1;
        luvut[2] = temp2;
    }
 
    if (luvut[1] == 6)
    {
        siirrot.push_back(0);
 
        temp1 = luvut[3];
        temp2 = luvut[2];
        luvut[3] = luvut[0];
        luvut[2] = luvut[1];
        luvut[0] = temp1;
        luvut[1] = temp2;
    }
 
    if (luvut[2] == 6)
    {
        siirrot.push_back(2);
 
        temp1 = luvut[5];
        temp2 = luvut[4];
        luvut[5] = luvut[2];
        luvut[4] = luvut[3];
        luvut[2] = temp1;
        luvut[3] = temp2;
    }
 
    if (luvut[0] == 5)
    {
        siirrot.push_back(0);
 
        temp1 = luvut[3];
        temp2 = luvut[2];
        luvut[3] = luvut[0];
        luvut[2] = luvut[1];
        luvut[0] = temp1;
        luvut[1] = temp2;
    }
 
    if (luvut[3] == 5)
    {
        siirrot.push_back(1);
 
        temp1 = luvut[4];
        temp2 = luvut[3];
        luvut[4] = luvut[1];
        luvut[3] = luvut[2];
        luvut[1] = temp1;
        luvut[2] = temp2;
    }
 
    if (luvut[2] == 5)
    {
        siirrot.push_back(0);
 
        temp1 = luvut[3];
        temp2 = luvut[2];
        luvut[3] = luvut[0];
        luvut[2] = luvut[1];
        luvut[0] = temp1;
        luvut[1] = temp2;
    }
 
    if (luvut[1] == 5)
    {
        siirrot.push_back(1);
 
        temp1 = luvut[4];
        temp2 = luvut[3];
        luvut[4] = luvut[1];
        luvut[3] = luvut[2];
        luvut[1] = temp1;
        luvut[2] = temp2;
    }
 
    if (luvut[2] == 4 || luvut[0] == 4)
    {
        siirrot.push_back(0);
 
        temp1 = luvut[3];
        temp2 = luvut[4];
        luvut[3] = luvut[2];
        luvut[2] = luvut[1];
        luvut[0] = temp1;
        luvut[1] = temp2;
    }
 
    if (luvut[1] == 4)
    {
        siirrot.push_back(2);
        siirrot.push_back(1);
        siirrot.push_back(0);
        siirrot.push_back(2);
        siirrot.push_back(0);
        siirrot.push_back(1);
        siirrot.push_back(2);
        siirrot.push_back(0);
 
        temp1 = luvut[3];
        temp2 = luvut[2];
        luvut[3] = luvut[1];
        luvut[2] = luvut[0];
        luvut[1] = temp1;
        luvut[0] = temp2;
    }
 
    if (luvut[0] != 1)
    {
        cout << "NO";
        return;
    }
 
    cout << "YES\n"
         << siirrot.size() << "\n";
    for (int siirto : siirrot)
    {
        cout << (siirto + 1) << " ";
    }
}
 
void k4n7(int luvut[])
{
}
 
void k4(int n, int luvut[])
{
    if (n <= 7)
    {
        if (n == 5)
        {
            k4n5(luvut);
            return;
        }
        if (n == 6)
        {
            k4n6(luvut);
            return;
        }
        k4n7(luvut);
        return;
    }
 
    vector<int> siirrot = {};
 
    int temp1, temp2;
 
    int haluttuIndex = n;
    int haluttuMod3 = n % 3;
    int nykyinenIndex;
    for (int nykyinen = n; nykyinen > 6; nykyinen--)
    {
        haluttuIndex--;
        haluttuMod3--;
        if (haluttuMod3 < 0)
        {
            haluttuMod3 = 2;
        }
 
        for (int i = 0; i < nykyinen; i++)
        {
            if (luvut[i] == nykyinen)
            {
                nykyinenIndex = i;
                break;
            }
        }
 
        if (nykyinenIndex == haluttuIndex)
        {
            continue;
        }
 
        if (nykyinenIndex >= nykyinen - 3)
        {
            siirrot.push_back(nykyinenIndex - 3);
 
            temp1 = luvut[nykyinenIndex - 3];
            temp2 = luvut[nykyinenIndex - 2];
            luvut[nykyinenIndex - 3] = luvut[nykyinenIndex];
            luvut[nykyinenIndex - 2] = luvut[nykyinenIndex - 1];
            luvut[nykyinenIndex] = temp1;
            luvut[nykyinenIndex - 1] = temp2;
 
            nykyinenIndex -= 3;
        }
 
        if (nykyinenIndex == 0)
        {
            siirrot.push_back(nykyinenIndex);
 
            temp1 = luvut[nykyinenIndex + 3];
            temp2 = luvut[nykyinenIndex + 2];
            luvut[nykyinenIndex + 3] = luvut[nykyinenIndex];
            luvut[nykyinenIndex + 2] = luvut[nykyinenIndex + 1];
            luvut[nykyinenIndex] = temp1;
            luvut[nykyinenIndex + 1] = temp2;
 
            nykyinenIndex += 3;
        }
 
        int siirto = (haluttuIndex - nykyinenIndex) % 3;
 
        for (int j = 0; j < siirto; j++)
        {
            siirrot.push_back(nykyinenIndex - 1);
 
            temp1 = luvut[nykyinenIndex + 2];
            temp2 = luvut[nykyinenIndex + 1];
            luvut[nykyinenIndex + 2] = luvut[nykyinenIndex - 1];
            luvut[nykyinenIndex + 1] = luvut[nykyinenIndex];
            luvut[nykyinenIndex - 1] = temp1;
            luvut[nykyinenIndex] = temp2;
 
            nykyinenIndex++;
        }
 
        while (nykyinenIndex != haluttuIndex)
        {
            siirrot.push_back(nykyinenIndex);
 
            temp1 = luvut[nykyinenIndex + 3];
            temp2 = luvut[nykyinenIndex + 2];
            luvut[nykyinenIndex + 3] = luvut[nykyinenIndex];
            luvut[nykyinenIndex + 2] = luvut[nykyinenIndex + 1];
            luvut[nykyinenIndex] = temp1;
            luvut[nykyinenIndex + 1] = temp2;
 
            nykyinenIndex += 3;
        }
    }
 
    // jarjesta 6.
    for (int i = 0; i < 6; i++)
    {
        if (luvut[i] == 6)
        {
            nykyinenIndex = i;
            break;
        }
    }
 
    if (nykyinenIndex == 0)
    {
        siirrot.push_back(0);
 
        temp1 = luvut[3];
        temp2 = luvut[2];
        luvut[3] = luvut[0];
        luvut[2] = luvut[1];
        luvut[0] = temp1;
        luvut[1] = temp2;
 
        nykyinenIndex = 3;
    }
 
    if (nykyinenIndex == 3 || nykyinenIndex == 4)
    {
        siirrot.push_back(1);
 
        temp1 = luvut[4];
        temp2 = luvut[3];
        luvut[4] = luvut[1];
        luvut[3] = luvut[2];
        luvut[1] = temp1;
        luvut[2] = temp2;
 
        nykyinenIndex = 5 - nykyinenIndex;
    }
 
    if (nykyinenIndex == 1)
    {
        siirrot.push_back(0);
 
        temp1 = luvut[3];
        temp2 = luvut[2];
        luvut[3] = luvut[0];
        luvut[2] = luvut[1];
        luvut[0] = temp1;
        luvut[1] = temp2;
 
        nykyinenIndex = 2;
    }
 
    if (nykyinenIndex == 2)
    {
        siirrot.push_back(2);
 
        temp1 = luvut[5];
        temp2 = luvut[4];
        luvut[5] = luvut[2];
        luvut[4] = luvut[3];
        luvut[2] = temp1;
        luvut[3] = temp2;
    }
 
    // järjestä 5
    for (int i = 0; i < 5; i++)
    {
        if (luvut[i] == 5)
        {
            nykyinenIndex = i;
            break;
        }
    }
 
    if (nykyinenIndex == 0)
    {
        siirrot.push_back(0);
 
        temp1 = luvut[3];
        temp2 = luvut[2];
        luvut[3] = luvut[0];
        luvut[2] = luvut[1];
        luvut[0] = temp1;
        luvut[1] = temp2;
 
        nykyinenIndex = 3;
    }
 
    if (nykyinenIndex == 3)
    {
        siirrot.push_back(1);
 
        temp1 = luvut[4];
        temp2 = luvut[3];
        luvut[4] = luvut[1];
        luvut[3] = luvut[2];
        luvut[1] = temp1;
        luvut[2] = temp2;
 
        nykyinenIndex = 2;
    }
 
    if (nykyinenIndex == 2)
    {
        siirrot.push_back(0);
 
        temp1 = luvut[3];
        temp2 = luvut[2];
        luvut[3] = luvut[0];
        luvut[2] = luvut[1];
        luvut[0] = temp1;
        luvut[1] = temp2;
 
        nykyinenIndex = 1;
    }
 
    if (nykyinenIndex == 1)
    {
        siirrot.push_back(1);
 
        temp1 = luvut[4];
        temp2 = luvut[3];
        luvut[4] = luvut[1];
        luvut[3] = luvut[2];
        luvut[1] = temp1;
        luvut[2] = temp2;
    }
 
    // siirrä 4. 4.
    for (int i = 0; i < 4; i++)
    {
        if (luvut[i] == 4)
        {
            nykyinenIndex = i;
            break;
        }
    }
 
    if (nykyinenIndex == 0)
    {
        siirrot.push_back(0);
 
        temp1 = luvut[3];
        temp2 = luvut[2];
        luvut[3] = luvut[0];
        luvut[2] = luvut[1];
        luvut[0] = temp1;
        luvut[1] = temp2;
 
        nykyinenIndex = 3;
    }
    if (nykyinenIndex == 2)
    {
        siirrot.push_back(0);
 
        temp1 = luvut[3];
        temp2 = luvut[2];
        luvut[3] = luvut[0];
        luvut[2] = luvut[1];
        luvut[0] = temp1;
        luvut[1] = temp2;
 
        nykyinenIndex = 1;
    }
 
    if (nykyinenIndex == 1)
    {
        siirrot.push_back(2);
        siirrot.push_back(1);
        siirrot.push_back(0);
        siirrot.push_back(2);
        siirrot.push_back(0);
        siirrot.push_back(1);
        siirrot.push_back(2);
        siirrot.push_back(0);
 
        temp1 = luvut[3];
        temp2 = luvut[2];
        luvut[3] = luvut[1];
        luvut[2] = luvut[0];
        luvut[1] = temp1;
        luvut[0] = temp2;
    }
 
    if ((luvut[1] - luvut[0] + 3) % 3 != 1)
    {
        cout << "NO";
        return;
    }
 
    for (int i = luvut[0]; i > 1; i--)
    {
        siirrot.push_back(1);
        siirrot.push_back(4);
        siirrot.push_back(3);
        siirrot.push_back(1);
        siirrot.push_back(0);
        siirrot.push_back(3);
        siirrot.push_back(1);
        siirrot.push_back(0);
        siirrot.push_back(4);
        siirrot.push_back(1);
        siirrot.push_back(2);
        siirrot.push_back(4);
        siirrot.push_back(0);
        siirrot.push_back(3);
    }
 
    cout << "YES\n"
         << siirrot.size() << "\n";
    for (int siirto : siirrot)
    {
        cout << (siirto + 1) << " ";
    }
}
 
void k5n5(int luvut[])
{
    if ((luvut[0] == 1) && (luvut[1] == 2) && (luvut[2] == 3) && (luvut[3] == 4))
    {
        cout << "YES\n0";
        return;
    }
    if ((luvut[0]) == 5 && (luvut[1] == 4) && (luvut[2] == 3) && (luvut[3] == 2))
    {
        cout << "YES\n1\n1";
        return;
    }
 
    cout << "NO";
    return;
}
 
void k5n6(int luvut[])
{
    vector<int> siirrot = {};
    int temp1, temp2;
    int index = 0;
    for (int i = 0; i < 6; i++)
    {
        if (luvut[0] == 1 && luvut[1] == 2 && luvut[2] == 3 && luvut[3] == 4 && luvut[4] == 5)
        {
            cout << "YES\n"
                 << siirrot.size() << "\n";
 
            for (int siirto : siirrot)
            {
                cout << (siirto + 1) << " ";
            }
 
            return;
        }
 
        temp1 = luvut[index];
        temp2 = luvut[index + 1];
 
        luvut[index] = luvut[index + 4];
        luvut[index + 1] = luvut[index + 3];
 
        luvut[index + 3] = temp2;
        luvut[index + 4] = temp1;
 
        siirrot.push_back(index);
        index ^= 1;
    }
}
 
bool k5n7(int luvut[])
{
    for (int i = 0; i < 7; i++)
    {
        if (luvut[i] % 2 == i % 2)
        {
            cout << "NO";
            return false;
        }
    }
 
    vector<int> siirrot = {};
    int temp1, temp2;
 
    // parilliset
    if (luvut[3] != 4)
    {
        if (luvut[1] == 4)
        {
            temp1 = luvut[0];
            temp2 = luvut[1];
 
            luvut[0] = luvut[4];
            luvut[1] = luvut[3];
 
            luvut[4] = temp1;
            luvut[3] = temp2;
 
            siirrot.push_back(0);
        }
        else
        { // luvut[5] == 4
            temp1 = luvut[2];
            temp2 = luvut[3];
 
            luvut[2] = luvut[6];
            luvut[3] = luvut[5];
 
            luvut[6] = temp1;
            luvut[5] = temp2;
            siirrot.push_back(2);
        }
    }
 
    if (luvut[1] != 2)
    {
        temp1 = luvut[1];
        temp2 = luvut[2];
 
        luvut[1] = luvut[5];
        luvut[2] = luvut[4];
 
        luvut[5] = temp1;
        luvut[4] = temp2;
 
        siirrot.push_back(1);
    }
 
    // parittomat
 
    if (luvut[0] == 7)
    {
        siirrot.push_back(2);
        siirrot.push_back(0);
        siirrot.push_back(2);
        siirrot.push_back(1);
 
        temp1 = luvut[4];
        luvut[4] = luvut[2];
        luvut[2] = luvut[0];
        luvut[0] = temp1;
    }
 
    if (luvut[4] == 7)
    {
        siirrot.push_back(0);
        siirrot.push_back(2);
        siirrot.push_back(0);
        siirrot.push_back(1);
 
        temp1 = luvut[2];
        luvut[2] = luvut[4];
        luvut[4] = luvut[6];
        luvut[6] = temp1;
    }
 
    if (luvut[2] == 7)
    {
        siirrot.push_back(0);
        siirrot.push_back(2);
        siirrot.push_back(0);
        siirrot.push_back(1);
 
        temp1 = luvut[2];
        luvut[2] = luvut[4];
        luvut[4] = luvut[6];
        luvut[6] = temp1;
    }
 
    if ((luvut[0] - luvut[2] + 8) % 6 != 0)
    {
        cout << "NO";
        return false;
    }
 
    while (luvut[0] != 1)
    {
        siirrot.push_back(2);
        siirrot.push_back(0);
        siirrot.push_back(2);
        siirrot.push_back(1);
 
        temp1 = luvut[4];
        luvut[4] = luvut[2];
        luvut[2] = luvut[0];
        luvut[0] = temp1;
    }
 
    cout << "YES\n"
         << siirrot.size() << "\n";
 
    for (int siirto : siirrot)
    {
        cout << (siirto + 1) << " ";
    }
    return true;
}
 
void k5(int n, int luvut[])
{
    vector<int> siirrot = {};
    int temp1;
 
    for (int i = 0; i < n; i++)
    {
        if (luvut[i] % 2 == i % 2)
        {
            cout << "NO";
            return;
        }
    }
 
    if (n <= 7)
    {
        if (n == 5)
        {
            k5n5(luvut);
            return;
        }
        if (n == 6)
        {
            k5n6(luvut);
            return;
        }
        k5n7(luvut);
        return;
    }
 
    int nPariton = n;
    int nParillinen = n;
 
    if (n & 1)
    {
        nParillinen--;
    }
    else
    {
        nPariton--;
    }
 
    int suurimmanParittomanIndex = -1;
    int suurimmanParilisenIndex = -1;
 
    for (int i = 0; i < n; i++)
    {
        if (luvut[i] == nPariton)
        {
            suurimmanParittomanIndex = i;
        }
        else if (luvut[i] == nParillinen)
        {
            suurimmanParilisenIndex = i;
        }
    }
 
    // Siirrä suurin pariton
 
    if (suurimmanParittomanIndex == nPariton - 3)
    {
        siirrot.push_back(nPariton - 7);
        siirrot.push_back(nPariton - 5);
        siirrot.push_back(nPariton - 7);
        siirrot.push_back(nPariton - 6);
 
        temp1 = luvut[nPariton - 5];
        luvut[nPariton - 5] = luvut[nPariton - 3];
        luvut[nPariton - 3] = luvut[nPariton - 1];
        luvut[nPariton - 1] = temp1;
 
        suurimmanParittomanIndex = nPariton - 5;
    }
    else
    {
 
        if (suurimmanParittomanIndex == 0)
        {
            siirrot.push_back(2);
            siirrot.push_back(0);
            siirrot.push_back(2);
            siirrot.push_back(1);
 
            temp1 = luvut[suurimmanParittomanIndex + 4];
            luvut[suurimmanParittomanIndex + 4] = luvut[suurimmanParittomanIndex + 2];
            luvut[suurimmanParittomanIndex + 2] = luvut[suurimmanParittomanIndex];
            luvut[suurimmanParittomanIndex] = temp1;
 
            suurimmanParittomanIndex += 2;
        }
 
        if ((nPariton - suurimmanParittomanIndex) % 4 == 3)
        {
            siirrot.push_back(suurimmanParittomanIndex + 2);
            siirrot.push_back(suurimmanParittomanIndex);
            siirrot.push_back(suurimmanParittomanIndex + 2);
            siirrot.push_back(suurimmanParittomanIndex + 1);
 
            temp1 = luvut[n + 4];
            luvut[n + 4] = luvut[n + 2];
            luvut[n + 2] = luvut[n];
            luvut[n] = temp1;
 
            suurimmanParittomanIndex += 2;
        }
    }
 
    while (suurimmanParittomanIndex < nPariton - 1)
    {
        siirrot.push_back(suurimmanParittomanIndex - 2);
        siirrot.push_back(suurimmanParittomanIndex);
        siirrot.push_back(suurimmanParittomanIndex - 2);
        siirrot.push_back(suurimmanParittomanIndex - 1);
 
        temp1 = luvut[suurimmanParittomanIndex];
        luvut[suurimmanParittomanIndex] = luvut[suurimmanParittomanIndex + 2];
        luvut[suurimmanParittomanIndex + 2] = luvut[suurimmanParittomanIndex + 4];
        luvut[suurimmanParittomanIndex + 4] = temp1;
 
        suurimmanParittomanIndex += 4;
    }
 
    // Siirrä suurin parillinen
 
    if (suurimmanParilisenIndex == nParillinen - 3)
    {
        siirrot.push_back(nParillinen - 7);
        siirrot.push_back(nParillinen - 5);
        siirrot.push_back(nParillinen - 7);
        siirrot.push_back(nParillinen - 6);
 
        temp1 = luvut[nParillinen - 5];
        luvut[nParillinen - 5] = luvut[nParillinen - 3];
        luvut[nParillinen - 3] = luvut[nParillinen - 1];
        luvut[nParillinen - 1] = temp1;
 
        suurimmanParilisenIndex = nParillinen - 5;
    }
    else
    {
 
        if (suurimmanParilisenIndex == 1)
        {
            siirrot.push_back(3);
            siirrot.push_back(1);
            siirrot.push_back(3);
            siirrot.push_back(2);
 
            temp1 = luvut[suurimmanParilisenIndex + 4];
            luvut[suurimmanParilisenIndex + 4] = luvut[suurimmanParilisenIndex + 2];
            luvut[suurimmanParilisenIndex + 2] = luvut[suurimmanParilisenIndex];
            luvut[suurimmanParilisenIndex] = temp1;
 
            suurimmanParilisenIndex += 2;
        }
 
        if ((nParillinen - suurimmanParilisenIndex) % 4 == 3)
        {
            siirrot.push_back(suurimmanParilisenIndex + 2);
            siirrot.push_back(suurimmanParilisenIndex);
            siirrot.push_back(suurimmanParilisenIndex + 2);
            siirrot.push_back(suurimmanParilisenIndex + 1);
 
            temp1 = luvut[suurimmanParilisenIndex + 4];
            luvut[suurimmanParilisenIndex + 4] = luvut[suurimmanParilisenIndex + 2];
            luvut[suurimmanParilisenIndex + 2] = luvut[suurimmanParilisenIndex];
            luvut[suurimmanParilisenIndex] = temp1;
 
            suurimmanParilisenIndex += 2;
        }
    }
 
    while (suurimmanParilisenIndex < nParillinen - 1)
    {
        siirrot.push_back(suurimmanParilisenIndex - 2);
        siirrot.push_back(suurimmanParilisenIndex);
        siirrot.push_back(suurimmanParilisenIndex - 2);
        siirrot.push_back(suurimmanParilisenIndex - 1);
 
        temp1 = luvut[suurimmanParilisenIndex];
        luvut[suurimmanParilisenIndex] = luvut[suurimmanParilisenIndex + 2];
        luvut[suurimmanParilisenIndex + 2] = luvut[suurimmanParilisenIndex + 4];
        luvut[suurimmanParilisenIndex + 4] = temp1;
 
        suurimmanParilisenIndex += 4;
    }
 
    /*for (int k = 0; k < n; k++)
    {
        cout << luvut[k] << " ";
    }
    cout << "\n";*/
 
    // Siirrä 7...n-2
    int nykyinenIndex = -1;
    int haluttuIndex;
    for (int nykyinen = n - 2; nykyinen >= 5; nykyinen--)
    {
        haluttuIndex = nykyinen - 1;
        for (int i = (nykyinen + 1) & 1; i <= haluttuIndex; i += 2)
        {
            if (luvut[i] == nykyinen)
            {
                nykyinenIndex = i;
                break;
            }
        }
 
        int korjaus = nykyinenIndex < 2 ? 0 : 2;
        while (nykyinenIndex < haluttuIndex)
        {
            siirrot.push_back(nykyinenIndex + 2 - korjaus);
            siirrot.push_back(nykyinenIndex - korjaus);
            siirrot.push_back(nykyinenIndex + 2 - korjaus);
            siirrot.push_back(nykyinenIndex + 1 - korjaus);
 
            temp1 = luvut[nykyinenIndex + 4 - korjaus];
            luvut[nykyinenIndex + 4 - korjaus] = luvut[nykyinenIndex + 2 - korjaus];
            luvut[nykyinenIndex + 2 - korjaus] = luvut[nykyinenIndex - korjaus];
            luvut[nykyinenIndex - korjaus] = temp1;
 
            nykyinenIndex += 2;
            korjaus = 2;
            // for (int k = 0; k < n; k++)
            // {
            //     cout << luvut[k] << " ";
            // }
            // cout << "\n";
        }
    }
 
    if (luvut[0] != 1 || luvut[1] != 2 || luvut[2] != 3 || luvut[3] != 4)
    {
        cout << "NO";
        return;
    }
 
    cout << "YES\n"
         << siirrot.size() << "\n";
    for (int siirto : siirrot)
    {
 
        cout << (siirto + 1) << " ";
        if (siirto <= -1 || siirto + 5 > n)
        {
            throw std::invalid_argument("VIRHE!!!");
        }
    }
 
    /**/
}
 
void generoiSyote(int n, int data[], auto r)
{
    int parillisia = n / 2;
    int parittomia = (n + 1) / 2;
    int parilliset[parillisia];
    int parittomat[parittomia];
    for (int i = 0; i < parillisia; i++)
    {
        parilliset[i] = (i + 1) * 2;
    }
    for (int i = 0; i < parittomia; i++)
    {
        parittomat[i] = i * 2 + 1;
    }
 
    shuffle(parilliset, parilliset + parillisia, r);
    shuffle(parittomat, parittomat + parittomia, r);
 
    for (int i = 0; i < parillisia; i++)
    {
        data[2 * i + 1] = parilliset[i];
    }
    for (int i = 0; i < parittomia; i++)
    {
        data[2 * i] = parittomat[i];
    }
}
 
void tee(int n, int k, int luvut[])
{
 
    if (k == 2)
    {
        k2(n, luvut);
    }
    else if (k == 3)
    {
        k3(n, luvut);
    }
    else if (k == 4)
    {
        k4(n, luvut);
    }
    else if (k == 5)
    {
        k5(n, luvut);
    }
}
 
int main()
{
    ios_base::sync_with_stdio(true);
    cin.tie(nullptr);
 
    if (true)
    {
        auto r = default_random_engine(0);
        for (int i = 0; i < 25000; i++)
        {
            int n = (rand() % 3) + 5;
 
            int data[n];
            generoiSyote(n, data, r);
 
            for (int k : data)
            {
                cout << k << " ";
            }
            cout << "\n";
            tee(n, 5, data);
            cout << "\n\n\n";
        }
    }
    else
    {
 
        int n, k;
        cin >> n >> k;
 
        int luvut[n];
 
        for (int i = 0; i < n; i++)
        {
            cin >> luvut[i];
        }
 
        tee(n, k, luvut);
    }
 
    return 0;
}