CS Curricula

Courses tagged with algs

COSC-311: Algorithms (1) algs

This course addresses the design and analysis of computer algorithms. (Amherst)

COSC-355: Network Science (1) algs

Many phenomena can be represented as networks of interactions between different components. Network science is the discipline at the intersection of computer science, statistics, and physics that studies the structure, formation, evolution, and behavior of such networks, with the goal of understanding the phenomena they represent. In this course we study algorithmic, computational, and statistical approaches to the analysis of networks of people (both online and offline), web pages, proteins, and physical goods. We cover, among other topics: models of network formation, ways of measuring the importance of entities in networks and algorithms to calculate those metrics, models and algorithms for diffusion of information and diseases, and human-friendly approaches for visualizing network dynamics. (Amherst)

COSC-373: Distributed Algorithms (1) algs

A distributed system consists of a network of processors that communicate by exchanging messages. No processor has a global view of the network, so neighboring processors must communicate in order for the system to perform a given task. In this course, we will study the theory of distributed systems. We will consider fundamental algorithmic tasks---for example, finding spanning trees, maximal independent sets, and graph coloring---in several models of distributed computing. Our goal is to understand under what conditions these tasks can be performed efficiently, if at all. While this course is primarily theoretical, we will discuss applications of the theory to modern computing paradigms (e.g., MapReduce). (Amherst)

CPI 220: Applied Data Structures and Algorithms (3) algs

Thorough grounding in applied knowledge and skills related to algorithms and data structures used in the development of software designed to solve complex problems. Overview of computational and critical thinking skills that can be called upon to analyze and solve complex problems in multiple domains. (ASU)

CSE 310: Data Structures and Algorithms (3) algs

Advanced data structures and algorithms, including stacks, queues, trees (B, B+, AVL), and graphs. Searching for graphs, hashing, external sorting. (ASU)

CSE 450: Design and Analysis of Algorithms (3) algs

Design and analysis of computer algorithms using analytical and empirical methods; complexity measures, design methodologies and survey of important algorithms. (ASU)

COMP 3270: Introduction To Algorithms (3) algs

Algorithms for standard computational problems and techniques for analyzing their efficiency; designing efficient algorithms and experimentally evaluating their performance. (Auburn)

CSCI 4100: Analysis of Algorithms (3) algs

Introduction to design and analysis of combinatorial algorithms. Use of asymptotics in evaluating algorithm’s efficiency and scalability. Application of induction and other mathematical techniques for proving correctness of algorithms. Data structures for simplifying algorithm design, such as hash tables, heaps, binary search trees. Advanced design and analysis methods, such as greedy algorithms, dynamic programming, amortized analysis. (Augusta)

CSI 3344: Introduction to Algorithms (3) algs

This course will provide a comprehensive introduction to computer algorithms taken from diverse areas of application. This course will concentrate on algorithms of fundamental importance and on analyzing the efficiency of these algorithms. (Baylor)

CSI 4144: Competitive Learning (1) algs

Students in the course will learn and implement algorithms to solve programming challenges. Topics include graph algorithms, backtracking search, simulation, geometry, combinatorics, number theory, sorting, searching, parsing, and output formatting. The course may be taken up to 3 times for credit. (Baylor)

CS 310: Data Structures and Algorithms (4) algs

Analysis of the design, implementation, and properties of basic and advanced data structures, including lists, stacks, queues, hash tables, trees, heaps, and graphs. Design and time-space analysis of basic and advanced algorithms, including searching, sorting, insert/delete, hash table collision resolution techniques, recursive functions, balanced tree maintenance, and graph algorithms. Weekly required laboratory programming and three or more additional programming projects in C++. Practical programming techniques including C++ templates and the Standard Template Library (STL), operator overloading, C++ stream I/O, separate compilation using makefiles, debugging tools and techniques, dynamic memory management. (Binghamton)

CS 375: Design and Analysis of Algorithms (4) algs

Analysis of common algorithms for processing strings, trees, graphs and networks. Comparison of sorting and searching algorithms. Algorithm design strategies: divide and conquer, dynamic, greedy, back tracking, branch and bound. Introduction to NP-completeness. Required activity includes student presentations. (Binghamton)

CSCI3383: Algorithms (3) algs

This course is a study of algorithms for, among other things, sorting, searching, pattern matching, and manipulation of graphs and trees. Emphasis is placed on the mathematical analysis of the time and memory requirements of such algorithms and on general techniques for improving their performance. (Boston)

CS 132: Geometric Algorithms (4) algs

Basic concepts, data structures, and algorithms for geometric objects. Examples of topics: Cartesian geometry, transformations and their representation, queries and sampling, triangulations. Emphasis on rigorous reasoning and analysis, advancing algorithmic maturity and expertise in its application. (BU)

CS 330: Introduction to Analysis of Algorithms (4) algs

Examines the basic principles of algorithm design and analysis; graph algorithms; greedy algorithms; dynamic programming; network flows; polynomial-time reductions; NP-hard and NP-complete problems; approximation algorithms; randomized algorithms. (BU)

CS 530: Advanced Algorithms (4) algs

Studies the design and efficiency of algorithms in several areas of computer science. Topics are chosen from graph algorithms, sorting and searching, NP-complete problems, pattern matching, parallel algorithms, and dynamic programming. (BU)

CS 543: Algorithmic Techniques for Taming Big Data (4) algs

Growing amounts of available data lead to significant challenges in processing them efficiently. In many cases, it is no longer possible to design feasible algorithms that can freely access the entire data set. Instead of that we often have to resort to techniques that allow for reducing the amount of data such as sampling, sketching, dimensionality reduction, and core sets. Also explores scenarios in which large data sets are distributed across several machines or even geographical locations and the goal is to design efficient communication protocols or MapReduce algorithms. Includes a final project and programming assignments in which we explore the performance of our techniques when applied to publicly available data sets. (BU)

CS 582: Geometry Processing (4) algs

Algorithms and data structures for digital processing of triangle meshes and point clouds. Topics include: surface smoothing, parametrization, and deformation; half-edge data structures; discretized curvature measures; and spectral analysis of surfaces. Numerical methods for linear algebra and optimization also discussed. (BU)

COSI 21a: Data Structures and the Fundamentals of Computing (4) algs

Focuses on the design and analysis of algorithms and the use of data structures. Through the introduction of the most widely used data structures employed in solving commonly encountered problems. Students will learn different ways to organize data for easy access and efficient manipulation. The course also covers algorithms to solve classic problems, as well as algorithm design strategies; and computational complexity theory for studying the efficiency of the algorithms. Usually offered every year. (Brandeis)

COSI 133a: Graph Mining (4) algs

Graphs and networks are a fundamental tool for modeling complex social, technological, and biological systems. This course covers the core methodologies and algorithms of graph and network mining techniques. Students learn methods and algorithms of graph and network mining, apply graph and network mining tools, and work on related homework and course projects. Usually offered every second year. (Brandeis)

COSI 180a: Algorithms (4) algs

Basic concepts in the design and analysis of algorithms. Usually offered every second year. (Brandeis)

CSCI 0500: Data Structures, Algorithms, and Intractability: An Introduction (1) algs

Covers designing and analyzing data structures and algorithms. Studies the theory of NP-completeness. (Brown)

CSCI 1550: Probabilistic Methods in Computer Science (1) algs

Randomization and probabilistic techniques play an important role in modern computer science, with applications ranging from combinatorial optimization and machine learning to communications networks and secure protocols. This course introduces the most fundamental probabilistic techniques used in computer science applications, in particular in randomized algorithms, probabilistic analysis of algorithms and machine learning. (Brown)

CSCI 1570: Design and Analysis of Algorithms (1) algs

A single algorithmic improvement can have a greater impact on our ability to solve a problem than ten years of incremental improvements in CPU speed. We study techniques for designing and analyzing algorithms. Typical problem areas addressed include hashing, searching, dynamic programming, graph algorithms, network flow, and optimization algorithms including linear programming. (Brown)

