Skip to content

A curated collection of Dynamic Programming problems and solutions with clear explanations, optimal approaches, and code implementations.

Notifications You must be signed in to change notification settings

harshagrawal11/DynamicProgramming

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

3 Commits
 
 
 
 
 
 

Repository files navigation

I am the GitHub Copilot Chat Assistant.

File summary

  • Purpose: Computes and prints the Longest Common Subsequence (LCS) of two input strings and its length using dynamic programming and backpointers.
  • Language: Java
  • Entry point: public class Lcs with main method reading two tokens from stdin.

How it works (brief)

  • Builds an (m+1) x (n+1) table of cells that store:
    • v: length of LCS for prefixes up to that cell
    • d: direction/backpointer ('d' = diagonal / match, 'u' = up, 's' = left)
  • Fills the table row by row: when characters match, take diagonal+1; otherwise take the larger of up or left and record direction.
  • Recursively follows backpointers from cost[m][n] to print the LCS in the correct order.
  • Finally prints the LCS and its length.

Known issues / bugs to fix

  • The source defines class C but uses D[][] cost and new D() — mismatch (compile error). Fix by renaming C to D or change D to C.
  • Minor typos in output text ("LENGHT" → "LENGTH").
  • Scanner.next() reads a token (no spaces). If you want full lines use Scanner.nextLine().
  • Direction character 's' is used for left; consider using 'l' for clarity.
  • Class and method naming: consider following Java conventions (class names start with uppercase, methods camelCase).
  • Current implementation stores the whole table (O(m*n) memory). If you only need the length, memory can be reduced to O(min(m,n)).

Time & space complexity

  • Time: O(m * n) where m = length of string a, n = length of string b.
  • Space: O(m * n) for the full DP table and backpointers. Can be reduced to O(min(m,n)) if only the length is required (but not the sequence reconstruction).

Usage / example

  • Compile: javac Lcs.java
  • Run: java Lcs
  • Example interactive run:
    • Input: ENTER STRING 1: AGGTAB ENTER STRING 2: GXTXAYB
    • Output: LONGEST COMMON SUBSEQUENCE IS: GTAB LENGHT OF THE LCS IS: 4

Suggested small corrections (summary)

  • Rename class C → D (or change all D references to C).
  • Fix printed messages spelling.
  • Consider handling full lines with nextLine() if inputs may contain spaces.
  • Optionally change direction markers to clearer names and add comments.
  • Add unit tests or example runs in a README.

If you want, I can:

  • Provide a corrected version of the file (compilable).
  • Produce detailed inline comments or a README.md content for the repo. Which would you prefer?

About

A curated collection of Dynamic Programming problems and solutions with clear explanations, optimal approaches, and code implementations.

Topics

Resources

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published