I think what you are talking about is Divide and Conquer (and Combine) techniques:
Divide the problem into a number of subproblems that are smaller instances of the same problem.
Conquer the subproblems by solving them recursively. If the subproblem sizes are small enough, however, just solve the subproblems in a straightforward manner.
Combine the solutions to the subproblems into the solution for the original problem.
CLRS 3rd Ed Ch 4, pp. 65
If not D&C, then at least a variant. It seems you are making an greedy choice, then this divides the problem into multiple, and you solve these subproblems the same way. Consider the following problem which I think can be solved as you mentioned:
Given a directed binary tree $T$ (meaning edges are directed from parent to child) with positive integer values on the nodes, determine the directed path with maximal sum of node values.
Here is how we can solve this:
- We make a "greedy" choice to include the root node. Since the values are positive, we know that the root node can only increase the sum of node values.
- We now can either go left or right (not both since it is directed towards leaves).
- Solve the left case, what is it's maximal path? Let's say it's of weight $L$.
- Solve the right case, what is it's maximal path? Let's say it's of of weight $R$.
- Now we combine these results, if $L > R$ then we prepend the root node to the path returned from the left case, else we prepend the root node to the path returned from the right case.
- If we get down to a leaf node, simply return it because it will be it's own maximal path since values are positive.
So this is a kind of "greedy" algorithm in the sense that we make a greedy choice (include the root node always). However, it is much more of a divide and conquer algorithm based on the definition of D&C. This is why greedy must only be left with one subproblem. If we have multiple subproblems then we are either in the case of Divide and Conquer or Dynamic Programming most likely.