CSCI 1810: Computational Molecular Biology (1) algs

High-throughput experimental approaches now allow molecular biologists to make large-scale measurements of DNA, RNA, and protein, the three fundamental molecules of the cell. The resulting datasets are often too large for manual analysis and demand computational techniques. This course introduces algorithms for sequence comparison and alignment; molecular evolution and phylogenetics; DNA/RNA sequencing and assembly; recognition of genes and regulatory elements; and RNA and protein structure. The course demonstrates how to model biological problems in terms of computer science. (Brown)

CSCI 1820: Algorithmic Foundations of Computational Biology (1) algs

This course is devoted to computational and statistical methods as well as software tools for DNA, RNA, and protein sequence analysis. The focus is on understanding the algorithmic and mathematical foundations of the methods, the design of the associated genomics tools, as well as on their applications. A comprehensive set of programming assignments provides a hands-on journey for the student into the complexities of real genomic data. (Brown)

CS 22: Data Structures & Parallelism (9) algs

CS 22 is a demanding course that covers implementation, correctness, and analysis of data structures and some parallel algorithms. This course is intended for students who have already taken a data structures course at the level of CS 2. Topics include implementation and analysis of skip lists, trees, hashing, and heaps as well as various algorithms (including string matching, parallel sorting, parallel prefix). The course includes weekly written and programming assignments covering the lecture material. Not offered 2023-24. (Caltech)

CS 38: Algorithms (9) algs

This course introduces techniques for the design and analysis of efficient algorithms. Major design techniques (the greedy approach, divide and conquer, dynamic programming, linear programming) will be introduced through a variety of algebraic, graph, and optimization problems. Methods for identifying intractability (via NP-completeness) will be discussed. (Caltech)

CS 137: Real-World Algorithm Implementation (12) algs

This course introduces algorithms in the context of their usage in the real world. The course covers compression, semi-numerical algorithms, RSA cryptography, parsing, and string matching. The goal of the course is for students to see how to use theoretical algorithms in real-world contexts, focusing both on correctness and the nitty-gritty details and optimizations. Students will choose to implement projects based on depth in an area or breadth to cover all the topics. (Caltech)

CS 138: Computer Algorithms (9) algs

This course is identical to CS 38. Only graduate students for whom this is the first algorithms course are allowed to register for CS 138. See the CS 38 entry for prerequisites and course description. (Caltech)

CS 139: Analysis and Design of Algorithms (12) algs

This course develops core principles for the analysis and design of algorithms. Basic material includes mathematical techniques for analyzing performance in terms of resources, such as time, space, and randomness. The course introduces the major paradigms for algorithm design, including greedy methods, divide-and-conquer, dynamic programming, linear and semidefinite programming, randomized algorithms, and online learning. (Caltech)

CS 149: Algorithmic Economics (9) algs

This course will equip students to engage with active research at the intersection of social and information sciences, including: algorithmic game theory and mechanism design; auctions; matching markets; and learning in games. (Caltech)

CS 150 a: Probability and Algorithms (3) algs

The probabilistic method and randomized algorithms. Deviation bounds, k-wise independence, graph problems, identity testing, derandomization and parallelization, metric space embeddings, local lemma.¯ (Caltech)

CS 252: Algorithms (6) algs

A course on techniques used in the design and analysis of efficient algorithms. We will cover several major algorithmic design paradigms (greedy algorithms, dynamic programming, divide and conquer, and network flow). Along the way, we will explore the application of these techniques to a variety of domains (natural language processing, economics, computational biology, and data mining, for example). As time permits, we will include supplementary topics like randomized algorithms, advanced data structures, and amortized analysis. (Carleton)

CS 352: Advanced Algorithms (6) algs

A second course on designing and analyzing efficient algorithms to solve computational problems. We will survey some algorithmic design techniques that apply broadly throughout computer science, including discussion of wide-ranging applications. A sampling of potential topics: approximation algorithms (can we efficiently compute near-optimal solutions even when finding exact solutions is computationally intractable?); randomized algorithms (does flipping coins help in designing faster/simpler algorithms?); online algorithms (how do we analyze an algorithm that needs to make decisions before the entire input arrives?); advanced data structures; complexity theory. As time and interest permit, we will mix recently published algorithmic papers with classical results. (Carleton)

15-351: Algorithms and Advanced Data Structures (12) algs

The objective of this course is to study algorithms for general computational problems, with a focus on the principles used to design those algorithms. Efficient data structures will be discussed to support these algorithmic concepts. Topics include: Run time analysis, divide-and-conquer algorithms, dynamic programming algorithms, network flow algorithms, linear and integer programming, large-scale search algorithms and heuristics, efficient data storage and query, and NP-completeness. Although this course may have a few programming assignments, it is primarily not a programming course. Instead, it will focus on the design and analysis of algorithms for general classes of problems. This course is not open to CS graduate students who should consider taking 15-651 instead. THIS COURSE IS NOT OPEN TO COMPUTER SCIENCE MAJORS OR MINORS. (CMU)

15-435: Foundations of Blockchains (12) algs

In this course, students will learn the mathematical foundations of blockchains, including how to construct distributed consensus protocols and prove them secure, cryptography for blockchains, and mechanism design for blockchains. This course will take a mathematically rigorous approach. Students are expected to have mathematical maturity and be able to write formal mathematical proofs. Students may also be expected to implement some consensus or cryptographic algorithms. This course is cross-listed with 15-635. Undergraduates should enroll in 15-435. Graduates students should enroll in 15-635. (CMU)

15-451: Algorithm Design and Analysis (12) algs

This course is about the design and analysis of algorithms. We study specific algorithms for a variety of problems, as well as general design and analysis techniques. Specific topics include searching, sorting, algorithms for graph problems, efficient data structures, lower bounds and NP-completeness. A variety of other topics may be covered at the discretion of the instructor. These include parallel algorithms, randomized algorithms, geometric algorithms, low level techniques for efficient programming, cryptography, and cryptographic protocols. (CMU)

15-456: Computational Geometry (9) algs

How do you sort points in space? What does it even mean? This course takes the ideas of a traditional algorithms course, sorting, searching, selecting, graphs, and optimization, and extends them to problems on geometric inputs. We will cover many classical geometric constructions and novel algorithmic methods. Some of the topics to be covered are convex hulls, Delaunay triangulations, graph drawing, point location, geometric medians, polytopes, configuration spaces, linear programming, and others. This course is a natural extension to 15-451, for those who want to learn about algorithmic problems in higher dimensions. (CMU)

15-457: Special Topics in Theory: Advanced Algorithms (12) algs

Selected advanced topics in algorithms and computational theory. Topics vary from semester to semester. (CMU)

15-495: Topics of Algorithmic Problem Solving (12) algs

This course aims to give implementation motivated perspectives on some algorithmic ideas that fall outside of the scopes of most courses. It is intended for graduate students, as well as undergraduate students who have high grades in 15-210, 15-251, 15-259 (and preferably 15-451). Evaluation will consist of about 30 auto-graded coding tasks, plus either participation in the East Central NA ICPC Regional Contest, or presentations of problem-solving reports from the Chinese IOI Team Selection Camp. The first half of the course will discuss floating point precision, numerical approximation schemes, heuristic search, usage of optimization packages, and vectorization. The second half will provide high-level surveys of 2-D range update and amp; query data structures, proactive propagation, palindromic automata, automated recurrence finding, and maximum adjacency search. (CMU)

CSDS 310: Algorithms (3) algs

The course covers fundamentals in algorithm design and analysis and provides practice in professional algorithm writing and presentations. Loop invariants, asymptotic notation, recurrence relations, sorting algorithms, divide-and-conquer, dynamic programming, greedy algorithms, basic graph algorithms. Offered as CSDS 310 and CSDS 310N. Counts as a Disciplinary Communication course. (Case)

CSDS 310N: Algorithms (3) algs

