COP4534: Algorithm Techniques

Course Description

COP4534 Algorithm Techniques is the second algorithms course in a computing degree — the point at which a student stops asking whether a program works and starts asking whether it is fast enough, and learns to answer that question before writing the code.

The statewide inventory records the course at Florida International University, Keiser University and the University of West Florida. ⚠ Keiser is a private institution, so the practical Florida public-system evidence base is two catalogs.

Florida International University uses the statewide title, Algorithm Techniques, with the prerequisite COP 3530.

The University of West Florida titles it Data Structures and Algorithms II, places it in the Hal Marcus College of Science and Engineering, Department of Computer Science at 3 semester hours, and requires COP 3530 AND COT 3100* — where the asterisk denotes a course that may be taken concurrently.

What the subject is. The first data structures course teaches the containers — lists, stacks, queues, trees, hash tables — and how to use them. ⚠ This course teaches the reasoning: how to recognise the shape of a problem, choose a technique that fits it, and prove that the result is correct and efficient. It is among the most transferable courses in an undergraduate computing degree, because the techniques outlive every language and framework a student will use.

The design paradigms are the spine of the course.

• Divide and conquer — break a problem into like subproblems, solve recursively, combine. Mergesort, quicksort, binary search, Strassen's matrix multiplication, and the recurrence relations that describe their cost.
• Greedy algorithms — make the locally best choice and never reconsider. ⚠ The interesting part is not the algorithms but the proofs: greedy is correct for Huffman coding, Dijkstra and minimum spanning trees, and wrong for the general knapsack problem — and knowing which case you are in requires an argument, not intuition.
• Dynamic programming — ⚠⚠ the technique students find hardest and the one interviews ask about most. Overlapping subproblems, optimal substructure, memoisation and tabulation; longest common subsequence, edit distance, knapsack, matrix chain multiplication.
• Graph algorithms — traversal, shortest paths, spanning trees, topological sort, flow. An unusually large share of real problems turn out to be graph problems in disguise, and recognising that is much of the skill.
• Complexity and intractability — P, NP, NP-completeness, reduction. ⚠ The practical payoff is knowing when to stop looking for an efficient exact algorithm and reach for approximation, heuristics, or a restricted version of the problem instead.

Learning Outcomes

Required Outcomes

• Analyse algorithms using asymptotic notation — big-O, big-Omega, big-Theta — and justify the bound.
• Distinguish best, average and worst case, and explain when each is the right measure.
• Solve recurrence relations by substitution, recursion tree and the master theorem.
• Analyse space complexity as well as time, including recursion stack cost.
• Apply divide and conquer to a new problem and analyse the result.
• Apply greedy techniques and prove or disprove the greedy choice property for a given problem.
• Formulate and solve problems by dynamic programming, identifying subproblem structure and recurrence.
• Convert a recursive formulation to a memoised and then a tabulated solution, and reconstruct the optimal solution, not merely its value.
• Implement and analyse graph traversals — BFS and DFS — and their applications.
• Apply shortest-path algorithms — Dijkstra, Bellman–Ford, Floyd–Warshall — and state the conditions each requires.
• Apply minimum spanning tree algorithms — Kruskal and Prim — and the union-find structure behind them.
• Apply topological sorting and detect cycles in directed graphs.
• Analyse and apply advanced sorting, including linear-time sorts and their preconditions.
• Explain and use balanced search trees — AVL, red-black or B-trees — and their guarantees.
• Explain hashing in depth: hash function design, collision resolution, load factor, and amortised analysis of resizing.
• Explain heaps and priority queues, and their role inside other algorithms.
• Explain P, NP, NP-hard and NP-complete, and what the classification does and does not assert.
• Perform a reduction between problems to establish hardness.
• Select an appropriate strategy for an intractable problem — approximation, heuristic, restriction, or exponential algorithm on small inputs.
• Argue the correctness of an algorithm using loop invariants or induction.
• Implement algorithms correctly in a general-purpose programming language and measure their empirical performance.
• Compare a theoretical bound with measured runtime and explain the discrepancy.

