### Problem 1:

```Lost points codes:

1.1	SAFCG 	Checked for the goal after when the node was added
instead of when the node was expanded -4
1.7	SAFCFG	Forgot F has a child A

Branch & Bound -

1.2	SACFDHFG did not use dynamic programming
1.6	SAFCDC	 Out of order but using dynamic programming

Greedy
1.8	SACDG	Use best h(n) not the arc distance

A*
1.3	SACG 	did not expand in alphabetical order
1.5	SAFCDG	Included child nodes in the decision before adding to the queue

Hill Climbing
1.4	SACG	Moved to A first instead of F
```

### Problem 2:

``` 2.1 Net
Wrong means if the greedy search does output optimal PATH (not
EXPANED nodes).

2.2 Greedy Search
This problem depends on the the net provided in previous question.

2.3 Path
Greedy search does generate optimal path;
Assert path = EXPANDED nodes;
Assert optimal path = shortest path.
```

### Problem 3:

``` 3.1 Min_Max
Just show choice but no explanation;
Choice is wrong but some value are assigned correctly;
Choice is correct but few value mistakes.

3.2 A-B Pruning
Miss-skip specific node(s);
Miss-skip a specific branch;
Skip node(s) that should be evaluated;
```

### Problem 5:

Note 5.1a:

The off-diagonal matrix elements should be zero, because “there are binary constraints between each two persons denoting the fact that the time scheduled for the meeting must be the same one for all persons.”  This is equivalent to a “binary equals” constraint between every pair of people.

Note 5.1b:

Each element of a matrix should represent a value pair, that is, an assignment of values to each of the two variables.  Therefore, each binary constraint matrix should be a 4 x 4 matrix, because there are 4 values, and 16 possible value pairs.

Note 5.1c:

You need to show the constraint net, with nodes, edges, and labels.  There should be 3 nodes (labeled Bill, Ann, and Paul), and 3 edges.  (It’s a fully connected net of 3 nodes.)

Note 5.1d:

You need to have 3 binary constraint matrices:  one for Bill-Ann, one for Bill-Paul, and one for Ann-Paul.

Note 5.1e:

You need to represent the unary constraints in the binary constraint matrices.  Just 1’s on all the diagonals would mean that the only constraint is that they all meet at the same time, but they could meet at any time.

Note 5.2a:

What you describe is simply the representation of the constraints in the binary constraint matrices.  Arc consistency checking takes place after the constraints have been represented in the matrices, and can let you remove values from the domain of a variable even if there were no given constraints that would preclude using that value.  (OR)  You describe values being removed from the domain of the variables, but don’t say why or how.  (OR)  You described a method of arc consistency checking that will not result in a fully consistent set of matrices, e.g. you make consistency updates, but don’t check them for consistency again.

Note 5.2b:

You need to provide a solution to the CSP.  The solution is 10am on Wednesday.

Note 5.2c:

What you describe is the search through the constraint net for a solution.  Arc consistency checking takes place before the search begins.  Immediately after the constraints have been entered into the BCMs, the BCMs themselves might be in a state that is inconsistent with each other.  The arc consistency checking resolves this problem.

It’s an understandable error because there is consistency checking during the search, but it is the consistency of variable assignments, not constraint matrices.  However, the difference is very important.  If you discover an inconsistency of variable assignments during the search, you simply backtrack and make different assignments.  You do NOT reduce the domain of the variables, because the assignment may be consistent with some other combination of assignments for all other variables.  This is very different from arc consistency checking, where you are oscillating between reducing the domain of variables, and reflecting the reductions in the BCMs.

Note 5.2d:

You need to describe how you chose the ordering of the variables (NOT values, and not BCMs).  This is the order that the variables are assigned values (visited).  In particular, the ordering of variables based on how constrained each variable is, and you first choose the variable that is most constrained, and each consecutive variable is the most constrained of the unassigned variables.

.