CSDS 410: Analysis of Algorithms (3) algs

This course covers fundamental topics in algorithm design and analysis in depth. Amortized analysis, NP-completeness and reductions, dynamic programming, advanced graph algorithms, string algorithms, geometric algorithms, local search heuristics. (Case)

CSDS 477: Advanced Algorithms (3) algs

Design and analysis of efficient algorithms, with emphasis on network flow, combinatorial optimization, and randomized algorithms. Linear programming: duality, complementary slackness, total unimodularity. Minimum cost flow: optimality conditions, algorithms, applications. Game theory: two-person zero-sum games, minimax theorems. Probabilistic analysis and randomized algorithms: examples and lower bounds. Approximation algorithms for NP-hard problems: examples, randomized rounding of linear programs. (Case)

CP307: Data Structures and Algorithms (1) algs

Study of fundamental data structure and algorithm concepts, and analysis techniques thereof. Examination of hash function and tree based data structures. Analysis techniques including asymptotic analysis and proof of algorithm correctness and performance. Exploration of reduction and algorithmic categories (e.g., NP- completeness). (Colorado)

CP407: Analysis of Algorithms (1) algs

Investigation of the efficiency and design of algorithms including order estimates, complexity, and NP problems. (Not offered 2024-25). (Colorado)

COMS W4232: Advanced Algorithms (3) algs

Introduces classic and modern algorithmic ideas that are central to many areas of Computer Science. The focus is on most powerful paradigms and techniques of how to design algorithms, and how to measure their efficiency. The intent is to be broad, covering a diversity of algorithmic techniques, rather than be deep. The covered topics have all been implemented and are widely used in industry. Topics include: hashing, sketching/streaming, nearest neighbor search, graph algorithms, spectral graph theory, linear programming, models for large-scale computation, and other related topics (Columbia)

COMS W4241: Numerical Algorithms and Complexity (3) algs

Modern theory and practice of computation on digital computers. Introduction to concepts of computational complexity. Design and analysis of numerical algorithms. Applications to computational finance, computational science, and computational engineering (Columbia)

CSOR E4231: Analysis of Algorithms I (3) algs

Introduction to the design and analysis of efficient algorithms. Topics include models of computation, efficient sorting and searching, algorithms for algebraic problems, graph algorithms, dynamic programming, probabilistic methods, approximation algorithms, and NP-completeness (Columbia)

CSOR W4231: Analysis of Algorithms I (3) algs

(Columbia)

CS 4820: Introduction to Analysis of Algorithms (4) algs

Develops techniques used in the design and analysis of algorithms, with an emphasis on problems arising in computing applications. Example applications are drawn from systems and networks, artificial intelligence, computer vision, data mining, and computational biology. This course covers four major algorithm design techniques (greedy algorithms, divide-and-conquer, dynamic programming, and network flow), undecidability and NP-completeness, and algorithmic techniques for intractable problems (including identification of structured special cases , approximation algorithms, local search heuristics, and online algorithms). (Cornell)

COSC 31: Algorithms (1) algs

A survey of fundamental algorithms and algorithmic techniques, including divide-and-conquer algorithms, dynamic programming, randomized algorithms, greedy algorithms, and graph algorithms. Presentation, implementation and formal analysis, including space/time complexity and proofs of correctness, are all emphasized. (Dartmouth)

COSC 32: Advanced Algorithms (1) algs

This course follows up on our basic undergraduate-level algorithms course, covering a number of advanced topics and ideas in algorithm design and analysis. You will learn about the use of advanced data structures, amortized analysis, randomization, linear programming, and approximation. The focus will be on methodology and broadly-applicable fundamental principles, rather than specific problem domains. (Dartmouth)

COSC 34: Randomized Algorithms (1) algs

Randomness is one of the key resources in algorithm design. Many problems have faster algorithms if randomization is allowed, and indeed, for certain problems randomness is essential. The course will introduce the probability basics, the fundamental tools, and provide multiple applications in machine learning, big data, optimization, etc. Not open to students who have received credit for COSC 49.10. (Dartmouth)

COSC 35: Data Stream Algorithms (1) algs

This course studies algorithms that process massive amounts of data; so massive that they will not fit in a computer’s storage. The course will cover a wide variety of techniques for summarizing such large amounts of data into succinct “sketches” that nevertheless retain important and useful information. The course starts from the basics, assuming only a basic knowledge of algorithms, and builds up to advanced techniques from recent research. (Dartmouth)

COSC 36: Approximation Algorithms (1) algs

Many problems arising in computer science are NP-hard and therefore we do not expect efficient algorithms for solving them exactly. This has led to the study of approximation algorithms where algorithms are supposed to run fast but can return approximate solutions. This course provides a broad overview of the main techniques involved in designing and analyzing such algorithms. It also explores connections between algorithms and mathematical fields such as algebra, geometry, and probability. (Dartmouth)

COSC 49.04: Concurrent Algorithms (1) algs

We consider problems where multiple processes have to coordinate their activities to accomplish a task. For an example, suppose that there are many sensing agents on an aircraft and each agent, based on its reading of the environment, has a recommendation on whether the aircraft should keep straight, turn left, or turn right. Since different agents can have different recommendations, we would want a protocol by which they can arrive at an 'agreement' on whether the plane should go left, right, or straight. How hard is it to design such a protocol? It turns out that if you want the protocol to be fault-tolerant, i.e., the protocol works correctly even if one of the agents stops communicating, it is impossible to design a correct protocol (under certain reasonable assumptions about the system). In the course, we will look at several fascinating coordination problems and solve them for several models of distributed computing: shared-memory versus message passing, synchronous versus asynchronous, fault-free versus fault-tolerant. We design algorithms, and prove lower bounds or even impossibility results. There will be weekly homework and a final exam. (Dartmouth)

COSC 49.06: Approximation Algorithms (1) algs

Many problems arising in computer science are NP-hard and therefore we do not expect polynomial time algorithms solving them exactly. This has led to the study of approximation algorithms where one relaxes the goal to return approximate solutions. Over the past three decades, a beautiful theory of approximation algorithms has emerged. This course will provide a broad overview of the main techniques and will often deep dive into the state-of-the-art. (Dartmouth)

COSC 49.07: 21st Century Algorithms (1) algs

The new century has brought us a new class of computational problems and paradigms, and to tackle them a suite of new algorithmic ideas have emerged. In this course, we will look at a collection of such ideas which are fundamental and yet not covered in a first course in undergraduate algorithms. (For instance, in fact, almost all algorithms covered in CS 31 are from last century). A rough set of problems and ideas are: random sampling algorithms, sketching algorithms, streaming algorithms, clustering algorithms, learning algorithms, etc, etc. (Dartmouth)

COSC 49.09: Introduction to Computational Topology (1) algs

Topology is the art of studying shapes without precise measurements. It is not surprising then that topology has found many applications in computer science, both in theoretical and applied research including algorithms and complexity theory, data analysis, robotics, computer graphics, etc., where often the input data is geometrically constrained, or noisy due to measurement errors. The course serves as an introduction to the rapidly growing area(s) of computational topology. (Dartmouth)

COSC 49.10: Randomized Algorithms (1) algs

COSC 49.11: Metric Embedding and Sketching (1) algs

In data analysis we can often assume the input is drawn from a metric space associated with some well-behaved distance function. In such scenario one can hope to find an alternative representation — an embedding — of the input data without sacrificing the distance information too much. To our surprise, not only this is possible, but often times one can also perform a sketching to reduce the size and amount of the data required. This seminar-style course is aimed to introduce the various ways to encode metric spaces in a succinct fashion with minimal distortion, suitable for their algorithmic purposes. Naturally, due to the vast amount of work and literature in the area, the topics covered in this class will be biased towards the interest and expertise of the instructor. (Dartmouth)

CPS 222: Computer Science III (1) algs