Optional Outcomes

• Apply network flow algorithms and the max-flow min-cut theorem.
• Apply string matching algorithms — KMP, Rabin–Karp, suffix structures.
• Explain randomised algorithms and expected-case analysis.
• Explain amortised analysis formally — aggregate, accounting and potential methods.
• Apply computational geometry algorithms such as convex hull.
• Explain approximation ratios and analyse an approximation algorithm.
• Explain parallel or external-memory algorithm design.
• Apply backtracking and branch and bound.
• Explain linear programming as an algorithmic tool.

Major Topics

Required Topics

• Asymptotic analysis and the formal definitions behind the notation.
• Recurrence relations and the master theorem.
• Divide and conquer.
• Sorting — comparison sorts, lower bounds, linear-time sorts.
• Greedy algorithms and greedy-choice proofs.
• Dynamic programming.
• Graph representation and traversal.
• Shortest paths and minimum spanning trees.
• Balanced search trees.
• Hashing and amortised analysis.
• Heaps and priority queues.
• Complexity classes, NP-completeness and reductions.
• Correctness arguments — invariants and induction.
• Implementation and empirical measurement.

Optional Topics

• Network flow.
• String algorithms and suffix structures.
• Randomised algorithms.
• Computational geometry.
• Approximation algorithms.
• Backtracking and branch and bound.
• Parallel and external-memory algorithms.
• Linear programming.
• Advanced structures — tries, segment trees, disjoint sets, Fibonacci heaps.

Resources & Tools

• Cormen, Leiserson, Rivest and Stein, Introduction to Algorithms — ⚠ "CLRS", the field's reference work. Rigorous, comprehensive, and heavy; excellent to consult and difficult to read straight through. If your course assigns it, treat it as a reference and use a second text for first exposure.
• Sedgewick and Wayne, Algorithms — ⚠ the most approachable of the standard texts, with Java implementations, and the accompanying site at algs4.cs.princeton.edu is free and carries code, data and visualisations.
• Kleinberg and Tardos, Algorithm Design — ⚠ the best treatment of how to choose a technique, organised by paradigm rather than by problem, with unusually good exercises. Widely preferred for a second course.
• Skiena, The Algorithm Design Manual — ⚠ the most practical of the four; its second half is a catalogue of problems mapped to the algorithms that solve them, which is exactly the lookup a working engineer wants. Skiena's video lectures are free.
• Erickson, Algorithms — ⚠ free and legally so from the author at jeffe.cs.illinois.edu/teaching/algorithms/; strong on recursion and dynamic programming, and genuinely well written.
• Visualisation: VisuAlgo (visualgo.net) and the University of San Francisco's data structure visualisations — free, and the fastest way to make a tree rotation or a DP table concrete.
• Practice platforms: LeetCode, HackerRank, Codeforces, AtCoder, and Project Euler. ⚠ These are how the material is actually internalised — the techniques do not stick from reading. Codeforces and AtCoder are the better training for correctness under constraints; LeetCode maps most directly onto interview practice.
• Implementation languages: courses commonly use Java, C++ or Python. ⚠ C++ dominates competitive programming because of the Standard Template Library and its speed; Python is quickest to write and can time out on large inputs. Know which your course expects.
• Free course material: MIT 6.006 and 6.046 on OpenCourseWare, Princeton's Coursera algorithms courses (Sedgewick), and Stanford's algorithms specialisation (Roughgarden).

Career Pathways

⚠ This is the course with the most direct effect on a computing graduate's employability, for a specific and slightly unsatisfying reason: it is what technical interviews test. That is not the best argument for learning it, but it is a true one and students deserve to know it.

