This manual is for CSC-FPX4020 Assessment 3, start to submission. Assessment 3 in CSC-FPX4020, Algorithms and Data Structures, is usually the synthesis deliverable: a graph problem modelled, a representation chosen with its memory counted, a traversal implemented, and correctness argued rather than asserted. Every criterion is marked on its own against the guide in your courseroom. From here you get our tutors' working sequence, a layout drawn from the criteria, and an annotated excerpt. Rather have it handled? Send the criteria and an original premium sample follows inside 24 to 48 hours, revised without charge for as long as the guide demands. Your courseroom may print this as CSC FPX 4020 Assessment 3 or CSC4020 Assessment 3; it is the same deliverable, and CSC-FPX4020 Assessment 3 is what this manual walks through.
One honesty note before the manual: Capella revises courses and scoring guides over time, so always write to the exact scoring guide attached to your assessment in the courseroom. The course identity above is verified on capella.edu; the method and structure below are our tutors' approach to it, not Capella's official rubric text.
How CSC-FPX4020 Assessment 3 is scored
Four levels, one per criterion, no averaging. The descriptions in the guide are the brief, and this is what they tend to mean here:
| Level | What it means on a graph and traversal deliverable |
|---|---|
| Distinguished | The model says what a vertex is and what an edge means, the representation is chosen with its storage counted, and correctness rests on a stated invariant with the hostile inputs enumerated. The bound names both sizes of the graph. |
| Proficient | A correct model, a working traversal, and a bound given. Solid, with correctness supported by tests rather than by an argument. |
| Basic | A traversal described and coded, with the representation unexamined and the analysis carrying one letter for a structure that has two sizes. |
| Non-performance | A required element is missing, most often the correctness argument or the comparison of representations. |
A graph has two sizes, and that single fact carries more marks in this deliverable than anything else. A cost written against vertices alone is ambiguous before the sentence ends, so name both the vertex count and the edge count and keep them apart.
The CSC-FPX4020 Assessment 3 method, step by step
-
Set the criteria as headings, then define the model
Say what one vertex represents, what one edge represents, whether edges have direction, and whether they carry a weight. A model stated this precisely removes most of the ambiguity that later criteria punish, and it takes four sentences.
-
Count both sizes before choosing a representation
Write down how many vertices and how many edges you expect. A network of a few hundred stops with only a few connections each is sparse, and sparseness is the argument for one representation over the other, so the counts have to appear before the choice does.
-
Price the two representations in stored cells
An adjacency list holds two entries per undirected edge and an adjacency matrix holds one cell per pair of vertices whether or not an edge exists. Do that arithmetic with your own numbers and put both totals in the document, then say which query each representation makes cheap, since asking whether two stops connect is instant in the matrix and a short walk in the list.
-
Match the traversal to the question being asked
Fewest connections and shortest travel time are different questions with different procedures behind them. Breadth-first search answers the first on an unweighted graph, a shortest-path procedure answers the second once minutes are attached to edges, and a paper that reaches for the wrong one has failed the criterion before the code is read.
-
Argue correctness with an invariant and hostile inputs
State the property that is true every time round the loop, establish it before the first pass, show that a pass cannot break it, and say what it hands you when the loop ends. Then enumerate the inputs designed to break it: an empty graph, a single vertex, a vertex with no edges, a disconnected component, and a cycle that would trap a traversal with no visited set.
-
Report the cost in both sizes, then self-score
A traversal that visits each vertex once and looks at each edge from both ends costs a term in the vertex count plus a term in the edge count, and writing it that way is the criterion. Then mark yourself against the guide and rewrite anything short of the top level.
A structure that maps to the criteria
The figures below are the planning targets our tutors use for a deliverable of this shape, not Capella requirements; expand where your own criteria ask for depth.
| Section | What it must do | Guide |
|---|---|---|
| The model | What a vertex is, what an edge means, direction, weight, and the counts of each. | ~200 words |
| Representation compared | Adjacency list against adjacency matrix in stored cells, with the query each one makes cheap. | ~250 words |
| Traversal and why this one | The procedure chosen, the question it answers, and the procedure you would use if the question changed. | ~250 words |
| Correctness | The loop invariant carried through the three steps, plus every hostile input named and handled. | ~300 words |
| Cost and evidence | The bound written in both graph sizes, and a run on your own data with the counts observed. | ~250 words |
| References | Algorithm texts, the origin of the named procedure, library documentation, and current APA both ways. | as needed |
Annotated sample excerpt
A last original excerpt from our team, printed as a model of how correctness gets argued instead of promised. Take the shape, then write it against your own graph.
A vertex is one shuttle stop and an edge is a scheduled hop between two stops in either direction, which gives 180 vertices and 340 edges for the whole campus network.1 Stored as adjacency lists that is 680 entries, and stored as a matrix it is 32,400 cells of which 680 hold anything, so the list is chosen for memory and the matrix keeps one advantage worth recording, namely that asking whether two named stops connect directly is a single lookup rather than a walk along a list.2 Correctness of the fewest-hops search then rests on one invariant: at the start of every pass, every stop already removed from the queue has been labelled with its true minimum number of hops from the origin, which holds trivially before the first pass, is preserved because each pass labels only unlabelled neighbours of the stop it removed, and on exit leaves every reachable stop labelled and every unreachable one untouched.3
- 1Defines the model and both sizes in one sentence. A reader now knows what every later bound is counting, which is the ambiguity this criterion is built to catch.
- 2Does the storage arithmetic with the writer's own numbers and gives the rejected representation its genuine advantage rather than a token one.
- 3Carries an invariant through establishment, preservation, and exit, and says what happens to the unreachable part of the graph. That structure is what a correctness criterion is asking for.
The full premium sample for your exact assessment, written fresh to your scoring guide and issue, is free to request. Study it, revise it into your own voice, and submit work you understand.
The five mistakes that cost Distinguished
- A bound written with one letter. A graph has a vertex count and an edge count, and a cost that names one of them is unfinished.
- Representation left unexamined. The choice between a list and a matrix is usually a criterion of its own, not an implementation detail.
- Correctness supported by passing tests. Tests show the cases you tried; an invariant covers the cases you did not.
- Breadth-first search used on a weighted graph. Fewest hops and shortest time are different questions, and the wrong procedure answers neither.
- No hostile inputs. An empty graph, an isolated vertex, and a cycle are where a traversal breaks, and the criterion knows it.
Pre-submission checklist
- Vertex and edge defined, with direction and weight settled explicitly
- Both graph sizes counted and written down before the representation is chosen
- List and matrix priced in stored cells, each given the query it makes cheap
- The traversal matched to the question, with the alternative named
- A loop invariant established, preserved, and cashed out at exit
- Hostile inputs enumerated and handled, cost written in both sizes, APA reconciled both ways
Traversal running and the correctness section blank?
Send the graph, the criteria, and whatever code compiles today. Back comes the model, the storage arithmetic, the invariant carried through all three steps, the hostile inputs, and the bound written in both sizes, inside 24 to 48 hours with revisions free until the guide is satisfied. Your opening request costs nothing.