This course will prepare students for advanced computer science courses. Using a production-level programming language as a tool, students will implement advanced data structures and algorithms. Students will also study advanced programming concepts and strategies for algorithm development and analysis. Through programming projects, students will explore complex tree structures, graph algorithms, greedy algorithms, dynamic programming, divide-and-conquer algorithms, and parallelism/concurrency. (F&M)

CPS 261: Algorithms (1) algs

Trees, graphs and networks; further analysis of algorithms and their efficiency. (F&M)

CS 3510: Design and Analysis of Algorithms (3) algs

Basic techniques of design and analysis of efficient algorithms for standard computational problems. NP-Completeness. Credit not allowed for both CS 3510 and CS 3511. (Georgia Tech)

CS 3511: Design and Analysis of Algorithms, Honors (3) algs

Techniques of design and analysis of efficient algorithms for standard computational problems. NP-Completeness Project. Credit not allowed for both CS 3511 and CS 3510. (Georgia Tech)

CS 4520: Approximation Algorithms (3) algs

Approximation algorithms for NP-hard optimization problems, design and analysis techniques for such algorithms. (Georgia Tech)

CS 4530: Randomized Algorithms (3) algs

Efficient randomized algorithms with improved performance over deterministic algorithms, or for NP-hard optimization problems, design and analysis techniques for such algorithms. (Georgia Tech)

CS 4540: Advanced Algorithms (3) algs

Advanced techniques for designing and analyzing efficient algorithms for combinatorial, algebraic, and number theoretic problems. (Georgia Tech)

COMPSCI 1240: Data Structures and Algorithms (4) algs

Design and analysis of efficient algorithms and data structures. Algorithm design methods, graph algorithms, approximation algorithms, and randomized algorithms are covered. (Harvard)

COMPSCI 2241: Algorithms at the Ends of the Wire (4) algs

Covers topics related to algorithms for big data, especially related to networks and database systems. Themes include sketch-based data structures, compression, graph and link information, and information theory. Requires a major final research-based project. (Harvard)

COMPSCI 2242: Probabilistic Analysis and Algorithms (4) algs

Probabilistic techniques and tools for the design and analysis of algorithms. Designed for all first-year graduate students in all areas. (Harvard)

COMPSCI 2243: Algorithms for Data Science (4) algs

This is a graduate topics class on algorithmic challenges in modern machine learning and data science. We will touch upon a number of domains (generative modeling, deep learning theory, robust statistics, Bayesian inference) and frameworks for algorithm design (spectral/tensor methods, moment methods, message passing, diffusions), focusing on provable guarantees. The theory draws upon a range of techniques from stochastic calculus, harmonic analysis, statistical physics, algebra, and beyond. We will also explore the myriad modeling challenges in building this theory and prominent paradigms (semi-random models, smoothed complexity, oracles) for going beyond traditional worst-case analysis. (Harvard)

MIT 6.5210: Advanced Algorithms (4) algs

First-year graduate subject in algorithms. Emphasizes fundamental algorithms and advanced methods of algorithmic design, analysis, and implementation. Surveys a variety of computational models and the algorithms for them. Data structures, network flows, linear programming, computational geometry, approximation algorithms, online algorithms, parallel algorithms, external memory, streaming algorithms. (Harvard)

6.1210: Introduction to Algorithms (12) algs

Introduction to mathematical modeling of computational problems, as well as common algorithms, algorithmic paradigms, and data structures used to solve these problems. Emphasizes the relationship between algorithms and programming, and introduces basic performance measures and analysis techniques for these problems. (MIT)

6.1220: Design and Analysis of Algorithms (12) algs

Techniques for the design and analysis of efficient algorithms, emphasizing methods useful in practice. Topics include sorting; search trees, heaps, and hashing; divide-and-conquer; dynamic programming; greedy algorithms; amortized analysis; graph algorithms; and shortest paths. Advanced topics may include network flow; computational geometry; number-theoretic algorithms; polynomial and matrix calculations; caching; and parallel computing. (MIT)

6.5060: Algorithm Engineering (12) algs

Covers the theory and practice of algorithms and data structures. Topics include models of computation, algorithm design and analysis, and performance engineering of algorithm implementations. (MIT)

6.5210: Advanced Algorithms (12) algs

6.5220: Randomized Algorithms (12) algs

Studies how randomization can be used to make algorithms simpler and more efficient via random sampling, random selection of witnesses, symmetry breaking, and Markov chains. Models of randomized computation. Data structures: hash tables, and skip lists. Graph algorithms: minimum spanning trees, shortest paths, and minimum cuts. Geometric algorithms: convex hulls, linear programming in fixed or arbitrary dimension. Approximate counting; parallel algorithms; online algorithms; derandomization techniques; and tools for probabilistic analysis of algorithms. (MIT)

6.5230: Advanced Data Structures (12) algs

More advanced and powerful data structures for answering several queries on the same data. Such structures are crucial in particular for designing efficient algorithms. Dictionaries; hashing; search trees. Self-adusting data structures; linear search; splay trees; dynamic optimality. Integer data structures; word RAM. Predecessor problem; van Emde Boas priority queues; y-fast trees; fusion trees. Lower bounds; cell-probe model; round elimination. Dynamic graphs; link-cut trees; dynamic connectivity; strings; text indexing; suffix arrays; suffix trees. Static data structures; compact arrays; rank and select. Succinct data structures; tree encodings; implicit data structures. External-memory and cache-oblivious data structures; B-trees; buffer trees; tree layout; ordered-file maintenance. Temporal data structures; persistence; retroactivity. (MIT)

6.5240: Sublinear Time Algorithms (12) algs

Sublinear time algorithms understand parameters and properties of input data after viewing only a minuscule fraction of it. Tools from number theory, combinatorics, linear algebra, optimization theory, distributed algorithms, statistics, and probability are covered. Topics include: testing and estimating properties of distributions, functions, graphs, strings, point sets, and various combinatorial objects. (MIT)

6.5250: Distributed Algorithms (12) algs

Design and analysis of concurrent algorithms, emphasizing those suitable for use in distributed networks. Process synchronization, allocation of computational resources, distributed consensus, distributed graph algorithms, election of a leader in a network, distributed termination, deadlock detection, concurrency control, communication, and clock synchronization. Special consideration given to issues of efficiency and fault tolerance. Formal models and proof methods for distributed computation. (MIT)

6.5310: Geometric Folding Algorithms: Linkages, Origami, Polyhedra (12) algs

Covers discrete geometry and algorithms underlying the reconfiguration of foldable structures, with applications to robotics, manufacturing, and biology. Linkages made from one-dimensional rods connected by hinges: constructing polynomial curves, characterizing rigidity, characterizing unfoldable versus locked, protein folding. Folding two-dimensional paper (origami): characterizing flat foldability, algorithmic origami design, one-cut magic trick. Unfolding and folding three-dimensional polyhedra: edge unfolding, vertex unfolding, gluings, Alexandrov's Theorem, hinged dissections. (MIT)

6.5320: Geometric Computing (12) algs

Introduction to the design and analysis of algorithms for geometric problems, in low- and high-dimensional spaces. Algorithms: convex hulls, polygon triangulation, Delaunay triangulation, motion planning, pattern matching. Geometric data structures: point location, Voronoi diagrams, Binary Space Partitions. Geometric problems in higher dimensions: linear programming, closest pair problems. High-dimensional nearest neighbor search and low-distortion embeddings between metric spaces. Geometric algorithms for massive data sets: external memory and streaming algorithms. Geometric optimization. (MIT)

6.5340: Topics in Algorithmic Game Theory (12) algs

Presents research topics at the interface of computer science and game theory, with an emphasis on algorithms and computational complexity. Explores the types of game-theoretic tools that are applicable to computer systems, the loss in system performance due to the conflicts of interest of users and administrators, and the design of systems whose performance is robust with respect to conflicts of interest inside the system. Algorithmic focus is on algorithms for equilibria, the complexity of equilibria and fixed points, algorithmic tools in mechanism design, learning in games, and the price of anarchy. (MIT)

