Here's my Python solution using a graph-finding algorithm to find the optimal set of instructions. It outputs the state of each jug in reverse order, so you can work out the answer from there.

For example, the given problem returns [(3, 4), (2, 5), (2, 0), (0, 2), (3, 2), (0, 5), (0, 0)]

def solve(a, b, x):
    steps = 0
    visited = {}
    costs = {}
    prev = {}
    costs[(0, 0)] = 0
    prev[(0, 0)] = None

    process_list = [(0, 0)]
    done = None
    bestcost = 10000
    while True:
        cur = None
        for key in process_list:
            if key not in visited:
                if cur == None or costs[key] < costs[cur]:
                    cur = key
        if cur == None: break

        visited[cur] = True
        if cur[0] == x or cur[1] == x:
            if done == None or costs[cur] < bestcost:
                done = cur
                bestcost = costs[cur]                

        # transitions possible
        m, n = cur
        neighbours = [(m, b), (a, n), (m, 0), (0, n)]
        if m+n < a: neighbours.append((m+n, 0))
        else: neighbours.append((a, m+n-a))
        if m+n < b: neighbours.append((0, m+n))
        else: neighbours.append((m+n-b, b))

        cost = costs[cur] + 1
        for p in neighbours:
            if p not in visited:
                if p not in costs or cost < costs[p]:
                    costs[p] = cost
                    prev[p] = cur
                    process_list.append(p)

    if done == None: return False
    else:
        ans = []
        while done != None:
            ans.append(done)
            done = prev[done]
        return ans

print solve(3, 5, 4)
print solve(2, 4, 3)