Es a tempo 8

#include <iostream>

using namespace std;

struct nodo {
    int info;
    nodo*next;

    nodo(int a=0, nodo*b=0) {
        info=a;
        next=b;
    }
};

nodo *buildL(int k) {
    if(!k)
        return 0;

    int x;
    cin>>x;
    return new nodo(x,buildL(k-1));
}

void leggiA(int*A,int k) {
    for(int i=0; i<k; i++)
        cin>>A[i];
}

nodo* clone(nodo*L) {
    if(!L)
        return 0;

    return new nodo(L->info,clone(L->next));
}

void stampa(nodo*L) {
    if(!L)
        cout<<endl;
    else {
        cout<<L->info<<' ';
        stampa(L->next);
    }
}


void concat(nodo*& L1, nodo* L2){

    if(!L1){
        L1 = L2;
    }
    else{
        concat(L1-> next, L2);
    }
}

nodo* remove(nodo* &L, int dim) {
    if(!dim){
        return NULL;
    }

    if(!L){
        return NULL;
    }

    nodo* Remove = L;
    L = L-> next;
    Remove->next = remove(L, dim - 1);
    return Remove;
}

/* PRE=(lista(L), lista(L1), e lista(L2) sono ben formate, A contiene dimA elementi non negativi,
    con dimA pari >=0, vL=lista(L),vL1=lista(L1),vL2=lista(L2)) */
void Fric(nodo*L, int*A, int dimA, nodo*&L1, nodo*&L2) {
    // pari --> L1, dispari --> L2

    if(!L){
        return;
    }

    if(!dimA) {
        concat(L1, L);
        return;
    }

    nodo *Concat = remove(L, *A);
    concat(L1, Concat);

    Concat = remove(L, *(A + 1));

    concat(L2, Concat);

    Fric(L, A + 2, dimA - 2, L1, L2);
}
/* POST=(i nodi di vL sono distribuiti correttamente su 2 liste X1 e X2 secondo i valori di A e L1=vL1@X1 e
L2=vL2@X2) */

/*

    Caso base 1:
            Se !L allora non ci sono più nodi, quindi è giusto smettere di fare ricorsione, in quanto la lista è finita
    Caso base 2:
            Se dimA == 0 allora è finito l'array e quindi non posso più andare oltre con gli inserimenti quindi è giusto fare un return

    Altrimenti metto nella variabile Concat la parte di lista da concatenare e successivamente la concateno alla lista L1 o L2. Alla fine ottengo che:
        L è una lista ben formata in quanto l'ultimo nodo ha il campo nexy che punta sempre a 0
        L1 è una lista ben formata in quanto remove crea solo liste ben formate e queste vengono aggiunte in coda alla lista L1 già presente
        mantenendola quindi ben formata. Un ragionamento analogo si può fare per L2
        A contiene dimA non negativi (dalla PRE) in quanto non viene mai modificato
        dimA è sempre pari in quanto viene sottratto sempre 2 e sempre positivo in quanto se fosse 0 si rientrerebbe in un caso base

        quindi pre_ric è rispettata.
        Per ipotesi induttiva assumo che sia verificata anche la post_ric

        Se post_ric è verificata si ha che nell'ultimo caso L1 = vL1@X1 e quindi L1 contiene i valori richiesti e vale altrettanto per L2
        Quindi post è rispettata

*/

main() {
  cout<<"start"<<endl;

  int n, dimA;
  cin >> n >> dimA;
  int*A=new int[dimA];
  nodo*L=buildL(n);
  stampa(L);
  leggiA(A,dimA);

  nodo*L1=0,*L2=0;
  Fric(L,A,dimA,L1,L2);
  stampa(L1);
  stampa(L2);

  cout<<"end"<<endl;
}