• Software developers, applications and systems software (SOC 15-1252, 15-1253) — ⚠ interviews at larger employers are, in practice, algorithms examinations: dynamic programming, graph traversal and complexity analysis recur constantly.
• Data scientists (SOC 15-2051) and machine learning engineers (SOC 15-1252) — training and inference are algorithmic efficiency problems at scale.
• Database architects and engineers (SOC 15-1243, 15-1242) — query planning, indexing and join algorithms are this material applied.
• Computer and information research scientists (SOC 15-1221) — ⚠ the natural route to graduate study; algorithms is a core qualifying-exam subject in most CS doctoral programmes.
• Operations research analysts (SOC 15-2031) — optimisation, routing, scheduling and network flow directly.
• Bioinformatics scientists (SOC 19-1029) — sequence alignment is dynamic programming; ⚠ relevant to Florida's life-sciences employers and the state's research universities.
• Quantitative analysts (SOC 13-2099) — efficiency under latency constraints.
• Information security analysts (SOC 15-1212) — cryptography and its analysis rest on complexity assumptions taught here.
• Game and simulation developers (SOC 15-1255) — pathfinding, spatial partitioning and real-time constraints; ⚠ Florida has a notable games and simulation cluster around Orlando, tied to the defence-simulation industry at the Central Florida Research Park.

Special Information

⚠ Prerequisites — and the concurrent discrete mathematics requirement

Both institutions require COP 3530 (data structures and algorithms I). UWF adds COT 3100 — discrete mathematics — with an asterisk, meaning it may be taken in the same term.

• ⚠ A concurrent prerequisite is still required. It is not optional and not deferrable; you must be registered for it if you have not completed it.
• ⚠⚠ Take discrete mathematics BEFORE this course if you possibly can. This is the strongest practical recommendation in this guide. The course's proofs — induction, invariants, counting, recurrence, graph theory — are discrete mathematics. Students taking both at once meet a proof technique in the algorithms lecture the week before it is introduced in the mathematics one, and the concurrency option exists for scheduling reasons, not pedagogical ones.
• The assumed background beyond the formal prerequisites: fluency with recursion, comfort implementing a data structure from scratch, and enough programming maturity that the implementation is not itself the obstacle.

Course format and workload

3 credits, 45 contact hours — lecture, three hours per week; no laboratory suffix, so programming is assigned outside class.

Expect 9–12 hours per week outside class. ⚠ The workload is unusual in shape: much of it is thinking rather than typing. A dynamic programming problem can take three hours to formulate and twenty minutes to code, which students consistently under-plan for — and the failure mode is starting an assignment the night before, when the formulation has nowhere to happen.

Assessment normally combines problem sets with proofs and analysis, programming assignments, and exams. ⚠ Exams typically ask you to design an algorithm for a problem you have not seen and analyse it — which is why memorising the standard algorithms is not sufficient preparation.

⚠ Where students struggle, and what actually works

• ⚠⚠ Dynamic programming. The near-universal wall. The difficulty is not implementation — it is identifying the subproblem, and there is no procedure for that. What works is volume: solve thirty DP problems and the recognition becomes reliable; read about DP and it does not. Start from the recursive formulation, then memoise, then tabulate — students who jump straight to the table almost always get the recurrence wrong.
• Writing proofs. Many students have never been asked to prove a program correct. A greedy algorithm that works on your examples is not a proved greedy algorithm, and the exchange-argument and cut-and-paste techniques are learnable — but they must be practised, not read.
• Recurrence relations. Mechanical once the master theorem is understood; ⚠ the common error is applying it to a recurrence outside its form. Check the conditions.
• NP-completeness. Reductions run in the direction opposite to most students' intuition. ⚠ To prove a problem hard you reduce a known hard problem TO it, not it to something else — getting the direction backwards is the single most common error on that unit.
• Theory-to-practice gaps. An O(n log n) algorithm can lose to an O(n²) one on realistic input sizes because of constants and cache behaviour. This is not a flaw in the analysis; it is a limit of what asymptotics claims, and understanding that boundary is part of the course.

Position in the curriculum, and articulation

⚠ A 4000-level upper-division course, normally taken in the junior or senior year, and required in essentially every computer science degree. Florida College System institutions do not generally offer it; A.A. transfer students meet it after transfer, and the prerequisite COP 3530 is the course to have finished first.

