#include <stdio.h>
#include <string.h>

void Compact(int i, int j, int nTuples, char newName[]);
void Swap(int i, int j);
void PrintRelData();

#define MAXRELS 10

int nRels;
int nAttrs;
int T[MAXRELS];
char name[MAXRELS][1000];    // Name of relation
                             // Initially: R, S, T, U
                             // Can change to: R |X| S, etc

int nData;
int V[MAXRELS][5];

char rel = 'R';
char attr = 'a';

double Cost[MAXRELS][MAXRELS];


int main(int argc, char *argv[])
{
   int i, j, k;
   char a, b;

   /* ================================
      Read # relations and T(R) data
      ================================ */
   scanf("%d %d\n", &nRels, &nAttrs);
   printf("# relations = %d, # attributes = %d\n", nRels, nAttrs);

   for ( k = 0; k < nRels; k++ )
   {
      scanf("%c", &a);
//    printf("%c --- ", a);
      scanf("%d\n", &T[a-rel]);

      name[k][0] = a;
      name[k][1] = '\0';

      printf("T(%s) = %d\n", name[k], T[a-rel]);
   }


   /* ====================================
      Read # data points and V(R,a) data
      ==================================== */
   scanf("%d\n", &nData);
   printf("# input data = %d\n", nData);

   for ( i = 0; i < nRels; i++ )
      for ( j = 0; j < nRels; j++ )
         V[i][j] = -1;

   for ( k = 0; k < nData; k++ )
   {
      scanf("%c %c", &a, &b);
//    printf("%c %c --- ", a, b);
      scanf("%d\n", &V[a-rel][b-attr]);

      printf("V(%c,%c) = %d\n", a, b, V[a-rel][b-attr]);
   }

   /* =============================
      Join 2
      ============================= */
   int bestI, bestJ;

   double bestCost = 999999999;
   putchar('\n');

   for ( i = 0; i < nRels; i++ )
   {
      for ( j = i; j < nRels; j++ )
      {
	 if ( i == j )  continue;

         double max = 1;

         for ( k = 0; k < nAttrs; k++ )
         {
            if ( V[i][k] > 0 && V[j][k] > 0 )
	       max = ( V[i][k] > V[j][k] ) ? V[i][k] : V[j][k] ;
         }

	 Cost[i][j] = T[i]*T[j]/max;
      
         printf("Cost %s|X|%s = %7.2lf", 
				name[i], name[j], Cost[i][j]);

	 if ( Cost[i][j] < bestCost )
	 {
	    bestCost = Cost[i][j];
	    bestI = i;
	    bestJ = j;
            printf("  +++++\n");
         }
	 else
         {
            printf("\n");
         }
      }
   }

   char newName[100];

   if ( T[bestI] <= T[bestJ] )
   {
      sprintf(newName, "(%s|X|%s)", name[bestI], name[bestJ]);
   }
   else
   {
      sprintf(newName, "(%s|X|%s)", name[bestJ], name[bestI]);
   }

   printf("(1) ====> %s\n\n\n", newName);

   Compact(bestI, bestJ, bestCost, newName);   // Compact and repeat
// PrintRelData();

   Swap(0, bestI);
// PrintRelData();

   printf("\n************************************************\n\n");

   i = 0;            // We also join with Rel[0] from now on

   while ( nRels >= 2 )
   {
      bestCost = 999999999;

      for ( j = 1; j < nRels; j++ )
      {
         for ( k = 0; k < nAttrs; k++ )
         {
            if ( V[i][k] > 0 && V[j][k] > 0 )
            {
               double max = 1;

               if ( V[i][k] > 0 && V[j][k] )
                  max = ( V[i][k] > V[j][k] ) ? V[i][k] : V[j][k] ;

               Cost[i][j] = T[i]*T[j]/max;

               printf("Cost %s|X|%s = %7.2lf",
                                name[i], name[j], Cost[i][j]);

               if ( Cost[i][j] < bestCost )
               {
                  bestCost = Cost[i][j];
                  bestI = i;
                  bestJ = j;
                     printf("  +++++\n");
               }
               else
               {
                  printf("\n");
               }
            }
         }
      }

      sprintf(newName, "(%s|X|%s)", name[bestI], name[bestJ]);


      Compact(bestI, bestJ, bestCost, newName);   // Compact and repeat
//    PrintRelData();

      printf("====> %s\n\n\n", newName);

      printf("\n********************************************\n\n");
   }


}



void Compact(int i, int j, int nTuples, char newName[])
{
   int k;

   if ( i > j )
   {
      k = i; i = j; j = k;       // Swap i, j 
   }

   printf("*** Consolidate %s into %s\n", name[j], name[i]);

   /* ===================
      i < j
      =================== */ 
   T[i] = nTuples;
   strcpy( name[i], newName );

   /* ==================================
      Preserve the # attribute values
      ================================== */ 
   for ( k = 0; k < nAttrs; k++ )
   {
      if ( V[j][k] > 0 )
      {
         V[i][k] = V[j][k];
         printf("+++ V[%s][%c] = %d\n", name[i], k+attr, V[j][k]);
      }
      else
         printf("    V[%s][%c] = %d\n", name[i], k+attr, V[j][k]);
   }

   /* ==================================
      Shift relations j+1, ... down
      ================================== */
   for ( j = j; j < nRels-1; j++ )
   {
      strcpy( name[j], name[j+1]);

      for ( k = 0; k < nAttrs; k++ )
      {
         V[j][k] = V[j+1][k];
      }
   }

   nRels--;
}



void Swap(int i, int j)
{
   int h, k;
   char hname[100];

   printf("*** Swap data of %s and %s\n", name[i], name[j]);

   h = T[i]; T[i] = T[j]; T[j] = h;

   strcpy( hname, name[i] );
   strcpy( name[i], name[j] );
   strcpy( name[j], hname );

   for ( k = 0; k < nAttrs; k++ )
   {
      h = V[i][k];
      V[i][k] = V[j][k];
      V[j][k] = h;
   }
}






void PrintRelData()
{
   int i, j;

   printf("vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv\n");
   printf("Relation data:\n");

   for (i = 0; i < nRels; i++)
      printf("T(%s) = %d\n", name[i], T[i]);

   printf("=========================================\n");

   for (i = 0; i < nRels; i++)
      for (j = 0; j < nAttrs; j++)
         printf("V(%s,%c) = %d\n", name[i], j+attr, V[i][j]);

   printf("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\n");
}