6.5350: Matrix Multiplication and Graph Algorithms (12) algs

Explores topics around matrix multiplication (MM) and its use in the design of graph algorithms. Focuses on problems such as transitive closure, shortest paths, graph matching, and other classical graph problems. Explores fast approximation algorithms when MM techniques are too expensive. (MIT)

CS 3000: Algorithms and Data (4) algs

Introduces the basic principles and techniques for the design, analysis, and implementation of efficient algorithms and data representations. Discusses asymptotic analysis and formal methods for establishing the correctness of algorithms. Considers divide-and-conquer algorithms, graph traversal algorithms, and optimization techniques. Introduces information theory and covers the fundamental structures for representing data. Examines flat and hierarchical representations, dynamic data representations, and data compression. Concludes with a discussion of the relationship of the topics in this course to complexity theory and the notion of the hardness of problems. (Northeastern)

CS 4810: Advanced Algorithms (4) algs

Builds on CS 3000. Presents an advanced study of computer algorithms. Covers basic algorithmic paradigms (e.g., greedy, divide-and-conquer, and dynamic programming); graph algorithms; optimization; computational Intractability (e.g., NP-completeness, PSPACE-completeness); randomized algorithms; and approximation algorithms. (Northeastern)

COMP_SCI 214-0: Data Structures & Algorithms (1) algs

Design, implementation, and performance analysis of abstract data types; data structures and their algorithms. Topics include fundamental collection classes, tree and graph representations and walks, search trees, sorting, priority queues and heaps, least-cost paths computations, and disjoint-set structures. Required for the computer science degree. (Northwestern)

COMP_SCI 336-0: Design & Analysis of Algorithms (1) algs

Analysis techniques and algorithm design techniques including sorting and selection algorithms, order statistics, heaps, and priority queues. (Northwestern)

CSCI 140: Algorithms (1) algs

Algorithm design, computer implementation and analysis of efficiency. Discrete structures, sorting and searching, parsing, pattern matching and data management. Reducibility and theoretical limitations. (Pomona)

CSCI 143: Applied Algorithms (1) algs

In this course we will look at how algorithms are used in systems such as those for making recommendations and for processing images. We will discuss technical issues that can arise and social questions that can be raised when theoretical algorithms are deployed in practice. Students will implement algorithms, read papers, write reflective essays, and complete a research-oriented final project. (Pomona)

CSCI 181Q: Graph Algorithm and Application (1) algs

This course will cover graph algorithms with a special focus on how theoretical algorithms are adapted and used in practice to solve real world problems. Topics may include: finding shortest paths, graph coloring, finding cliques, stable matchings, and graph drawing. Projects will involve both adapting and implementing algorithms discussed in class. (Pomona)

COS 226: Algorithms and Data Structures (1) algs

This course surveys the most important algorithms and data structures in use on computers today. Particular emphasis is given to algorithms for sorting, searching, and string processing. Fundamental algorithms in a number of other areas are covered as well, including geometric algorithms, graph algorithms, and some numerical algorithms. The course will concentrate on developing implementations, understanding their performance characteristics, and estimating their potential effectiveness in applications. Two online lectures, two class meetings, one precept. G. Kol, K. Wayne (Princeton)

COS 343: Algorithms for Computational Biology (1) algs

This course introduces algorithms for analyzing DNA, RNA, and protein, the three fundamental molecules in the cell. Students will learn algorithms on strings, trees, and graphs and their applications in: sequence comparison and alignment; molecular evolution and comparative genomics; DNA sequencing and assembly; recognition of genes and regulatory elements; and RNA structure and protein interaction networks. Students will also implement algorithms and apply them to biological data. (Princeton)

COS 423: Theory of Algorithms (1) algs

Design and analysis of efficient data structures and algorithms. General techniques for building and analyzing algorithms. Introduction to NP-completeness. (Princeton)

COS 451: Computational Geometry (1) algs

Introduction to basic concepts of geometric computing, illustrating the importance of this new field for computer graphics, solid modelling, robotics, databases, pattern recognition, and statistical analysis. Algorithms for geometric problems. Fundamental techniques, for example, convex hulls, Voronoi diagrams, intersection problems, multidimensional searching. (Princeton)

CS 21100: Competitive Programming I (2) algs

CP1 teaches applied algorithmic ideas and problem solving techniques to solve programming interview and competitive programming questions including usage of basic data structures such as [array, set, map, stack, queue, deque, priority queue], the four main algorithm paradigms: [complete search, greedy, divide and conquer, dynamic programming], other algorithmic ideas including [binary search the answer/bisection, meet-in-the-middle, prefix sum and difference arrays, two pointers, sliding window], and basic graph algorithms covering [strongly/connected components, floodfill, topological sort, shortest paths]. (Purdue)

CS 25300: Data Structures And Algorithms For DS/AI (3) algs

This course gives a broad introduction to the most important data structures and algorithms in computer science. The emphasis is on data structures and their use in algorithms relevant for data science and AI and their applications. The course focuses on developing and comparing efficient implementations, assessing suitability of data structures for massive data sets, and understanding effective use, modifications, and extensions. (Purdue)

CS 31100: Competitive Programming II (2) algs

CP2 teaches experienced programmers additional techniques to solve interview and competitive programming problems and builds on material learned in CP1. This includes specific algorithmic techniques such as [shortest paths, topological sort, MST, union find, range queries], advanced algorithms surrounding trees and DAGs, advanced problem types in [dynamic programming, backtracking/simulation, mathematics, string processing], and more. It can be viewed as a programming complement to CS 38100, with some overlap in content. (Purdue)

CS 38100: Introduction To The Analysis Of Algorithms (3) algs

Techniques for analyzing the time and space requirements of algorithms. Application of these techniques to sorting, searching, pattern-matching, graph problems, and other selected problems. Brief introduction to the intractable (NP-hard) problems. (Purdue)

CS 41100: Competitive Programming III (2) algs

CP3 teaches experienced programmers additional techniques to solve competitive programming problems and builds on material learned in CP1 and CP2. This includes algorithmic techniques in topics such as [network flow, computational geometry, graph matching, NP-hard problems]. Primarily, CP3 prepares students to compete in programming contests, which means most class time is focused on simulating contest environments and teaching teamwork and communication alongside problem practice. (Purdue)

COMP 182: Algorithmic Thinking (4) algs

Algorithms are the engines of a great majority of systems, natural and artificial alike. This course introduces algorithmic thinking as a discipline for reasoning about systems, taming their complexities, and elucidating their properties. Algorithmic techniques, along with their correctness and efficiency, will be taught through reasoning about systems of interactions, such as markets, that are ubiquitous in our highly connected world. (Rice)

COMP 380: Practical Problem-Solving (3) algs

We introduce algorithms, algorithmic techniques, and some discrete math with a decidedly practical bent. This will improve anyone’s programming skills, but with specific application towards programming contests and programming-oriented job interviews. This also provides optional additional preparation for COMP 382. Features both individual and small-group exercises in a hands-on class. (Rice)

COMP 382: Reasoning About Algorithms (4) algs

Writing algorithms is fun, but how are you sure that the algorithm you wrote is flawless? Are there computing tasks for which it is impossible to produce an efficient algorithm, or, for that matter, any algorithm? To answer these questions, you have to learn to perform mathematical reasoning about algorithmic problems and solutions COMP 382 is an introduction to such reasoning techniques. Topics covered would include elementary logic, analysis of the correctness and efficiency of algorithms, and formal computational models like finite automata and Turning machines. On the way, you are also going to learn some new algorithm design techniques. (Rice)

COMP 414: Optimization: Algorithms, Complexity and Approximations (3) algs

The main focus of the course will be on smooth optimization techniques, with applications in machine learning and artificial intelligence. The course will introduce the basics of algorithms on continuous optimization, starting from the classical gradient descent algorithm in convex optimization, towards more sophisticated approaches in non-convex scenarios. The course will explore the fundamental theory, algorithms, complexity and approximations in nonlinear optimization. (Rice)

