Week 62: CST370 - Design and Analysis of Algorithms

WK03: Weekly Reflection

This week's module focused on brute force string matching, exhaustive search, depth-first search, breadth-first search, and the introduction to divide and conquer algorithm design. These topics helped me understand different ways algorithms solve problems, from simple direct methods to more organized search and problem-solving strategies.

One thing that stood out to me was brute force string matching. I learned that brute force approaches are often easy to understand because they try possible solutions directly, but they may not always be efficient for large inputs. The examples with string matching helped me see how an algorithm can compare characters step by step and still become expensive as the input grows.

The exhaustive search topics were also useful because they showed how some problems can be solved by checking every possible option. The lectures on the traveling salesperson problem, knapsack problem, and assignment problem helped me understand why exhaustive search can guarantee a correct answer but may require a huge amount of time. This connected well with last week's focus on time efficiency because it showed why analyzing growth rates matters in real problem solving.

I also learned about depth-first search and breadth-first search. Depth-first search helped me understand how an algorithm can explore one path deeply before backtracking, while breadth-first search explores level by level. Comparing DFS and BFS made me think more carefully about how different search strategies affect the order in which a problem is explored. The time efficiency videos and exercises were helpful because they showed that these algorithms can be analyzed systematically, especially when working with graphs.

The divide and conquer materials introduced another important strategy. I learned that divide and conquer solves problems by breaking them into smaller subproblems, solving those subproblems, and then combining the results. The Master Theorem lecture was challenging, but it gave me a useful tool for analyzing recursive algorithms more efficiently.

Overall, this week helped me see that algorithm design is not only about finding an answer, but also about choosing the right strategy. My main takeaway is that brute force and exhaustive search are simple and reliable but can become inefficient, while DFS, BFS, and divide and conquer offer more structured ways to solve problems.

Comments

Post a Comment

Popular posts from this blog

Week 20: CST 363 - Introduction to Database Systems

   WK04:  Midpoint Reflections I'm not new to databases and have some practical experience with SQL, but this course gave me the theoretical backbone for concepts I've used pragmatically. I connected everyday tasks - designing tables, choosing keys, writing joins, and skimming plans - to the relational model and formal normalization. Seeing why clustered vs. heap layouts affect access, how B-tree indexes support equality/range predicates, and where optimizers derive their strategies clarified earlier "rules of thumb." Overall, I gained vocabulary and structure to justify design choices. Brief Summary of 5 Things Learned I strengthened the relational model: entities/attributes, candidate vs. primary keys, and why foreign keys enforce meaning across tables. I practiced expressive SQL beyond basics - joins, subqueries, and aggregates - while reading execution plans to understand scans, seeks, and join algorithms. I deepened constraints and referential integrity to preven...
Read more

Week 11: CST 338 - Software Design

  Week 3 Learning Journal – HW 1 Code Review This week was extremely busy. Between multiple programming assignments, studying for quizzes, and finishing up other coursework, I didn't get a single day off - not even Sunday. I worked through the entire weekend just to keep up. One of the last things I tackled was the code review assignment, not because it was difficult, but because it was worth fewer points compared to other assignments. Ironically, despite being worth less than half of another assignment, it took nearly the same amount of time. Reading, testing, and analyzing other students' code takes real focus - especially when you're trying to give meaningful feedback and not just check a box. But I'll be honest: even though it felt like extra work at first, the peer code review assignment turned out to be one of the most helpful parts of the week. Looking through other people's code - seeing what they did right, where they made mistakes, or how they handled logi...
Read more

Week 17: CST 363 - Introduction to Database Systems

 WK01: Starting CST363 – Introduction to Databases This week I officially started a new course: CST363 – Introduction to Database Systems . The class looks like a solid mix of theory and practice. We'll design relational schemas, practice SQL queries, connect to databases programmatically, and even touch on NoSQL concepts like MongoDB. The syllabus makes it clear that this isn't just about running commands - it's about understanding the underlying algorithms, data structures, and principles that power modern database systems. That excites me, since databases are everywhere, from apps to analytics pipelines. Relational Databases vs. Spreadsheets At first glance, relational database tables and spreadsheets look the same - rows and columns full of data. But digging deeper, the differences are critical. Spreadsheets are flexible but mostly unstructured; you can mix data types freely, create ad hoc formulas, and manually tweak things. Databases, on the other hand, enforce stric...
Read more