Алгоритм для достижения числа в фиксированном количестве шагов с использованием только сложения, деления и умножения

Работая над игрой на работе, и в какой-то момент игры игрок бросается в бонусную игру. Сумма, которую они должны выиграть, предопределена, однако мы бы хотели придумать алгоритм, который использует сложение, умножение и деление, чтобы получить эту сумму за x шагов. Количество шагов также будет известно заранее, поэтому алгоритм просто должен выяснить, как использовать это количество шагов для достижения числа.

Единственными вычислениями, которые вы можете использовать, являются +1 до +15, x2, x4,/2,/4. Вы можете превысить целевой номер во время шагов, но на последнем шаге должны быть на целевом номере. Сумма шага обычно составляет от 15 до 30, и вы всегда начинаете с 0.

Например: Количество: 100, Шагов: 10 == +10, +2, x2, +4, x4, +10,/2, +15, +15, +9

Сумма: 40, Шаги: 12 == +15, +1, +5, +2, +1,/2, * 4, +6, +6,/4, +5, * 2

Мне любопытно, если что-то вроде этого может уже существовать? Я уверен, что мы можем что-то придумать, но я не хотел заново изобретать колесо, если есть общий алгоритм, который мог бы справиться с работой.

---

Обновление. Сделано несколько незначительных изменений в коде @FryGuy, чтобы сделать его маршрутом, чтобы достичь целевого номера несколько случайным. Его решение отлично поработало, но, увидев его работу и принимая во внимание комментарии @Argote и @Moron, я понял, что для этого нужно иметь уровень рандомизации, чтобы сделать его привлекательным для наших игроков. Добавлено +1 более 10 шагов, чтобы достичь целевого числа из 10, отлично работает, но "скучно" с точки зрения того, как мы будем его использовать. Большое спасибо всем, кто прокомментировал и ответил.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CR
{
    class Program
    {
        static void Main(string[] args)
        {
            while (true)
            {
                int targetNumber = 20;
                int steps = 13;
                int[] route = null;
                Boolean routeAcceptable = false;

                // Continue choosing routes until we find one that is acceptable (doesn't average above or target win, but does exceed it at least once)
                while(!routeAcceptable)
                {
                    routeAcceptable = CalculateRoute(targetNumber, steps, out route) && route.Average() < targetNumber && route.Max() > targetNumber;
                }

                foreach (int i in route.Reverse())
                {
                    Console.WriteLine(i);
                }
                Console.WriteLine("-----------------------");
                Console.ReadLine();
            }
        }

        static Boolean CalculateRoute(int targetNumber, int numSteps, out int[] route)
        {
            int maxValue = targetNumber * 16;
            bool[,] reachable = new bool[numSteps + 1, maxValue];

            // build up the map
            reachable[0, 0] = true;
            for (int step = 0; step < numSteps; step++)
            {
                for (int n = 0; n < maxValue; n++)
                {
                    if (reachable[step, n])
                    {
                        foreach (int nextNum in ReachableNumbersFrom(n))
                        {
                            if (nextNum < maxValue && nextNum > 0)
                            {
                                reachable[step + 1, nextNum] = true;
                            }
                        }
                    }
                }
            }

            // figure out how we got there
            int[] routeTaken = new int[numSteps + 1];
            int current = targetNumber;
            for (int step = numSteps; step >= 0; step--)
            {
                routeTaken[step] = current;
                bool good = false;

                // Randomize the reachable numbers enumeration to make the route 'interesting'
                foreach (int prev in RandomizedIEnumerbale(ReachableNumbersFromReverse(current)))
                {
                    if (prev < targetNumber * 8)
                    {
                        if (reachable[step, prev])
                        {
                            current = prev;
                            good = true;

                            // Avoid hitting the same number twice, again to make the route 'interesting'
                            for (int c = numSteps; c >= 0; c--)
                            {
                                reachable[c, prev] = false;
                            }
                            break;
                        }
                    }
                }

                if (!good)
                {
                    route = routeTaken;
                    return false;
                }
            }

            route = routeTaken;
            return true;
        }

        static IEnumerable<int> ReachableNumbersFrom(int n)
        {
            // additions
            for (int i = 1; i <= 15; i++)
            {
                yield return n + i;
            }

            // mults/divides
            yield return n / 2;
            yield return n / 4;
            yield return n * 2;
            yield return n * 4;
        }

        static IEnumerable<int> ReachableNumbersFromReverse(int n)
        {
            // additions
            for (int i = 1; i <= 15; i++)
            {
                if (n - i >= 0)
                    yield return n - i;
            }

            // mults/divides
            if (n % 2 == 0)
                yield return n / 2;
            if (n % 4 == 0)
                yield return n / 4;
            yield return n * 2;
            yield return n * 4;
        }

        static IEnumerable<int> RandomizedIEnumerbale(IEnumerable<int> enumerbale)
        {
            Random random = new Random(System.DateTime.Now.Millisecond);
            return (
                from r in
                    (
                        from num in enumerbale
                        select new { Num = num, Order = random.Next() }
                    )
                orderby r.Order
                select r.Num
                );
        }
    }
}