COMP 416: Genome-Scale Algorithms and Data Structures (3) algs

Since the advent of Sanger Sequencing in 1977, computer scientists have devised algorithms and software tools to interpret and analyze DNA sequences. The field of bioinformatics focuses on computational approaches to solving biological questions. This course serves both as an introduction to widely used algorithms in bioinformatics and a software design course. The class involves a semester-long software design and implementation project, emphasizing design patterns and high-performance computing. No prior knowledge of biology is assumed nor required. (Rice)

COMP 458: Quantum Computing Algorithms (3) algs

Quantum computing is an emerging field with the potential to revolutionize various industries, including cryptography, scientific computation, optimization, and machine learning. Quantum Computing Algorithms is a course designed to introduce students to the foundations and practical algorithms of quantum computing from a systems perspective to equip them for the evolving technological landscape. The course will first refresh students on required mathematical concepts in linear algebra, probabilities, and statistics. Students will also learn about fundamental quantum principles, including superposition, entanglement, reversibility, interference, and circuits. The course will then delve into advanced quantum algorithms, especially variational and parameterized codes, including search, optimization, machine learning, and quantum simulation. Students will gain hands-on experience with Python-based quantum programming languages, Cirq and Tensorflow Quantum, to program current quantum computers. (Rice)

COMP 474: Computational Genomics for Microbial Forensics (3) algs

This course covers computational approaches, including algorithms (divide and conquer, greedy, randomized) and data structures (suffix arrays, suffix trees, de bruijn graphs) that have served as the foundation for computational analyses and real-time tracking of infectious diseases. The course is organized into four themed modules, and each module features several seminal computational advances leading to real-world applications spanning the past three decades. The students prepare written summaries of each computational advance, as well as prepare in-class presentations, to both reinforce learning and embed communication into the class. The course also features quizzes (on Canvas) and a midterm and final exam to assess learning of the key computational concepts covered in this course. (Rice)

COMP 480: Probabilistic Algorithms and Data Structure (4) algs

This course will be ideal for someone wanting to build a strong foundation in the theory and practice of algorithms for processing Big-Data. We will discuss advanced data structures and algorithms going beyond deterministic setting and emphasize the role of randomness in getting significant, often exponential, improvements in computations and memory. (Rice)

CSSE 473: Design and Analysis of Algorithms (4) algs

Students study techniques for designing algorithms and for analyzing the time and space efficiency of algorithms. The algorithm design techniques include divide-and-conquer, greedy algorithms, dynamic programming, randomized algorithms and parallel algorithms. The algorithm analysis includes computational models, best/average/worst case analysis, and computational complexity (including lower bounds and NP-completeness). (Rose-Hulman)

CS 161: Design and Analysis of Algorithms (35) algs

Worst and average case analysis. Recurrences and asymptotics. Efficient algorithms for sorting, searching, and selection. Data structures: binary search trees, heaps, hash tables. Algorithm design techniques: divide-and-conquer, dynamic programming, greedy algorithms, amortized analysis, randomization. Algorithms for fundamental graph problems: minimum-cost spanning tree, connected components, topological sort, and shortest paths. Possible additional topics: network flow, string searching. (Stanford)

CS 161ACE: Problem-Solving Lab for CS 161 (1) algs

Additional problem solving practice for CS 161. Sections are designed to allow students to acquire a deeper understanding of CS and its applications, work collaboratively, and develop a mastery of the material. Concurrent enrollment in CS 161 required. Limited enrollment, permission of instructor, and application required. (Stanford)

CS 166: Data Structures (34) algs

This course is a deep dive into the design, analysis, implementation, and theory of data structures. Over the course of the quarter, we'll explore fundamental techniques in data structure design (isometries, amortization, randomization, etc.) and explore perspectives and intuitions useful for developing new data structures. We'll do so by surveying classic data structures like Fibonacci heaps and suffix trees, as well as more modern data structures like count-min sketches and range minimum queries. By the time we've finished, we'll have seen some truly beautiful strategies for solving problems efficiently. (Stanford)

CS 168: The Modern Algorithmic Toolbox (34) algs

This course will provide a rigorous and hands-on introduction to the central ideas and algorithms that constitute the core of the modern algorithms toolkit. Emphasis will be on understanding the high-level theoretical intuitions and principles underlying the algorithms we discuss, as well as developing a concrete understanding of when and how to implement and apply the algorithms. The course will be structured as a sequence of one-week investigations; each week will introduce one algorithmic idea, and discuss the motivation, theoretical underpinning, and practical applications of that algorithmic idea. Each topic will be accompanied by a mini-project in which students will be guided through a practical application of the ideas of the week. Topics include hashing, dimension reduction and LSH, boosting, linear programming, gradient descent, sampling and estimation, and an introduction to spectral techniques. (Stanford)

CS 261: Optimization and Algorithmic Paradigms (3) algs

Algorithms for network optimization: max-flow, min-cost flow, matching, assignment, and min-cut problems. Introduction to linear programming. Use of LP duality for design and analysis of algorithms. Approximation algorithms for NP-complete problems such as Steiner Trees, Traveling Salesman, and scheduling problems. Randomized algorithms. Introduction to sub-linear algorithms and decision making under uncertainty. (Stanford)

CS 263: Counting and Sampling (3) algs

This course will cover various algorithm design techniques for two intimately connected class of problems: sampling from complex probability distributions and counting combinatorial structures. A large part of the course will cover Markov Chain Monte Carlo techniques: coupling, stationary times, canonical paths, Poincare and log-Sobolev inequalities. Other topics include correlation decay in spin systems, variational techniques, holographic algorithms, and polynomial interpolation-based counting. (Stanford)

CS 265: Randomized Algorithms and Probabilistic Analysis (CME 309) (3) algs

Randomness pervades the natural processes around us, from the formation of networks, to genetic recombination, to quantum physics. Randomness is also a powerful tool that can be leveraged to create algorithms and data structures which, in many cases, are more efficient and simpler than their deterministic counterparts. This course covers the key tools of probabilistic analysis, and application of these tools to understand the behaviors of random processes and algorithms. (Stanford)

CS 361: Engineering Design Optimization (34) algs

Design of engineering systems within a formal optimization framework. This course covers the mathematical and algorithmic fundamentals of optimization, including derivative and derivative-free approaches for both linear and non-linear problems, with an emphasis on multidisciplinary design optimization. Topics will also include quantitative methodologies for addressing various challenges, such as accommodating multiple objectives, automating differentiation, handling uncertainty in evaluations, selecting design points for experimentation, and principled methods for optimization when evaluations are expensive. Applications range from the design of aircraft to automated vehicles. (Stanford)

CS 366: Computational Social Choice (3) algs

An in-depth treatment of algorithmic and game-theoretic issues in social choice. Topics include common voting rules and impossibility results; ordinal vs cardinal voting; market approaches to large scale decision making; voting in complex elections, including multi-winner elections and participatory budgeting; protocols for large scale negotiation and deliberation; fairness in societal decision making;nalgorithmic approaches to governance of modern distributed systems such as blockchains and community-mediated social networks; opinion dynamics and polarization. (Stanford)

CS 368: Algorithmic Techniques for Big Data (3) algs

Designing algorithms for efficient processing of large data sets poses unique challenges. This course will discuss algorithmic paradigms that have been developed to efficiently process data sets that are much larger than available memory. We will cover streaming algorithms and sketching methods that produce compact datanstructures, dimension reduction methods that preserve geometric structure, efficient algorithms for numerical linear algebra, graph sparsification methods, as well as impossibility results for these techniques. (Stanford)

CS 369O: Optimization Algorithms (3) algs

