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

typedef unsigned uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<pii> vpii;
typedef complex<double> cpx;
template <typename T> using minPq = priority_queue<T, vector<T>, greater<T>>;
#define ms(a, x) memset(a, x, sizeof(a))
#define pb push_back
#define fs first
#define sn second
#define ALL(v) begin(v), end(v)
#define SZ(v) ((int) (v).size())
#define lbv(v, x) (lower_bound(ALL(v), x) - (v).begin())
#define ubv(v, x) (upper_bound(ALL(v), x) - (v).begin())
template <typename T> inline void UNIQUE(vector<T> &v){sort(ALL(v)); v.resize(unique(ALL(v)) - v.begin());}
const int INF = 0x3f3f3f3f;
const ll LLINF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
#define FR(i, n) for(int i = 0; i < (n); i++)
#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define FORR(i, a, b) for(int i = (a); i >= (b); i--)
#define dbg(x) {cerr << #x << ' ' << x << endl;}
#define dbgArr(arr, n) {cerr << #arr; FR(_i, n) cerr << ' ' << (arr)[_i]; cerr << endl;}
template <typename T, typename U>
ostream& operator<<(ostream &os, pair<T, U> p){return os << "(" << p.fs << ", " << p.sn << ")";}

const int MN = 2e5 + 5;
int n, lim;
int arr[MN];
pii sorted[MN];
int nxt[MN], prv[MN];

vi groups[MN];
int gi;
int id[MN];

void genGroup(int src){
    int n1 = src;
    while(!id[n1]){
        id[n1] = gi;
        groups[gi].pb(n1);
        n1 = nxt[n1];
    }
    gi++;
}

int main(){
    cin.sync_with_stdio(0); cin.tie(0);
    cin >> n >> lim;
    FR(i, n) cin >> arr[i], sorted[i] = {arr[i], i};
    sort(sorted, sorted+n);
    FR(i, n) nxt[sorted[i].sn] = i, prv[i] = sorted[i].sn;
    FR(i, n) if(arr[i] == sorted[i].fs && i != nxt[i]){
        int a = prv[i], b = nxt[i];
        nxt[a] = b, prv[b] = a;
        nxt[i] = prv[i] = i;
    }

    gi = 1;
    FR(i, n) if(!id[i]) genGroup(i);

    map<int, vi> byVal;
    FR(i, n) if(SZ(groups[id[i]]) != 1) byVal[sorted[i].fs].pb(i);

    for(auto [v, vec] : byVal){
        int p1 = vec[0];
        FOR(i, 1, SZ(vec)){
            int p2 = vec[i];
            if(id[p1] == id[p2]) continue;
            int g1 = id[p1], g2 = id[p2];
            if(SZ(groups[g1]) < SZ(groups[g2])) swap(g1, g2);
            if(SZ(groups[g2]) == 1) continue;
            int a = prv[p1], b = prv[p2];
            nxt[a] = p2, nxt[b] = p1;
            prv[p1] = b, prv[p2] = a;
            for(int x : groups[g2]) id[x] = g1, groups[g1].pb(x);
            groups[g2].clear();
        }
    }

    vi bigGroups;
    FR(i, gi) if(SZ(groups[i]) > 1) lim -= SZ(groups[i]), bigGroups.pb(i);
    if(lim < 0) return !printf("-1\n");

    // dbgArr(nxt, n);
    // dbgArr(prv, n);
    // dbgArr(id, n);

    int q = SZ(bigGroups);
    int k = min(lim, SZ(bigGroups));
    if(k >= 3){
        q++;
        q -= k-1;
        vi shuf;
        FR(i, k) shuf.pb(groups[bigGroups.end()[-1-i]][0]);
        cout << q << '\n';
        cout << k << '\n';
        FR(i, k) cout << shuf[i]+1 << " \n"[i == k-1];

        vi nxts;
        FR(i, k) nxts.pb(nxt[shuf[i]]);
        FR(i, k){
            int a = shuf[i], b = shuf[(i+1)%k];
            int c = nxts[i], d = nxts[(i+1)%k];
            nxt[b] = c; prv[c] = b;
        }

        vi newGroup;
        FR(i, k){
            vi &vec = groups[bigGroups.end()[-1-i]];
            for(int a : vec) newGroup.pb(a);
            vec.clear();
        }

        FR(i, k-1) bigGroups.pop_back();
        groups[bigGroups.back()] = newGroup;
    }
    else cout << q << '\n';

    // dbgArr(nxt, n);
    // dbgArr(prv, n);

    for(int a : bigGroups){
        vi vec;
        int src = groups[a][0];
        int n1 = src;
        do {
            vec.pb(n1);
            n1 = nxt[n1];
        } while(n1 != src);
        assert(SZ(vec) == SZ(groups[a]));

        cout << SZ(vec) << '\n';
        FR(i, SZ(vec)) cout << vec[i]+1 << " \n"[i == SZ(vec)-1];
    }
}