Monthly Archives: October 2025

Digital Marketing Strategic Plan for Agricultural Enterprises in Vietnam
The document presents the digital transformation orientation for Vietnam's agricultural sector in the 4.0 era. Content includes: market analysis, digital branding with 4 core messages (Clean – Fresh – Convenient – Sustainable), multi-channel strategy (Social Media, SEO, Content, E-commerce), along with a 6-step implementation roadmap and a KPI system for performance measurement.

This is a strategic handbook that helps Vietnamese agricultural enterprises develop sustainably and lead the market in the digital era.

In the context of Vietnam's agriculture entering a period of powerful transformation, digital marketing is no longer an option – it is an inevitable path.
The plan from SeaTek not only provides a modern customer acquisition strategy but also serves as a guiding compass to help agricultural enterprises build a strong brand, increase value, and develop sustainably in the digital era.

Linked List (Linked list) is one of the structured data frameworks in the installer. It is displayed from a a series of nodes, where each node stores the value (value) and a pointer (pointer) points to the next node in the list. This structure is particularly useful when working with dynamic data or performing frequent insertion and deletion operations.

Note: This article is for beginners. The author shares their self-learning process, hoping to inspire and reinforce knowledge for the community. If you already have experience, continue practicing at a higher level or try rewriting and explaining it – as this is the most effective way to memorize and train algorithmic thinking.

1. Understanding Linked Lists through a visual example.

Imagine Linked List like string ticket trên Jira or Trello – each ticket has a link “Next” leads to the next ticket.

In fact, you'll find linked lists in many places:

• Function Undo/Redo Excel or VS Code are prime examples of this. Doubly Linked List:
  • Ctrl + Z → go backward (prev)
  • Ctrl + Y → Go to (next)
• Web browser when you press Back or Forward — that is, you are moving in a Two-way linked list Displays browsing history.

2. Common Types of Linked Lists

Singly Linked List

Each node has only one pointer. next points to the next node.

• Browse words head → tail But there's no turning back.
• Advantages: simple, memory-saving, fast insertion or deletion at the beginning of the list (O(1)).
• Disadvantage: cannot be accessed backward; to find a node previously, you have to traverse from the beginning.
• Typical exercises: LeetCode 206 – Reverse Linked List.

Doubly Linked List

Each node has both pointers. prev and next, allowing for bidirectional browsing.

• Browsing is possible in both directions.
• Inserting/deleting in the middle is more convenient than a single list.
• It takes extra memory to save. prev.
• Caution is needed when updating the cursor to avoid incorrect pointing errors.

Circular Linked List

Last node (tail) points back to the first node (head), forming a closed loop.

• Browsing from any node will traverse the entire list.
• Application in round-robin scheduling or systems that require continuous loops.
• A clear stopping condition needs to be defined to avoid infinite loops.

3. Comparing Linked Lists and Arrays

4. Featured LeetCode exercises

• 206. Reverse Linked List → Reverse the cursor direction using three variables prev, curr, next.
• 141. Linked List Cycle → Detect loops using two fast-slow pointers (fast–slow pointers).
• 21. Merge Two Sorted Lists → Merge the two sorted lists, carefully pointing the pointer correctly.
• 146. LRU Cache → Combine HashMap (O(1) lookup) and Doubly Linked List (O(1) reorder, delete).

5. Basic Python Code Examples

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def insert_head(self, val):
        node = Node(val)
        node.next = self.head
        self.head = node

    def insert_end(self, val):
        node = Node(val)
        if not self.head:
            self.head = node
            return
        curr = self.head
        while curr.next:
            curr = curr.next
        curr.next = node

    def print_list(self):
        curr = self.head
        while curr:
            print(curr.val, end=" -> ")
            curr = curr.next
        print("None")

6. Effective ways to learn and practice

Before you start coding, please Draw a Linked List diagram on paper.Most errors when working with Linked Lists stem from pointing the wrong cursor.pointer), so be sure to understand the direction of next and prev before running the code.

• Focus on four groups of exercises: reverse list, detect cycle, merge lists, remove node, and LRU cache.
• In backend/frontend interviews, you'll often be asked about the trade-off between Arrays and Linked Lists.
• Prepare templates Node and LinkedList To code faster.
• Always consider the time/space complexity beforehand to optimize the solution.

7. The mindset for training is important.

When practicing linked lists, start with a short list: [1 → 2 → 3 → None] or [10 → 20 → 30 → 40 → None].

With a short list, it's easy to observe the changes after each operation. insert, delete, reverseIf you encounter a pointing error, printing a small list helps in quick detection. Once your logic is solid, try a larger test case.

Additionally, please write more. helper function like print_list() or to_array() To visualize the data after each step.

8. Conclusion

• Linked Lists are the foundation of many other data structures such as Stack, Queue, Graph, and Cache.
• Understanding the nature of pointers is more important than memorizing formulas.
• Draw – Simulate – Code – Optimize: that's the most effective learning cycle.

Summary: Mastering Linked Lists will give you a deeper understanding of how data operates in memory and expand your thinking to more complex structures like Trees, Graphs, Heaps, and HashMaps. Understanding the fundamentals first, then optimizing – that's the right mindset when learning algorithms.

This article systemizes the core nature of Dynamic Programming when applied to graph structures. I present it in clear sections to help readers grasp the key focus and approach — especially suitable for beginners or those looking to review the concept.