⚠ Take it early enough to use it. The material feeds directly into upper-division electives — machine learning, databases, computer graphics, bioinformatics — and it is what interviews for internships test. A student who defers it to the final term interviews without it.

Number and prefix note. The number is COP4534 at both institutions and articulation is clean. ⚠ But the same subject carries other numbers in Florida — COT4400 (analysis of algorithms) is common, and some programmes run their second algorithms course under COP and others under COT. COP is computer programming; COT is computing theory, and the split reflects whether a department frames the course as implementation or as theory. Search by subject rather than prefix when checking a receiving programme's requirement, and keep the syllabus — the evaluation turns on topic coverage.

⚠ A note on the sequence title

UWF's "Data Structures and Algorithms II" implies a first course under the same name, which is COP 3530. If you transfer in with COP 3530 completed elsewhere, you satisfy the prerequisite — the numbers match statewide. ⚠ What may not match is coverage: some institutions push balanced trees and graph algorithms into the first course and others leave them to the second, so a transfer student can meet a topic assumed to be known or repeat one already covered. Neither is a barrier; both are worth knowing about in week one.

AI Integration

⚠⚠ This course has the sharpest AI tension of any undergraduate computing course, and it is worth stating plainly rather than managing around.

The tension: large language models are genuinely good at the standard algorithm problems — the classical dynamic programming problems, graph algorithms and interview questions are abundant in their training data and the outputs are frequently correct. ⚠ And this is precisely the material whose value lies in having derived it yourself.

Where AI assistance is legitimately useful:

• Explaining a technique after you have struggled with it. A second explanation of why a DP recurrence has the shape it does, once you have tried to find it, is genuinely valuable.
• Checking your analysis — you derive a bound, then ask for a critique of your reasoning. ⚠ This direction is safe; asking for the bound first is not.
• Generating test cases and edge cases, including adversarial inputs for an implementation you wrote.
• Implementation boilerplate — graph representations, input parsing, timing harnesses — which is not what is being assessed.
• Explaining an unfamiliar algorithm encountered in a paper or a codebase.

⚠⚠ Where it fails, and where it costs you:

• Confidently wrong complexity analysis. Models state bounds fluently and are unreliable on anything non-standard — amortised analysis, recurrences outside the master theorem's form, and space complexity including the recursion stack. Verify the derivation; do not accept the notation.
• Fabricated correctness arguments. ⚠ Asked to prove a greedy algorithm correct, a model will produce a proof-shaped paragraph whether or not the algorithm is correct. In a course where the proof is the deliverable, that is the worst possible failure mode — and greedy algorithms that are wrong pass most hand-written test cases, so the code will not reveal it.
• Novel problems. Performance drops markedly on problems that are not variants of well-known ones — which is exactly what exams ask.
• ⚠⚠ The interview consequence, stated bluntly. Technical interviews at most large employers still examine this material live, without tools. A student who generated their way through this course has the credit and cannot do the thing the credit is taken to signal. That gap is discovered in the interview, when it is too late to close.

The deeper argument, which is not about integrity. ⚠ What this course builds is the ability to look at an unfamiliar problem and see its structure — that it is a graph problem, that it has optimal substructure, that the greedy choice will fail here. That recognition is built by failing at problems and then succeeding at them, and it is not transferable from an explanation. A tool that supplies the answer removes the only part of the exercise that changes you — and in this subject, unusually, the thing removed is the thing employers are paying for.

Where algorithms and AI genuinely meet, and this is worth knowing: training and inference are algorithmic efficiency problems. Attention is quadratic in sequence length, which is why efficient-attention research exists; nearest-neighbour search in vector databases is an algorithms problem; and the people improving model efficiency are doing exactly what this course teaches.

Academic integrity. Course policies here are normally specific and normally strict. Submitting generated solutions as your own violates every Florida institution's policy — and in this course the practical penalty arrives twice, at the exam and at the interview.