Algo difícil

[[duilioisola]]

Se me ocurre que hagas una matriz de cantidad(A) x cantidad(B). En mi anterior ejemplo 5x3.
Luego vas haciendo parejas según los cruces en la matriz y los vas recorriendo diagonamente.
(Se recorren diagonalmente, porque si el A1 juega con B1, A1 no puede jugar con nadie mas esa jornada)

Eemplo visual

Lista 1 (1,2,3,4,5)
Lista 2 (A,B,C)

  12345
A \
B  \
C   \
A1, B2, C3

  12345
A    \
B     \
C \
A4, B5, C1

  12345
A  \
B   \
C    \
A2, B3, C4

  12345
A     \
B  \
C   \
A5, B1, C2

etc.

La idea es que elijas el primer y saltes uno a la derecha y uno abajo para elegir el siguiente.
Si te pasas de longitud, en una de las dos direcciones vuelves al primer elemnto.

Código Delphi [-]
maxx=5
maxy=3
siguiente(x,y)
begin
   x=x+1
   y=y+1
   if (x>maxx) x=1
   if (yZmaxy) y=1
end

Al final tendrás las 15 parejas, pero debes tener en cuenta que n (la cantidad de estadios de futbol) no puede ser mayor que la cantidad de equipos en la lista más pequeña.
De lo contrario, según el ejemplo anterior algún equipo deberá jugar dos veces ese día:
A1,B2,C3,¡¡¡A4!!!

También tendrás que tener en cuenta que para que un equipo no descanse más de dos jornadas, deberá haber un número mínimo de campos.
En el ejemplo de 3x5 n debe ser >=2

[fidel]

Si en 1ª hay 5 equipos, en 2ª hay 3 equipos, y hay 2 campos, un equipo de primera tiene obligatoriamente que descansar 2 jornadas seguidas.

Podrías hacer esto

Ejemplo
Equipos primera: 1 2 3
Equipos segunda: A B C

Tabla PARTIDOS con dos campos: LOCAL, VISITANTE.
Calculas el número de partidos (en el ejemplo 3 x 3 = 9)
Añades 9 registros
Pones como local los 3 equipos de primera hasta llenar los 9 registros.

LOCAL
1
2
3
1
2
3
1
2
3

Otra tabla PROVISIONAL con 9 registros y la llenas con los equipos de segunda repitiéndolos las veces que haga falta

A
B
C
A
B
C
A
B
C

Ahora tendrías que ir cogiendo el primer equipo de la tabla provisional y ponerle como visitante en la tabla PARTIDOS y borrarle.
Coger de nuevo el primero (será otro) y ponerle de visitante en el siguiente registro y después borrarle. Esto habiendo controlado antes que esa pareja no esta ya hecha, en cuyo caso en vez del primero se coge el siguiente hasta que sea valido para no repetir pareja, cuando sea válido se coloca y se borra.
De nuevo se coge el primero el primero, etc, etc hasta que quede vacía la talbla provisional y completados los partidos.

quedaría así

LOCAL VISITANTE
1 A
2 B
3 C
1 B
2 A
3 A
1 C
2 C
3 B

Ahora ir cogiendo por orden para cada jornada, controlando que no entre un equipo repetido en la misma jornada

Si hay dos campos quedaría

joranda 1ª ... 1 A y 2 B
joranda 2ª ... 3 C y 1 B
joranda 3ª ... 2 A y 1 C
joranda 4ª ... 3 A y 2 C
joranda 5ª ... 3 B

pero ahora que he acabado veo que tampoco funciona bien pues el B y el 1 han estado dos jornadas descansando.
Mira a ver si puedes depurarlo y que funcione bien.

[Rioja72]

Muchas gracias, voy a coger la idea de los dos (duilioisola, fidel), aquí no tengo compilador para poder probarlo ahora mismo.
Crearé una matriz para los partidos de dos dimensiones que se irán marcando conforme se juegue. Para cada jornada recorreré la matriz en diagonales, por otra parte tendré dos listas ordenadas con el nº de veces que ha descansado cada equipo e iré cogiendo los primeros que aparezcan en esas listas y así hasta que quede completada la matriz. Creo que de esta forma no será necesario implementar un "vuelta atrás", que sinceramente, para este caso no sabría ni por donde empezarlo.

