Weighted Path Count in DAG

You are given a weighted, directed acyclic graph (DAG) with n nodes (labeled from 0 to n-1) and a list of edges. Each edge is represented as a tuple (u, v, w) where u is the source node, v is the destination node, and w is the weight of the edge.

Your task is to implement a function that counts the number of distinct paths from a given source node to a given destination node such that the sum of the edge weights along the path is exactly equal to a target value.

For example, your function signature might be:

def count_paths(n, edges, source, destination, target):
    # Your implementation here

Where:

• n: an integer representing the number of nodes.
• edges: a list of tuples (u, v, w) representing the edges in the graph.
• source: the starting node.
• destination: the target node to reach.
• target: the exact sum of weights that the path must add up to.

Consider the following constraints and notes:

• The graph is guaranteed to have no cycles.
• The number of nodes n can be assumed to be reasonably small (for instance, n ≤ 50), but the number of paths can be large.
• You must count each distinct path that meets the target weight sum.
• Think carefully about the efficiency of your solution to avoid unnecessary computations.

Example:

Input:
n = 4
edges = [
(0, 1, 2),
(0, 2, 3),
(1, 3, 4),
(2, 3, 1)
]
source = 0
destination = 3
target = 6

In this example, there is 1 valid path: 0 -> 1 -> 3 (with weight sum 2 + 4 = 6). The other potential path 0 -> 2 -> 3 sums to 3 + 1 = 4, which does not match the target.

Write a complete and efficient solution to this problem.