Question 1
In the box below, type in the minimum cost of a traveling salesman tour for this instance, rounded down to the nearest integer.
OPTIONAL: If you want bigger data sets to play with, check out the TSP instances from around the world here. The smallest data set (Western Sahara) has 29 cities, and most of the data sets are much bigger than that. What’s the largest of these data sets that you’re able to solve — using dynamic programming or, if you like, a completely different method?
25
20833.3333 17100.0000
20900.0000 17066.6667
21300.0000 13016.6667
21600.0000 14150.0000
21600.0000 14966.6667
21600.0000 16500.0000
22183.3333 13133.3333
22583.3333 14300.0000
22683.3333 12716.6667
23616.6667 15866.6667
23700.0000 15933.3333
23883.3333 14533.3333
24166.6667 13250.0000
25149.1667 12365.8333
26133.3333 14500.0000
26150.0000 10550.0000
26283.3333 12766.6667
26433.3333 13433.3333
26550.0000 13850.0000
26733.3333 11683.3333
27026.1111 13051.9444
27096.1111 13415.8333
27153.6111 13203.3333
27166.6667 9833.3333
27233.3333 10450.0000
// MP 5 Scan
// Given a list (lst) of length n
// Output its prefix sum = {lst[0], lst[0] + lst[1], lst[0] + lst[1] + ... + lst[n-1]}
// Due Tuesday, January 22, 2013 at 11:59 p.m. PST
//#include <wb.h>
#include <stdio.h> /* required for file operations */
#include <stdlib.h>
#include <string.h>
#include <math.h>
#define BLOCK_SIZE 512 //@@ You can change this
#define MAX_COST 1000000000
int BitCount(unsigned int u)
{
unsigned int uCount;
uCount = u - ((u >> 1) & 033333333333) - ((u >> 2) & 011111111111);
return ((uCount + (uCount >> 3)) & 030707070707) % 63;
}
int main(int argc, char ** argv) {
int nodeElements; // number of elements in the list
//int n;
int i=0;
double atof ( const char * str );
char line[100]; /* declare a char array */
FILE *file; /* declare a FILE pointer */
file = fopen("tsp.txt", "r"); /* open a text file for reading */
char * pch;
int k;
float * X;
float * Y;
while(fgets(line, sizeof line, file)!=NULL) { /* keep looping until NULL pointer... */
pch = strtok (line," ");
k = 0;
if (i == 0) {
while (pch != NULL){
if (k == 0) {
nodeElements = atoi(pch);
X = (float *) malloc (nodeElements * sizeof(float));
Y = (float *) malloc (nodeElements * sizeof(float));
}
pch = strtok (NULL, " ");
k ++;
}
} else {
float m, n;
m = n = -1;
while (pch != NULL){
if (k == 0) {
m = atof(pch);
}
if (k == 1) {
n = atof(pch);
X[i - 1] = m;
Y[i - 1] = n;
}
pch = strtok (NULL, " ");
k ++;
}
}
i++;
}
float * D = (float *) malloc (nodeElements * nodeElements * sizeof(float));
for (int m = 0; m < nodeElements; m++) {
for (int n = 0; n < nodeElements; n++) {
float dx = X[m] - X[n];
float dy = Y[m] - Y[n];
int index = m * nodeElements + n;
D[index] = sqrt(dx*dx + dy*dy);
}
}
int j; //,min,temp;
int * P = (int *) malloc ((nodeElements + 1) * sizeof(int));
int b = 1;
for (i = 0; i <= nodeElements; i++) {
P[i] = b;
b = b * 2;
}
b = P[nodeElements];
float * A = (float *) malloc (nodeElements * b * sizeof(float));
for(i = 0; i < b; i++)
for(j = 0; j < nodeElements; j++)
{
int index = j*b + i;
if ((j == 0) && (i == 1)) {
A[index] = 0;
} else if ((j == 0)&& (i != 1)) {
A[index] = MAX_COST;
} else {
A[index] = -1;
}
}
int * bitPositions = (int *) malloc ((nodeElements) * sizeof(int));
for (int m = 2; m <= nodeElements; m++) {
printf("m: %d\n", m);
for (unsigned int ii = 0; ii < b; ii++) {
if ((ii % 2 == 1) && (BitCount(ii) == m)) {
int bitCount = 0;
for (unsigned int k = 0; k <= nodeElements; k++) {
if (ii & P[k]) {
bitPositions[bitCount] = k;
bitCount++;
}
}
for (unsigned int k1 = 0; k1 < m; k1++) {
j = bitPositions[k1];
if (j == 0)
continue;
float min = MAX_COST;
for (unsigned int k2 = 0; k2 < m; k2++) {
if (k1 == k2)
continue;
int kk = bitPositions[k2];
float result = A[(ii - P[j]) + kk*b] + D[kk * nodeElements + j];
if (result > MAX_COST)
result = MAX_COST;
if (result < min) {
min = result;
}
}
A[ii + b * j] = min;
}
}
}
}
free(bitPositions);
float finalResult = MAX_COST;
for (int j=1; j<nodeElements; j++) {
float result = A[j*b + b-1] + D[j * nodeElements + 0];
if (result < finalResult) {
finalResult = result;
}
}
printf ("%f.3", finalResult);
free(X);
free(Y);
free(D);
free(A);
//free(M);
free(P);
return 0;
}
*)
val _ = Control.polyEqWarn := false;
val _ = let
(* utility *)
fun printResults(results) = foldl (fn ((module, report), _) => print(module ^ ":\n" ^ report ^ "\n")) () results
fun allStringsEqual str strs = foldl (fn (nextStr, allEqualSoFar) => allEqualSoFar andalso nextStr = str) true strs
fun onlyFailedModules results =
List.map
(fn (module, result) => (module, foldl (op ^) "" result))
(List.filter (fn (_, result) => (not o (allStringsEqual "")) result) results)
(* assertion framework *)
fun assert(msg: string, e: bool) = if e then "" else "\tFAIL: " ^ msg ^ "\n"
fun assertFalse(msg: string, e: bool) = assert(msg, not e)
fun assertEquals(msg, expected, result) = assert("expected " ^ msg, expected = result)
fun assertEqualsInt(msg, expected, result) =
assertEquals("int " ^ Int.toString(expected) ^ " but was " ^ Int.toString(result) ^ " - " ^ msg, expected, result)
fun assertEmptyList(msg, xs) = assert("expected empty list - " ^ msg, null xs)
fun assertEqualsList(msg, expected, result) = assertEquals("equal lists - " ^ msg, expected, result)
fun assertEqualsString(msg, expected, result) =
assertEquals("string '" ^ expected ^ "' but was '" ^ result ^ "' - " ^ msg, expected, result)
fun assertNone(msg: string, result) = assert("expected NONE but got SOME - " ^ msg, not (isSome result))
fun assertSome(msg, expected) = assert("expected SOME but got NONE - " ^ msg, isSome(expected))
(* tests *)
(* TODO: should implement `test` runner (only feasible with some kind of lazy evaluation scheme) *)
(* (also setup/teardown functions, number of tests run, ...) *)
(* consider passing the function to be tested as a parameter just once, to avoid *)
(* having to repeat the function name all the time *)
(* find out if SML allows the code to find out a function name as a string, to avoid *)
(* having to pass the `test` function both as a symbol and as a string *)
val tests = [
("only_capitals", [
assertEmptyList("for empty list", only_capitals([])),
assertEqualsList("for list with uppercase strings", ["Upper", "Case"],
only_capitals(["lower", "case", "Upper", "Case"])
)
]),
("longest_string1", [
assertEqualsString("for 'longest' as the first of many longest strings",
"longest", longest_string1(["short", "small", "longest", "tiny", "l0ng3st"]))
]),
("longest_string2", [
assertEqualsString("for 'l0ng3st' as the last of many longest strings",
"l0ng3st", longest_string2(["short", "small", "longest", "tiny", "l0ng3st"]))
]),
("longest_string_helper", let
fun like_in_longest_string_1(x, y) = x > y
in [
assertEqualsString("for 'longest' as the first of many longest strings",
"longest", longest_string_helper like_in_longest_string_1 ["short", "small", "longest", "tiny", "l0ng3st"])
] end),
("first_answer", [
assert("should raise NoAnswer for empty list",
(* NOTE: sort of tedious construct to `test` for the right kind of exception to be raised *)
(* maybe figure out a more elegant way *)
(* trivial, if lazy evaluation is possible in any way *)
case SOME(SOME(first_answer (fn x => NONE) [])) handle NoAnswer => NONE | _ => SOME(NONE) of
NONE => true
| SOME _ => false
),
assertEqualsInt("for equals_3 on increasing list", 3,
first_answer (fn x => case x of 3 => SOME 3 | _ => NONE) [1, 2, 3, 4, 5]
)
]),
("all_answers", [
assertEquals("for any f and empty list", SOME [], all_answers (fn x => x) []),
assertNone("for x => NONE and any list", all_answers (fn x => NONE) [1, 2, 3, 4, 5]),
assertEqualsList("for x => SOME [x, x*x] and an int list", SOME [2, 4, 5, 25, 3, 9, 4, 16],
all_answers (fn x => SOME [x, x*x]) [2, 5, 3, 4]
)
]),
("count_wildcards", [
assertEqualsInt("for tuple of Wildcard patterns", 3,
count_wildcards (TupleP [Wildcard, ConstP 3, Wildcard, UnitP, Wildcard]))
]),
("check_pat", [
assertFalse("for repeated Variable name", check_pat (TupleP [Variable "my_var", Variable "my_var"])),
assertFalse("for repeated Variable names with other patterns interspersed",
check_pat(TupleP [Variable "my_var", UnitP, Wildcard, Variable "my_var"])
),
assert("for non-repeated Variables names with other patterns interspersed",
check_pat (TupleP [Variable "my_var", UnitP, Wildcard, Variable "other_var"])
)
]),
("match", [
assertEquals("empty binding list for Wildcard pattern", SOME [], match(Const 16, Wildcard)),
assertEquals("one binding for matching pattern with one Variable", SOME [("my_var", Const 13)],
match(Const 13, Variable "my_var")
),
assertEquals("empty binding list for matching UnitP", SOME [], match(Unit, UnitP)),
assertEquals("empty binding list for matching ConstP", SOME [], match(Const 17, ConstP 17)),
assertEquals("binding list for matching ConstructorP", SOME [("my_var", Const 13)],
match(Constructor("my_constructor", Const 13), ConstructorP("my_constructor", Variable "my_var"))
),
assertEquals("binding list for matching TupleP", SOME [("my_var", Const 13), ("other_var", Const 17)],
match(Tuple [Const 13, Const 17], TupleP [Variable "my_var", Variable "other_var"])
)
]),
("first_match", [
assertEquals("empty binding list for Wildcard pattern", SOME [],
first_match (Const 16) [UnitP, Wildcard, Variable "my_var"]
),
assertEquals("one binding for Variable pattern", SOME [("my_var", Const 16)],
first_match (Const 16) [UnitP, Variable "my_var", Wildcard]
),
assertNone("for no matching pattern",
first_match (Const 16) [UnitP, ConstP 32, ConstructorP ("my_constructor", Variable "my_var")]
)
]),
("typecheck_patterns", [
assertEquals("Anything-TupleT for first hw-example",
SOME (TupleT [Anything, Anything]),
typecheck_patterns([], [TupleP [Variable "x", Variable "y"], TupleP [Wildcard, Wildcard]])),
assertEquals("nested Anything-TupleT for second hw-example",
SOME (TupleT [Anything, TupleT [Anything, Anything]]),
typecheck_patterns([], [TupleP [Wildcard, TupleP [Wildcard, Wildcard]], TupleP [Wildcard, Wildcard]])),
assertNone("for exception UnmatchedConstructor",
typecheck_patterns([], [
TupleP [Wildcard, TupleP [Wildcard, Wildcard]],
TupleP [Wildcard, Wildcard],
TupleP [ConstructorP("my_cons", Variable "my_var"), Wildcard]
])),
assertEquals("TupleT with Datatype for example with valid Constructor",
SOME (TupleT [Datatype "c_my_type", TupleT [Anything, Anything]]),
typecheck_patterns([("my_cons", "c_my_type", IntT)], [
TupleP [Wildcard, TupleP [Wildcard, Wildcard]],
TupleP [Wildcard, Wildcard],
TupleP [ConstructorP("my_cons", ConstP 13), Wildcard]
]))
])
]
val _ = print "\n\n";
in
case onlyFailedModules tests of
[] => print("SUCCESS\n\n")
| results => printResults(results)
end
, :y
def initialize(x,y)
@x = x
@y = y
end
def eval_prog env
self # all values evaluate to self
end
def preprocess_prog
self # no pre-processing to do here
end
def shift(dx,dy)
Point.new(@x + dx, @y + dy) # shifting a point
end
def intersect other
other.intersectPoint self
end
def intersectPoint p
if real_close_point(@x, @y, p.x, p.y)
Point.new(p.x, p.y)
else
NoPoints.new
end
end
def intersectLine line
if real_close(@y, line.m * @x + line.b)
Point.new(@x, @y)
else
NoPoints.new
end
end
def intersectVerticalLine vline
if real_close(@x, vline.x)
Point.new(@x, @y)
else
NoPoints.new
end
end
def intersectWithSegmentAsLineResult seg
if (inbetween(@x,seg.x1,seg.x2) and inbetween(@y,seg.y1,seg.y2)) then
Point.new(@x,@y)
else
NoPoints.new
end
end
end
class Line < GeometryValue
# *add* methods to this class -- do *not* change given code and do not
# override any methods
attr_reader :m, :b
def initialize(m,b)
@m = m
@b = b
end
def eval_prog env
self # all values evaluate to self
end
def preprocess_prog
self # no pre-processing to do here
end
def shift(dx,dy)
Line.new(@m, @b + dy - @m*dx) # shifting a line
end
def intersect other
other.intersectLine self
end
def intersectPoint p
p.intersectLine self
end
def intersectLine line
if real_close(@m, line.m) then
if real_close(@b, line.b) then
Line.new(@m, @b)
else
NoPoints.new
end
else
x = (line.b - @b) / (@m - line.m)
y = @m * x + @b
Point.new(x, y)
end
end
def intersectVerticalLine vline
Point.new(vline.x, @m * vline.x + @b)
end
def intersectWithSegmentAsLineResult seg
#Line.new(@m, @b)
LineSegment.new(seg.x1,seg.y1,seg.x2,seg.y2)
end
end
class VerticalLine < GeometryValue
# *add* methods to this class -- do *not* change given code and do not
# override any methods
attr_reader 
In this assignment, you will create a data type that resizes a W-by-H image using the seam-carving technique.
The energy is high (white) for pixels in the image where there is a rapid color gradient (such as the boundary between the sea and sky and the boundary between the surfing Josh Hug on the left and the ocean behind him). The seam-carving technique avoids removing such high-energy pixels.
