import java.util.*;

public class Marriage {

  // If menPrefs[i][j] = k, then Ms. k, is ranked j-th in the Mr. i's list.
  static int[][] menPrefs;
  // If womenPrefs[i][j] = k, then Mr. k, is ranked j-th in the Ms. i's list.
  static int[][] womenPrefs;

  // wife[i] = Mr. i's wife. Similarly, husband[j] = Ms. j's husband.
  // These arrays are filled by the algorithm.
  static int[] wife, husband;

  public static void main (String[] argv)
  {
    try {
      if ( (argv == null) || (argv.length != 2) ) {
        System.out.println ("Usage: Marriage <numTrials> <numCouples>");
        System.exit(1);
      }

      int numTrials = Integer.parseInt (argv[0]);
      int numCouples = Integer.parseInt (argv[1]);

      double avgTimeTaken = performTrials (numTrials, numCouples);
      double theoretical = theoreticalTime (numCouples);
      System.out.println ("Actual=" + avgTimeTaken + " theoretical=" + theoretical 
                          + " ratio=" + (avgTimeTaken/theoretical));
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }
  

  static double theoreticalTime (int n)
  {
    return n*n;
  }
  

  static double performTrials (int numTrials, int numCouples)
  {
    // An array that holds the order 0, 1, ..., n-1.
    // This is just used as input to create a random permutation.
    int[] incrOrder = new int [numCouples];
    for (int i=0; i<numCouples; i++)
      incrOrder[i] = i;

    menPrefs = new int [numCouples][];
    womenPrefs = new int [numCouples][];
    for (int i=0; i<numCouples; i++) {
      // Create a random permutation for Mr. i.
      menPrefs[i] =  RandomPermutation.permutePreserve (incrOrder);
      // Create a random permutation for Ms. i.
      womenPrefs[i] =  RandomPermutation.permutePreserve (incrOrder);
    }

    // Create space for wife and husbands.
    wife = new int [numCouples];
    husband = new int [numCouples];

    // We will measure the total time taken over all trials.
    double totalTimeTaken = 0;

    double totalWifeQ = 0,  totalHusbandQ = 0;
    

    // Repeat "numTrials" times:

    for (int n=0; n<numTrials; n++) {

      // Create set of random preferences for men and women.
      for (int i=0; i<numCouples; i++) {
        // Create random prefs.
        RandomPermutation.permute (menPrefs[i]);
        RandomPermutation.permute (womenPrefs[i]);
      }

      // Start timing.
      double startTime = System.currentTimeMillis();

      // Perform matching.
      marry (menPrefs, womenPrefs);

      // Measure time taken.
      double timeTaken = System.currentTimeMillis() - startTime;

      // Accumulate, for average.
      totalTimeTaken += timeTaken;

      // Compute average wifeQuality (average rank of assignment wife).
      double wifeQuality = computeQuality (menPrefs, wife);

      // Compute average husband quality (average rank of assignment husband).
      double husbandQuality = computeQuality (womenPrefs, husband);
      
      // Accumulate totals of each.
      totalWifeQ += wifeQuality;
      totalHusbandQ += husbandQuality;
    }
  
    // Print wife-quality and husband-quality averages over numTrials.
    System.out.println ("Avg wife quality: " + totalWifeQ / numTrials);
    System.out.println ("Avg husband quality: " + totalHusbandQ / numTrials);

    // Return average time taken.
    return totalTimeTaken / numTrials;
  }
  

  static double computeQuality (int[][] prefs, int[] spouse)
  {
    // INSERT YOUR CODE HERE
    // NOTE: Suppose spouse[i]==j. Then, j is i's spouse. Now, 
    // j must lie somewhere in the ranking for i. That is, 
    // there is some k for which prefs[i][k] = j. In other words,
    // j is the k-th preference for i. Thus, "k" is the spousal
    // quality for i. Hint: use the method rank() below.

    // To compute the quality of spouse[i], use 
    //    r = rank (prefs[i], spouse[i])

    // Compute the spousal quality for each i, then the average
    // and return the average.
  }


  static void marry (int[][] menPrefs, int[][] womenPrefs)
  {
    int numCouples = menPrefs.length;

    // Build list of all men, sorted by their ID.
    TreeSet UnmarriedMen = new TreeSet ();
    for (int i=0; i<numCouples; i++) {
      UnmarriedMen.add (new Integer(i));
    }

    // Initially, no pairings:
    for (int i=0; i<numCouples; i++) {
      wife[i] = husband[i] = -1;
    }
    

    // As long as there are unmarried men, find a wife for them.

    while (! UnmarriedMen.isEmpty()) {

      // Extract the first one in the list.
      Integer index = (Integer) UnmarriedMen.first();
      UnmarriedMen.remove (index);
      int i = index.intValue();

      // Now, Mr. i finds a lady.
      for (int j=0; j<numCouples; j++) {

        // Mr. i tries to marry his j-th preference, Ms. k = menPrefs[i][j]
        int k = menPrefs[i][j];

        // Is she married?
        if (husband[k] == -1) {
          // She's available and demurely accepts.
          wife[i] = k;
          husband[k] = i;
          break;
        }
        else if (isPreferable (womenPrefs, k, i, husband[k]) ) {
          // Mr. i is preferred to Ms. k's current husband => it's splitsville for Ms. k.
          int x = husband[k];
          husband[k] = i;
          wife[i] = k;
          // Poor Mr. x goes back to the bachelor list.
          UnmarriedMen.add (new Integer (x));
          break;
        }
        // Else, continue search.

      } // end-for.
      
      // Now Mr. i has a spouse, but may get kicked back to bachelorhood.

    } // endwhile.

    // Now we're done.
    
  }


  // This method checks to see which of potential mates i and j are better
  // for person k.

  static boolean isPreferable (int[][] prefs, int k, int i, int j)
  {
    // Obtain ranks of i and j.
    int rank_i = rank (prefs[k], i);
    int rank_j = rank (prefs[k], j);

    // Compare.
    if (rank_i < rank_j)
      return true;
    else 
      return false;
  }

  

  // Where does person i fall in the preference order given?

  static int rank (int[] prefs, int i)
  {
    // Look in array for rank.
    // NOTE: we can implement this much more efficiently with a pre-computed rank array.
    for (int j=0; j<prefs.length; j++)
      if (prefs[j] == i)
        return j;

    // Error.
    System.out.println ("rank: not found: " + i);
    return -1;
  }
  

}