CS302 -- Lab 4 -- Enumeration

• CS302 -- Data Structures and Algorithms II
• James S. Plank
• This file: http://web.eecs.utk.edu/~jplank/plank/classes/cs302/Labs/Lab4
• Lab Directory: /home/jplank/cs302/Labs/Lab4

What you hand in

UNIX> g++ -Wall -Wextra -std=c++11 -o matrix_enum matrix_enum.cpp

Introduction, and your enumerations

Part of this research was performing enumerations of square matrices. The elements in the matrices can be any of three characters: '.', 'X' and 'E'. The enumeration is parameterized by two values:

• W (which stands for the "word size") is the number of rows in the matrices. It is also the number of columns, because the matrices are square.
• E (which stands for "extra non-zero entries") is a number between 0 and W²-W.

• There are exactly W elements with X's. There must be an 'X' in every row and every column. (BTW, this is called a Permutation Matrix).
• There are exactly E elements that have E's in them, and they can't be where the X's are.
• The remaining W²-W-E elements contain '.'.

Your job is to write a program called matrix_enum, which takes three command line arguments: W, E and either an 'x' or an 'h'. Your program will enumerate all of the matrices for W and E, in any order you want, and print them out in one of the following two formats:

• If the last argument is 'x', then you'll print the matrices out in the format above. You should print each matrix as W lines of W characters that are '.', 'X' or 'E'. After each matrix, you print a blank line.
• If the last argument is 'h', then you'll convert each line of each matrix into an integer, and print that integer in hexadecimal, with no leading 0's and no leading "0x". If element i in a row is 'X' or 'E', then you'll set the i-th bit of the number to 1. Otherwise, the i-th bit is zero. You'll print each integer on its own line, and print a blank line at the end of each matrix.

UNIX> matrix_enum 2 0 x
X.
.X

.X
X.

UNIX>

UNIX> matrix_enum 2 1 x
XE
.X

X.
EX

EX
X.

.X
XE

UNIX>

UNIX> matrix_enum 2 2 x
XE
EX

EX
XE

UNIX>

UNIX> matrix_enum 2 0 h
1
2

2
1

UNIX>

UNIX> matrix_enum 2 1 h
3
2

1
3

3
1

2
3

UNIX>

UNIX> matrix_enum 2 2 h
3
3

3
3

UNIX>

Approach

.X.
..X
X..

At the second level, you have W²-W potential locations for the 'E' characters. Thus, this is an "n choose k" where n is equal to W²-W and k is equal to E. Implement this using the recursive technique specified in the Enumeration lecture notes, in the section entitled "Using Recursion to Perform an "n choose k" Enumeration."

When I did this, I created a vector out of the non-'X' matrix elements. I stored these as numbers: (row * W + column). I then enumerated all ways to choose E of these, using the same technique as in the lecture notes. Continuing the example above, suppose W equals three, and my permutation matrix is (1,2,0). Then the potential spots for 'E' elements are the following (again, using (row * W + column)):

Here is my main class definition. You don't need to use this, but you may find it useful:

class Matrix {
  public:
    int W;
    int E;
    int P;                      /* This is 'x' or 'h' */
    vector <int> Perm;          /* Permutation of 0 .. (W-1), for the 'X' elements. */
    vector <int> Non_X;         /* This is the row/col id of each of the non-X elements. */
    vector <int> E_ID;          /* This is the row/col id of the E elements */
    void Print();               /* Print the matrix defined by W, Perm and E_ID */
    void Permute(int index);    /* This is the recursive permuting method. */
    void Choose(int index);     /* This is the recursive n-choose-k method. */
};

The Gradescript

UNIX> matrix_enum 2 1 x | flatten_for_grading | sort
.X XE
EX X.
X. EX
XE .X
UNIX> matrix_enum 2 1 h | flatten_for_grading | sort
1 3
2 3
3 1
3 2
UNIX> 

The second technique is to use the program double_check. This takes W, E, and h|x on the command line and then accepts input of your program piped through flatten_for_grading. It then checks every line of input t to see if it is legal for those parameters. This means that for 'x':

• Lines have the proper number of characters and are in the proper format.
• Each row has exactly one 'X' in a different column.
• The number of 'E' and '.' characters is correct.
• Lines are unique.

So double_check will allow you to specify (3,3,4) twice, but not three times.

The double_check program prints nothing if its input is legal. If you have a problem, it prints an error message on standard output. For example, here's what happens if you specify (3,3,4) three times in the above example:

UNIX> double_check 3 2 h
3 3 4
3 3 4
3 3 4
Bad line 3: Too many lines (3) with these values.
Here are the matrices that correspond to these values:
EX. XE. ..X
XE. EX. ..X
UNIX> 

To help you manage your expectations -- the following table contains how long the gradescripts took on my programs (seconds). Most of this time is in double_check, by the way -- please see this Piazza question and answer for more detail on why gradescript 81 takes so long.