[ecfisa]

Hola Rioja72.

Para sumar alguna idea te pongo un código que hasta donde probé funciona.
Dados los datos, genera todas las combinaciones posibles, aunque no necesariamente en el órden que mostras en tu ejemplo.
La cantidad de elementos de las listas, así como el número de elementos por grupos se ajustan con tres SpinEdits.
Te quedaría probarlo más a fondo y ver si te puede servir. (o al menos espero que te aporte alguna idea)

Código Delphi [-]
type
  TForm1 = class(TForm)
    Label1: TLabel;
    Label2: TLabel;
    Label3: TLabel;
    SpinEditLstA: TSpinEdit; 
    SpinEditLstB: TSpinEdit; 
    SpinEditNGrp: TSpinEdit;
    StringGrid1: TStringGrid;
    btMostrar: TButton;
    procedure FormShow(Sender: TObject);
    procedure btMostrarClick(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);    
  private
    MAXLSTA, MAXLSTB: Integer;
    FGrupoA, FGrupoB, FParejas: Tstrings;
    procedure Inicializar;
    procedure Mostrar(NElem: Integer);
  public
  end;

var
 Form1: TForm1;

implementation {$R *.dfm}

procedure TForm1.FormShow(Sender: TObject);
begin
  // Crear Listas;
  FGrupoA:= TStringList.Create;
  FGrupoB:= TStringList.Create;
  FParejas:= TStringList.Create;
end;

procedure TForm1.Inicializar;
var
  c,f,x: Integer;
begin
  // Vaciar listas
  FGrupoA.Clear;
  FGrupoB.Clear;
  FParejas.Clear;
  // Ajustar base 0
  MAXLSTA:= SpinEditLstA.Value-1;
  MAXLSTB:= SpinEditLstB.Value-1;
  // Inicializar valores
  for x:= 0 to MAXLSTA do
    FGrupoA.Add('A'+IntToStr(x+1));
  for x:= 0 to MAXLSTB do
    FGrupoB.Add('B'+IntToStr(x+1));
  // Hacer los pares
  for f:= 0 to MAXLSTA do
  begin
    x:= f;
    for c:= 0 to MAXLSTB  do
    begin
      if x < MAXLSTA then
        Inc(x)
      else
        x:= 0;
      FParejas.Add(FGrupoA[x]+' '+FGrupoB[c]);
    end;
  end;
end;

procedure TForm1.Mostrar(NElem: Integer);
var
  i,j,NGrp,ix: Integer;
begin
  // Inicializar valores
  Inicializar; 
  // Limpiar StringGrid
  for i:= 0 to 10 do
    for j:= 0 to 10 do
      StringGrid1.Cells[i,j]:= '';
  // Obtener Nro de grupos
  NGrp:= (FParejas.Count) div NElem;
  for ix:= 1 to NGrp do
    StringGrid1.Cells[ix,0]:= 'Grupo '+IntToStr(ix);
  // Distribuir parejas
  ix:= 0;
  for i:= 1 to NGrp do
   for j:= 1 to NElem do
   begin
     StringGrid1.Cells[i,j]:= FParejas[ix];
     Inc(ix);
   end;
   // Si sobran elementos, agregar parejas faltantes
  ix:= FParejas.Count-(NGrp*NElem);
  if ix > 0 then
  begin
    StringGrid1.Cells[NGrp+1,0]:= 'Grupo ' + IntToStr(NGrp+1);
    for i:= 0 to ix - 1 do
      StringGrid1.Cells[NGrp+1, i+1]:= FParejas[FParejas.Count-ix+i];
  end;
end;

procedure TForm1.btMostrarClick(Sender: TObject);
begin
  Mostrar(SpinEditNGrp.Value);
end;

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  // Liberar TStrings
  FGrupoA.Free;
  FGrupoB.Free;
  FParejas.Free;
end;
end.

Saludos.

[Rioja72]

¡¡¡ qué pasada !!!, muchas gracias, claro que sirve de ayuda, me basaré ya en este código para continuar y depurarlo. Hay que decir que descansan más de una jornada y hay que ajustar la rejilla (grilla) para ver todos los resultados. Sigo dándole vueltas y me parece que del "vuelta atrás (backtracking)" no me salva nadie.

De nuevo, muchas gracias por tu interés.