Smallest expression to represent a number using single digit

// Java Program to generate minimum expression containing
// only given digit D that evaluates to number N.

import java.util.HashMap;
import java.util.Stack;

public class SingleDigit {

    // limit of Digits in the expression
    static int LIMIT = 10;

    // map that store if a number is seen or not
    static HashMap<Integer, Integer> seen
        = new HashMap<Integer, Integer>();

    // stack for storing operators
    static Stack<Character> operators
        = new Stack<Character>();
    static int minimum = LIMIT;

    // function to find minimum levels in the recursive tree
    static void minLevel(int total, int N, int D, int level)
    {

        // if total is equal to given N
        if (total == N) {

            // store if level is minimum
            minimum = Math.min(minimum, level);
            return;
        }

        // if the last level is reached
        if (level == minimum)
            return;

        // if total can be divided by D.
        // recurse by dividing the total by D
        if (total % D == 0)
            minLevel(total / D, N, D, level + 1);

        // recurse for total + D
        minLevel(total + D, N, D, level + 1);

        // if total - D is greater than 0
        if (total - D > 0)

            // recurse for total - D
            minLevel(total - D, N, D, level + 1);

        // recurse for total multiply D
        minLevel(total * D, N, D, level + 1);
    }

    // function to generate the minimum expression
    static boolean generate(int total, int N, int D,
                            int level)
    {
        // if total is equal to N
        if (total == N)
            return true;

        // if the last level is reached
        if (level == minimum)
            return false;

        // if total is seen at level greater than current
        // level or if we haven't seen total before. Mark
        // the total as seen at current level
        if ((seen.containsKey(total)
             && seen.get(total) >= level)
            || !seen.containsKey(total)) {

            seen.put(total, level);

            int divide = Integer.MAX_VALUE;

            // if total is divisible by D
            if (total % D == 0) {
                divide = total / D;

                // if divide isn't seen before
                // mark it as seen
                if (seen.containsKey(divide))
                    seen.put(divide, level + 1);
            }

            int addition = total + D;

            // if addition isn't seen before
            // mark it as seen
            if (seen.containsKey(addition))
                seen.put(addition, level + 1);

            int subtraction = Integer.MAX_VALUE;
            // if D can be subtracted from total
            if (total - D > 0) {
                subtraction = total - D;

                // if subtraction isn't seen before
                // mark it as seen
                if (seen.containsKey(subtraction))
                    seen.put(subtraction, level + 1);
            }

            int multiply = total * D;

            // if multiply isn't seen before
            // mark it as seen
            if (seen.containsKey(multiply))
                seen.put(multiply, level + 1);
            ;

            // recurse by dividing the total if possible
            if (divide != Integer.MAX_VALUE)
                if (generate(divide, N, D, level + 1)) {

                    // store the operator.
                    operators.push('/');
                    return true;
                }

            // recurse by adding D to total
            if (generate(addition, N, D, level + 1)) {

                // store the operator.
                operators.push('+');
                return true;
            }

            // recurse by subtracting D from total
            if (subtraction != Integer.MAX_VALUE)
                if (generate(subtraction, N, D,
                             level + 1)) {

                    // store the operator.
                    operators.push('-');
                    return true;
                }

            // recurse by multiplying D by total
            if (generate(multiply, N, D, level + 1)) {

                // store the operator.
                operators.push('*');
                return true;
            }
        }

        // expression is not found yet
        return false;
    }

    // function to print the expression
    static void printExpression(int N, int D)
    {
        // find minimum level
        minLevel(D, N, D, 1);

        // generate expression if possible
        if (generate(D, N, D, 1)) {

            String expression = "";

            // if stack is not empty
            if (!operators.empty()) {

                // concatenate D and operator at top of
                // stack
                expression = Integer.toString(D)
                             + operators.peek();
                operators.pop();
            }

            // until stack is empty
            // concatenate the operator with parenthesis for
            // precedence
            while (!operators.empty()) {
                if (operators.peek() == '/'
                    || operators.peek() == '*')
                    expression = "(" + expression
                                 + Integer.toString(D) + ")"
                                 + operators.peek();
                else
                    expression = expression
                                 + Integer.toString(D)
                                 + operators.peek();
                operators.pop();
            }

            expression = expression + Integer.toString(D);

            // print the expression
            System.out.println("Expression: " + expression);
        }

        // not possible within 10 digits.
        else
            System.out.println("Expression not found!");
    }

    // Driver's Code
    public static void main(String[] args)
    {

        int N = 7, D = 4;

        // print the Expression if possible
        printExpression(N, D);

        // print expression for N =100, D =7
        minimum = LIMIT;
        printExpression(100, 7);

        // print expression for N =200, D =9
        minimum = LIMIT;
        printExpression(200, 9);
    }
}

// This code is contributed by Lovely Jain