Algorithms for GATE CSE 2027: Important Topics and Patterns

The most important Algorithms topics for GATE CSE 2027 are time complexity and recurrences, minimum spanning trees, Dijkstra and shortest-path properties, DFS, and dynamic programming. Analysts put the subject at roughly 8 marks a paper. It is also among the hardest, because most questions test a subtle property rather than a formula.

Key takeaways

• The Algorithms syllabus is unchanged for 2027. NP-completeness is not named in it.
• Analyst compilations put Algorithms at about 8.3 marks per paper on average from 2009 to 2026. In 2026 Shift 1 it was the heaviest core subject, at 10 marks.
• Four families have near-unbroken runs from 2018 to 2026: code complexity and recurrences, quicksort and merge sort counting, MST, and Dijkstra and shortest paths.
• Dynamic programming questions increasingly give you a new problem and ask you to build the recurrence yourself. This was what made the 2026 papers hard.
• MSQs with four true/false statements on asymptotics, MSTs and shortest paths have become common since 2021. They often include the false converse of a well-known theorem.

What the GATE 2027 Algorithms syllabus says

The official 2027 syllabus reads: "Searching, sorting, hashing. Asymptotic worst case time and space complexity. Algorithm design techniques: greedy, dynamic programming and divide-and-conquer. Graph traversals, minimum spanning trees, shortest paths."

This is identical to 2026. Two points matter for planning. First, NP-completeness is not in the text: it was a regular 1-mark item from 2003 to 2018, but it has not appeared from 2023 to 2026. Second, recurrences and graph theory overlap with Discrete Mathematics. Revise them together with Engineering Mathematics. Confirm the wording at gate2027.iitm.ac.in.

How many marks Algorithms carries

These are third-party analyst compilations (gateexam.info, GeeksforGeeks, careers360, goclasses.in), not official figures. Analysts disagree on whether recurrences, C-code complexity and graph theory count as Algorithms, so any single year can be off by 2–3 marks.

The small drop between the two periods is within classification noise. The honest reading is flat at around 8 marks. The mix has changed, though: there are fewer 1-mark definition questions and more 2-mark NAT and MSQ items that combine two ideas. For a comparison across subjects, see GATE CSE subject-wise weightage.

The most-tested Algorithms topics and how they are asked

The years are reconstructed from PYQ repositories and are approximate.

1. Complexity of code and recurrences

Some form of loop or code complexity question appears in essentially every paper. Typical questions: nested loops with i *= 2 or j += i, a while (i * i <= n) loop, or a recursive function with two calls plus a loop. A NAT may ask how many times a statement runs for a specific n. Recurrence questions mix Master theorem cases with forms outside it, such as T(n) = T(√n) + 1 or T(n) = 2T(n/2) + n log n. Newer papers sometimes ask for the exponent k in Θ(n^k) as a NAT.

2. Minimum spanning trees

MST execution (total weight, the k-th edge Kruskal adds, the edges Prim picks from a given vertex) is listed in every year from 2005 to 2026. The property side has grown: MSQs on adding a constant to all weights, squaring weights, the heaviest edge in a cycle, uniqueness, and counting distinct MSTs when weights repeat.

3. Dijkstra and shortest-path properties

Dijkstra appears in every year listed from 2004 to 2026. Question forms: the order vertices are extracted, the distance to a target, the number of relaxations, or a graph with a negative edge where Dijkstra may or may not still give correct answers. Property MSQs test reweighting, subpath optimality and Bellman–Ford pass counts. The 2026 papers added modified conditions such as negative edges and constrained paths.

A quick example of the reweighting trap: suppose A to B directly costs 5, and A to C to B costs 2 + 2 = 4. Add 2 to every edge. The direct path becomes 7 and the two-edge path becomes 8, so the shortest path changes. The MST would not change under the same shift.

4. DFS, BFS and topological order

DFS edge classification, discovery and finish times, and valid orderings appear in every year from 2014 to 2025, and approx. 2026. Counting questions (number of topological orderings, number of SCCs) are rising as NATs.

5. Dynamic programming

Every paper since 2016 has had at least one DP question. Since 2019 it is more often a new problem than a textbook table: count binary strings avoiding a pattern, count grid paths with blocked cells, or find the maximum sum with no two adjacent picks. Classical tables (LCS, matrix chain multiplication, 0/1 knapsack, edit distance) still show up in some papers.