Fundamental theory for solving continuous optimization problems with provable efficiency guarantees. Coverage of both canonical optimization methods and techniques, e.g. gradient descent, mirror descent, stochastic methods, acceleration, higher-order methods, etc. and canonical optimization problems, critical point computation for non-convex functions, smooth-convex function minimization, regression, linear programming, etc. Focus on provable rates for solving broad classes of prevalent problems including both classic problems and those motivated by large-scale computational concerns. Discussion of computational ramifications, fundamental information-theoretic limits, and problem structure. (Stanford)

CS 369Z: Dynamic Data Structures for Graphs (3) algs

With the increase of huge, dynamically changing data sets there is a raising need for dynamic data structures to represent and process them. This course will present the algorithmic techniques that have been developed for dynamic data structures for graphs and for point sets. (Stanford)

CS 468: Topics in Geometric Algorithms: Non-Euclidean Methods in Machine Learning (3) algs

Contents of this course vary with each offering. Past offerings have included geometric matching, surface reconstruction, collision detection, computational topology, differential geometry for computer scientists, computational symmetry and regularity, data-driven shape analysis, and non-Euclidean methods in machine learning. (Stanford)

CPSC 041: Algorithms (1) algs

The study of algorithms is useful in many diverse areas. As algorithms are studied, considerable attention is devoted to analyzing formally their time and space requirements and proving their correctness. Topics covered include abstract data types, trees (including balanced trees), graphs, searching, sorting, NP complete optimization problems, and the impact of several models of parallel computation on the design of algorithms and data structures. (Swarthmore)

CPSC 068: Bioinformatics (1) algs sci

This course is an introduction to the fields of bioinformatics and computational biology, with a central focus on algorithms and their application to a diverse set of computational problems in molecular biology. Computational themes will include dynamic programming, greedy algorithms, supervised learning and classification, data clustering, trees, graphical models, data management, and structured data representation. Applications will include genetic sequence analysis, pair wise-sequence alignment, phylogenetic trees, motif finding, gene-expression analysis, and protein-structure prediction. No prior biology experience is necessary. (Swarthmore)

CPSC 091T: Special Topics: Randomized Algorithms (1) algs

In the past 40 years, randomization has proved to be a key tool in the design and analysis of algorithms. Randomized algorithms can be simpler and/or more efficient than deterministic algorithms. It can also better capture several computational problems that arise in nature. This course provides an introduction to algorithm design with a focus on randomized algorithms and data structures. Topics include analysis of algorithms, basics of discrete probability including tail inequalities, the probabilistic method, NP-Completeness, and applications to graph algorithms, streaming algorithms, communication complexity, and machine learning. (Swarthmore)

CSCE 411: Design and Analysis of Algorithms (3) algs

Study of computer algorithms for numeric and non-numeric problems; design paradigms; analysis of time and space requirements of algorithms; correctness of algorithms; NP-completeness and undecidability of problems. (Texas A&M)

CSCE 430: Problem Solving Programming Strategies (3) algs

Methods for analyzing fundamental programming problems from a variety of domains and implementing solutions quickly and efficiently; problems based on competitive programming contests to develop skills in problem analysis, coding and testing; solving problems will involve identifying and applying a range of algorithmic solutions; includes dealing with combinatorics, dynamic programming, graphs, numerical calculations, string processing and geometry, along with other specialized algorithms. (Texas A&M)

CSCE 440: Quantum Algorithms (3) algs

Introduction to the design and analysis of quantum algorithms; basic principles of the quantum circuit model; gives a gentle introduction to basic quantum algorithms; reviews recent results in quantum information processing. (Texas A&M)

CS 160: Algorithms (4) algs

Introduction to the study of algorithms. Strategies such as divide-and-conquer, greedy methods, and dynamic programming. Graph algorithms, sorting, searching, integer arithmetic, hashing, and NP-complete problems. (Tufts)

CS385: Design & Analys-Algorithms (3) algs

This course studies analysis of algorithms and the relevance of analysis to the design of efficient computer algorithms. Algorithmic approaches covered include greedy, divide and conquer, and dynamic programming. Topics include sorting, searching, graph algorithms, and disjoint set structure. (West Point)

CS 170: Efficient Algorithms and Intractable Problems (4) algs

Concept and basic techniques in the design and analysis of algorithms; models of computation; lower bounds; algorithms for optimum search trees, balanced trees and UNION-FIND algorithms; numerical and algebraic algorithms; combinatorial algorithms. Turing machines, how to count steps, deterministic and nondeterministic Turing machines, NP-completeness. Unsolvable and intractable problems. (Berkeley)

CS 176: Algorithms for Computational Biology (4) algs

Algorithms and probabilistic models that arise in various computational biology applications: suffix trees, suffix arrays, pattern matching, repeat finding, sequence alignment, phylogenetics, genome rearrangements, hidden Markov models, gene finding, motif finding, stochastic context free grammars, RNA secondary structure. There are no biology prerequisites for this course, but a strong quantitative background will be essential. (Berkeley)

CS C176: Algorithms for Computational Biology (4) algs

This course will provide familiarity with algorithms and probabilistic models that arise in various computational biology applications, such as suffix trees, suffix arrays, pattern matching, repeat finding, sequence alignment, phylogenetics, hidden Markov models, gene finding, motif finding, linear/logistic regression, random forests, convolutional neural networks, genome-wide association studies, pathogenicity prediction, and sequence-to-epigenome prediction. (Berkeley)

CS C177: Algorithmic Economics (4) algs

The class provides an introduction to algorithmic questions in economic design. The class will cover problems of public goods and social choice, as well as allocative questions and private consumption. The focus is on normative questions: From the perspective of social goals, these are efficiency, fairness, and equity. In terms of private goals, the focus is on revenue maximization. The course will cover voting, fair division, pricing and market mechanisms. There is an emphasis on the algorithmic questions that arise naturally in economic design. (Berkeley)

CSE 100: Advanced Data Structures (4) algs

High-performance data structures and supporting algorithms. Use and implementation of data structures like (un)balanced trees, graphs, priority queues, and hash tables. Also, memory management, pointers, recursion. Theoretical and practical performance analysis, both average case and amortized. Uses C++ and STL. (UCSD)

CSE 100R: Advanced Data Structures (4) algs

High-performance data structures and supporting algorithms. Use and implementation of data structures like (un)balanced trees, graphs, priority queues, and hash tables. Also memory management, pointers, recursion. Theoretical and practical performance analysis, both average case and amortized. Uses C++ and STL. This course is a distance education course. Students may not receive credit for both CSE 100R and CSE 100. (UCSD)

CSE 101: Design and Analysis of Algorithms (4) algs

Design and analysis of efficient algorithms with emphasis of nonnumerical algorithms such as sorting, searching, pattern matching, and graph and network algorithms. Measuring complexity of algorithms, time and storage. NP-complete problems. (UCSD)

CSE 181: Molecular Sequence Analysis (4) algs

This course covers the analysis of nucleic acid and protein sequences, with an emphasis on the application of algorithms to biological problems. Topics include sequence alignments, database searching, comparative genomics, and phylogenetic and clustering analyses. (UCSD)

CMPSC 130A: Data Structures and Algorithms I (4) algs

Data structures and applications with proofs of correctness and analysis. Hash tables, priority queues (heaps); balanced search trees. Graph traversal techniques and their applications. (UCSB)

CMPSC 130B: Data Structures and Algorithms II (4) algs

Design and analysis of computer algorithms. Correctness proofs and solution of recurrence relations. Design techniques; divide and conquer, greedy strategies, dynamic programming. Applications of techniques to problems from several disciplines. NP-completeness. (UCSB)

CS 277: Algorithms and Data Structures for Data Science (4) algs

Introduction to elementary concepts in algorithms and classical data structures with a focus on their applications in Data Science. Topics include algorithm analysis, elementary data structures, discrete algorithm design principles, and discussion of discrete and continuous optimization. (Illinois)

CS 374: Introduction to Algorithms & Models of Computation (4) algs