1. Core Idea

In classical DP problems (e.g., Fibonacci, Knapsack), states usually have a natural order from 1 to n. On graphs, the dependency relationships between nodes do not have a fixed order; therefore, it is necessary to determine an appropriate computation order to ensure that dependencies are satisfied before computing the value of a node.

Topological order is the ordering of vertices in a directed graph such that if a directed edge u → v exists, u appears before v. If the graph is a DAG (Directed Acyclic Graph), we can perform a topological sort and safely use this order for DP. If the graph contains cycles, topological sort is not applicable; in that case, alternative techniques such as DFS combined with memoization or iterative relaxation algorithms like Bellman–Ford / Floyd–Warshall are used until the values converge.

Illustrative example: to compute the value of node 4 (assuming the value is the total path from 1 to 4), we first need the results of nodes 2 and 3; to have 2 and 3, we must have the result of 1. Therefore, it is necessary to arrange the order so that each node is computed after the nodes it depends on.

ex: topo = [1, 2, 3, 4]

dp[1] = base
dp[2] = f(dp[1])
dp[3] = f(dp[1])
dp[4] = f(dp[2], dp[3])

Thus, the computation order always ensures that dependencies already have values.

2. Example: Longest Path on DAG

Problem: Given n vertices and a set of edges, find the length of the longest path on a DAG. Idea: Traverse the vertices in topological order and update the values for adjacent vertices.

For each edge u → v, perform:

dp[v] = max(dp[v], dp[u] + 1)

Pseudo code:

topo = topological_sort(graph)
dp = [0 for _ in range(n)]
for u in topo:
    for v in graph[u]:
        dp[v] = max(dp[v], dp[u] + 1)
return max(dp)

Time complexity: O(V + E) if a topological order is already available. Topo ensures that a vertex is never updated before its prerequisites have been processed.

3. When Graphs Have Cycles

If the graph contains cycles, topological sort is not applicable. Common alternatives include:

• DFS + memoization: use DFS to compute values on demand, storing results (memo) to avoid recomputation. For problems requiring the longest path on a graph with cycles, cycles must be handled appropriately (e.g., detecting infinity or cutting cycles according to the problem requirements).
• Bellman–Ford / Floyd–Warshall: iterative algorithms that relax edges multiple times until the values converge (or detect the existence of a negative cycle with Bellman–Ford).

DFS + memo pseudo code:

def dfs(u):
    if seen[u]:
        return dp[u]
    seen[u] = True
    dp[u] = 1 + max(dfs(v) for v in graph[u])
    return dp[u]

Bellman–Ford: iterate through all edges V-1 times, each time performing an update of the form dist[v] = min(dist[v], dist[u] + w). In essence, this is a form of iterative DP (iterative relaxation) until the values stabilize.

4. Real-World Analogy

Real-world dependency management problems accurately reflect the thinking of DP on graphs:

• Airflow DAG: a task only runs when the tasks it depends on have completed.
• Compiler dependency graph: module A must be compiled before module B if B depends on A.
• Neural network forward pass: traverse the computation graph in topological order to compute the values of the nodes.

Ultimately, these are all dependency resolution.

5. Key Takeaways

• On a DAG, prefer using topo DP with a complexity of O(V + E).
• If the graph contains cycles, consider using DFS + memoization or iterative relaxation algorithms like Bellman–Ford.
• The focus is not on formulas; it is on managing information flow (dependencies) and computation order.
• DP on graphs = reuse + ordering + dependency control.

6. Related LeetCode Problems

For practice, you can refer to the following problems (from easy to medium-hard):

• 207. Course Schedule — cycle detection + topo sort
• 210. Course Schedule II — construct topo order
• 329. Longest Increasing Path in a Matrix — DP on an implicit graph in a grid
• 1514. Path with Maximum Probability — DP combined with Dijkstra
• 787. Cheapest Flights Within K Stops — a variant of Bellman–Ford

7. Personal Reflection

I used to understand DP as a rigid set of state transition formulas. After diving deeper, I realized that the essence of DP is managing information flow within a dependency network. Graphs only make the concept more abstract, but the principle remains the same: solve the simple parts first, store the results, and then use them to compute the more complex parts.

Once you grasp this principle, algorithms like Bellman–Ford, Floyd–Warshall, or topo DP become much more intuitive. A useful habit: draw the dependency graph before coding and experiment with a small example (4–5 vertices) to observe the order and how values propagate.

Practical Principles:

• Understand the computation flow (simulate flow) before implementing code — Understand > Memorize.
• DP = reuse + ordering + dependency management — from there, you can reconstruct the algorithm without having to memorize formulas.
• If there are cycles, do not force a topo sort; switch to an iterative update method like Bellman–Ford and continue to relax until stable.
• Always clearly identify 'who depends on whom' — visualization helps to quickly grasp dependencies.
• Start from the base case; think forward (past → future) or backward (goal → start) depending on the problem.
• If you find yourself computing the same value repeatedly — use memoization; double-check boundaries and base cases to avoid common errors.

Ghi chú: Đây là chia sẻ từ góc nhìn người bắt đầu nhằm giúp người học hệ thống lại kiến thức. Việc thực hành và giải nhiều bài sẽ giúp nâng cấp khả năng làm chủ các biến thể nâng cao hơn.