6. Sorting and hashing

Quicksort partition and comparison-count questions appear nearly every year. Merge sort counts, heap-based selection and stability or in-place properties also appear often. Linear probing table-state questions appeared approx. in 2007, 2009, 2010, 2014, 2015, 2017, 2019, 2020, 2021, 2023, 2024 and 2026, usually as a NAT for a key's final slot or the number of probes.

Algorithms priority table for GATE 2027

These tiers come from a weighted eight-factor score covering historical frequency, recent frequency, variety of question forms, syllabus centrality, time since last asked, format fit, IIT Madras history and other evidence. They set study priority. They do not promise any question.

The book's Algorithms chapter scores all 28 subtopics individually, sets out the likely question shapes for each high-priority topic, and adds 50 original practice questions (17 MCQ, 12 MSQ, 21 NAT) with worked solutions. See what the book includes.

How the question format has changed

From 2018 to 2026, NAT count questions made up an estimated 40–50% of Algorithms marks: MST weight, number of MSTs, extraction order, relaxations, comparisons, probes, DP cell values, and number of orderings. NAT has no negative marking, so the real cost is time. The 2026 papers were described as lengthy because of how many hand executions they needed.

MSQs have been used for true/false statement sets since they were introduced in 2021. Asymptotics, MSTs and shortest paths suit this format well, because each has a well-known theorem and a well-known false converse. An MSQ gives no partial credit, so every selected option has to be right. Our guide to MCQ, MSQ and NAT strategy covers how to attempt them.

On IIT Madras: none of its three earlier CS papers (2003, 2011, 2019) gave Algorithms less weight than the average for its era, with 9 marks in 2011 and 6–7 in 2019. Two of the three leaned towards exact-count questions. Three data points are too few for a strong prediction.

Common Algorithms traps

• Dijkstra and negative edges. Dijkstra can fail with a negative edge. That does not mean it always fails.
• MST uniqueness. Distinct weights guarantee a unique MST, but a unique MST does not require distinct weights.
• Adding a constant. Adding the same constant to every edge keeps the MST but can change shortest paths. Multiplying all weights by a positive constant changes neither.
• Shortest-path tree vs MST. They are different trees in general.
• Master theorem gaps. T(n) = 2T(n/2) + n log n is not covered by the basic form. It is Θ(n log² n). T(n) = T(n − 1) + log n is Θ(n log n), not Θ(n).
• Loop counting. An inner loop with j += i sums to Θ(n log n), not Θ(n²). A loop with i = i * i runs Θ(log log n) times.
• Stability and space. Quicksort and heapsort are not stable. Standard merge sort on arrays is not in-place.
• Lower bound. Ω(n log n) applies only to comparison sorts. Counting and radix sort work around it for bounded ranges.
• Binary search on a linked list takes Θ(n), not Θ(log n).
• Greedy coin change works only for some coin systems.
• Hash probes. The usual convention counts every slot examined, including the empty slot where the key lands.
• Undirected DFS has no forward or cross edges.
• Huffman ties. Tie-breaking can change one symbol's code length but not the total bits.

How to prepare Algorithms for GATE 2027

1. Complexity first. Practise loop patterns and recurrences until you can classify them on sight. They feed every other topic and appear in almost every paper.
2. Run graph algorithms by hand. Take 6–8 vertex graphs and run Kruskal, Prim, Dijkstra, Bellman–Ford, DFS and BFS. Write down the tie-breaking and the starting vertex each time. A graph of that size should take about 3–4 minutes.
3. Build a theorem-and-converse list for asymptotics, MSTs and shortest paths. This is your MSQ preparation.
4. DP in two stages. First the classical tables. Then new problems: define the state, write the recurrence, fix the base cases, and compute small values by hand.
5. Sorting and hashing counts. Comparisons, swaps, inversions, partitions, probe sequences and insertion orders.
6. Formulas last. Merging needs at most m + n − 1 comparisons. Finding max and min together takes ⌈3n/2⌉ − 2. Strassen uses 7 multiplications. Build-heap is Θ(n).
7. Skip the low-yield topics until the rest is solid: NP-completeness and search variants.

Algorithms builds on heaps, recursion and graph representation from Programming and Data Structures, so revise them together. The book's 10 full mock tests put these topics into timed, paper-length sets, which matters for a subject where time is the real cost (details).