Analysis of algorithms, major paradigms of algorithm design including recursive algorithms, divide-and-conquer algorithms, dynamic programming, greedy algorithms, and graph algorithms. Formal models of computation including finite automata and Turing machines. Limitations of computation arising from fundamental notions of algorithm and from complexity-theoretic constraints. Reductions, undecidability and NP-completeness. (Illinois)

CS 403: Accelerated Fundamentals of Algorithms II (3) algs

The second class in a sequence of two classes that introduces students to the theoretical foundations of computer science. Topics include major paradigms of algorithm design divide and conquer, greedy, recursive, and dynamic programming; solving recurrences and analysis of divide and conquer algorithms; graph algorithms; formal models of computations like finite state automata and Turing machines; reductions. (Illinois)

CS 473: Algorithms (4) algs

Design and analysis techniques, approximation algorithms, randomized algorithms and amortized analysis, and advanced topics such as network flow, linear programming, and dynamic data structures, among others. (Illinois)

CS 313: Intermediate Data Structures (4) algs

Design and analysis of data structures as means of engineering efficient software; attention to data abstraction and encapsulation. Lists, trees, heaps, stacks, queues, dictionaries, priority queues. (UO)

CS 315: Intermediate Algorithms (4) algs

Algorithm design, worst-case and average-behavior analysis, correctness, computational complexity. (UO)

CS 413: Advanced Data Structures (4) algs

Complex structures, storage management, sorting and searching, hashing, storage of texts, and information compression. (UO)

CIS 3200: Introduction to Algorithms (1) algs

How do you optimally encode a text file? How do you find shortest paths in a map? How do you design a communication network? How do you route data in a network? What are the limits of efficient computation? This course gives a comprehensive introduction to design and analysis of algorithms, and answers along the way to these and many other interesting computational questions. You will learn about problem-solving; advanced data structures such as universal hashing and red-black trees; advanced design and analysis techniques such as dynamic programming and amortized analysis; graph algorithms such as minimum spanning trees and network flows; NP-completeness theory; and approximation algorithms. (Penn)

CIS 3340: Advanced Topics in Algorithms (1) algs

Can you check if two large documents are identical by examining a small number of bits? Can you verify that a program has correctly computed a function without ever computing the function? Can students compute the average score on an exam without ever revealing their scores to each other? Can you be convinced of the correctness of an assertion without ever seeing the proof? The answer to all these questions is in the affirmative provided we allow the use of randomization. Over the past few decades, randomization has emerged as a powerful resource in algorithm desgin. This course would focus on powerful general techniques for designing randomized algorithms as well as specific representative applications in various domains, including approximation algorithms, cryptography and number theory, data structure design, online algorithms, and parallel and distributed computation. (Penn)

CIS 5020: Analysis of Algorithms (1) algs

An investigation of paradigms for design and analysis of algorithms. The course will include dynamic programming, flows and combinatorial optimization algorithms, linear programming, randomization and a brief introduction to intractability and approximation algorithms. The course will include other advanced topics, time permitting. (Penn)

CSCI 270: Introduction to Algorithms and Theory of Computing (4) algs

Algorithm analysis. Greedy algorithms, divide and conquer, dynamic programming, graph algorithms. NP-completeness and basic recursion theory and undecidability. Sorting lower bounds. Number-theory based cryptography. (USC)

CMPU 241: Analysis of Algorithms (1) algs

Introduces the systematic study of algorithms and their analysis with regard to time and space complexity. Topics include divide-and-conquer, dynamic programming, greediness, randomization, upper and lower-bound analysis, and introduction to NP completeness. Emphasis is placed on general design and analysis techniques that underlie algorithmic paradigms. Builds a foundation for advanced work in computer science. (Vassar)

CSE 247: Data Structures and Algorithms (3) algs

Study of fundamental algorithms, data structures, and their effective use in a variety of applications. Emphasizes importance of data structure choice and implementation for obtaining the most efficient algorithm for solving a given problem. A key component of this course is worst-case asymptotic analysis, which provides a quick and simple method for determining the scalability and effectiveness of an algorithm. Online textbook purchase required. (Washington U.)

CSE 341T: Parallel and Sequential Algorithms (3) algs

The course aims to teach students how to design, analyze and implement parallel algorithms. The emphasis is on teaching fundamental principles and design techniques that easily transfer over to parallel programming. These techniques include divide and conquer, contraction, the greedy method, and so on. (Washington U.)

CSE 347: Analysis of Algorithms (3) algs

This course introduces techniques for the mathematical analysis of algorithms, including randomized algorithms and non-worst-case analyses such as amortized and competitive analysis. It also introduces the standard paradigms of divide-and-conquer, greedy, and dynamic programming algorithms, as well as reductions, and it provides an introduction to the study of intractability and techniques to determine when good algorithms cannot be designed. (Washington U.)

CS 231: Fundamental Algorithms (1) algs

An introduction to the design and analysis of fundamental algorithms. General techniques covered: divide-and-conquer algorithms, dynamic programming, greediness, probabilistic algorithms. Topics include: sorting, searching, graph algorithms, compression, cryptography, computational geometry, and NP-completeness. (Wellesley)

CS 331: Advanced Algorithms (1) algs

Explore advanced topics in the design and analysis of algorithms and data structures. The focus is on expanding your toolkit of problem-solving techniques and considering new settings that model real-world challenges. Topics may include: randomization, approximation algorithms, online and streaming settings, parallel and distributed computing, linear programming and LP rounding, optimization under uncertainty, bias and fairness in algorithms, and algorithmic foundations of data science and machine learning. (Wellesley)

COMP 312: Algorithms and Complexity (1) algs

The course will cover the design and analysis of correct and efficient algorithms. Basic topics will include greedy algorithms, divide-and-conquer algorithms, dynamic programming, and graph algorithms. Some advanced topics in algorithms may be selected from other areas of computer science. (Wesleyan)

CSCI 256: Algorithm Design and Analysis (1) algs

This course investigates methods for designing efficient and reliable algorithms. By carefully analyzing the structure of a problem within a mathematical framework, it is often possible to dramatically decrease the computational resources needed to find a solution. In addition, analysis provides a method for verifying the correctness of an algorithm and accurately estimating its running time and space requirements. We will study several algorithm design strategies that build on data structures and programming techniques introduced in Computer Science 136. These include greedy, divide-and-conquer, dynamic programming, and network flow algorithms. Additional topics of study include algorithms on graphs and strategies for handling potentially intractable problems. (Williams)

CSCI 356: Advanced Algorithms (1) algs

This course explores advanced concepts in algorithm design, algorithm analysis and data structures. Areas of focus will include algorithmic complexity, randomized and approximation algorithms, geometric algorithms, and advanced data structures. Topics will include combinatorial algorithms for packing, and covering problems, algorithms for proximity and visibility problems , linear programming algorithms, approximation schemes, hardness of approximation, search, and hashing. (Williams)

CSCI 358: Applied Algorithms (1) algs

This course is about bridging the gap between theoretical running time and writing fast code in practice. The course is divided into two basic topics. The first is algorithmic: we will discuss some of the most useful tools in a coder's toolkit. This includes topics like randomization (hashing, filters, approximate counters), linear and convex programming, similarity search, and cache-efficient algorithms. Our goal is to talk about why these efficient algorithms make seemingly difficult problems solvable in practice. The second topic is applications: we will discuss how to implement algorithms in an efficient way that takes advantage of modern hardware. Specific topics covered will include blocking, loop unrolling, pipelining, as well as strategies for performance analysis. Projects and assessments will include both basic theoretical aspects (understanding why the algorithms we discuss actually work), and practical aspects (implementing the algorithms we discuss to solve important problems, and optimizing the code so it runs as quickly as possible). (Williams)

CPSC 365: Algorithms (1) algs

Paradigms for algorithmic problem solving: greedy algorithms, divide and conquer, dynamic programming, and network flow. NP completeness and approximation algorithms for NP-complete problems. (Yale)