Usa las etiquetas de Código GeSHi para destacar los fragmentos de código...

Para lo que quieres hacer puedes por ejemplo copiar los caracteres que tú quieras:

string original = "cadena original";
string resultado;
for(size_t i = primer_caracter_a_copiar; i < total_a_copiar; ++i)
    resultado.push_back(original[i]); 

Tienes otras formas de hacerlo seguramente pero esta es una de ellas bastante simple de entender y sin usar funciones extrañas de esas que nadie sabe que existen.

Por ejemplo en C o si trabajas con <char*> lo que puedes hacer es mover el puntero de inicio y colocar el '\0' donde quieras acabar.

char original[] = "cadena original";
char *resultado = original;
resultado += primer_caracter_a_copiar;
resultado[total_a_copiar] = '\0'; 

Si tienes alguna duda sobre algo ya sabes que puedes preguntar y por favor usa las etiquetas para los códigos.

El programa parece que funciona correctamente...
Si tu problema es que no se vuelve a mostrar lo de "Ingrese una opcion\n" es porque se encuentra fuera del <do while>. Si no te refieres a eso, manda la salida de tu programa y especifica cuál es el problema ya que yo al menos no lo encuentro 

Ayudarte podemos ayudarte, en cambio; hacerte el trabajo, no.
Si tienes problemas con una parte en concreto especifica esa parte y coloca lo que llevas traducido para poder ayudarte de la forma más similar posible.
Y los códigos entre etiquetas de Código GeSHi...

El problema lo tienes después de la primera iteración con las variables <resultados> y <goles> y eso es porque no puedes usar el índice <j> para controlar esos arrays ya que no coinciden los valores. Los arrays siempre son {0,1,2} y si usas el índice <j>; en la primera iteración estás usando correctamente {0,1,2} pero en la segunda estás usando {1,2,3} por lo que el índice 0 tiene basura y estás accediendo al 3 que está fuera del array.

En google habrá muchos ejemplos de permutaciones en C.
Y para controlar la condición de que A debe ir antes que D, calcula todas las permutaciones y haz una función que compruebe si eso se cumple o no y utiliza solo las permutaciones que lo cumplan.

Pues hombre si te pide que hagas algo (determinar el salario) en base a unas condiciones y no sabemos cuáles son pues no sabemos qué datos necesitas almacenar y cuáles aparecen solo por hacer el ejercicio más "realista".

Pero si tienes que guardar todo eso pues por ejemplo puedes crear un <struct Recolector> y hacer un array de <Recolector> pero en vez de hacerlo de 20, pregunta primero cuántos recolectores están trabajando y crear el array de forma dinámica. Y si te piden que uses memoria dinámica puedes crear todos los arrays de esa forma aunque sea posible hacerlo de forma estática.

Con esa solución que dices que has encontrado lo que haces es que el puntero <nombre> apunte a la misma cadena constante que apunta <arreglo>. Con esto ahorras reservas de memoria pero no estás "haciendo copias" del nombre, lo que estás haciendo es que los punteros apunten al mismo sitio.

Si lo quieres hacer con memoria dinámica tendrías que reservar memoria y cambiar las líneas 20-22 (que están haciendo que el puntero apunte al nombre) por <strncpy()> para copiar literalmente el contenido del <string> en el nuevo array dinámico que has creado.

En ningún momento estás reservando memoria para <nombre> de ninguna instancia de la struct <s_alumno>. Lo único que haces en el <main> es hacer que el puntero a <nombre> apunte a una cadena literal que se encuentra en otra zona de memoria. Por lo tanto no puedes usar <strcpy()> ya que estás intentando copiar datos en una zona no permitida de memoria.

PD: Se agradecen nombres de variables más significativos que ayuden a seguir el programa con facilidad.

Si creas un arreglo dinámico en algún sitio estás calculando el tamaño que debe tener... guarda esa longitud. En tu caso que vas incrementando en 1 el tamaño con <realloc()>, al final puedes saber también cuál es esa longitud. Mantenla de alguna forma (retorno o referencia). Para ello te recomendaría que la función reciba el nuevo array por referencia y devuelva la longitud de este como valor de retorno:

int CARGA(t_alumno arreglo1[], t_alumno arreglo2[], t_alumno *nuevo_arreglo[]); 

El tamaño de la primera dimensión de un array no es necesario pasarlo a la función. También puedes hacerlo al revés:

t_alumno* CARGA(t_alumno arreglo1[], t_alumno arreglo2[], int *longitud_final); 

No he mirado el resto del programa pero te puedo adelantar que la línea 108 no es correcta. Un array no acaba cuando el siguiente elemento apunta a NULL, básicamente porque no apunta a NULL. Cuando pasas un array debes pasar su longitud en otro parámetro para saber hasta donde recorrerlo.