Smallest number greater than K by removing digits from N

// Java code to implement the approach
import java.util.*;
class GFG{

static int ans = 0;

// Function to generate all possible combination
static void find(int i, ArrayList<Integer> digits , int mask, int k)
{
    // Base case
    if (i == digits.size())
        return;

    // Store the ans for current state of mask
    int temp = 0;
    int pow_of_10 = 1;
    for (int j = digits.size() - 1; j >= 0; j--) {
         int kk = (int)Math.pow(2, j);

        // If the bit is 1 means current element
        // is removed in that state
        if ((mask & kk)==0) {
            temp = temp + pow_of_10 * digits.get(j);
            pow_of_10 *= 10;
        }
    }
    if (temp > k) {
        ans = Math.min(ans, temp);
    }
    int next = (int)Math.pow(2, i);
    find(i + 1, digits, mask, k);
    find(i + 1, digits, mask | next, k);
}

// Function to find number less than N greater than K
static int GreaterthanK(int N, int K)
{
    // Array to store digits of N
    ArrayList<Integer> digits = new ArrayList<Integer>();
    int M = N;
    while (M>0) {
        digits.add(M % 10);
        M /= 10;
    }
    Collections.reverse(digits);
    ans = N;
    find(0, digits, 0, K);
    return ans;
}

// Driver code
public static void main(String[] args)
{
    int N = 121230;
    int K = 756;

    // Function call
    System.out.println(GreaterthanK(N, K));
}

}
// This code is contributed by Pushpesh Raj.

public class Main {
    static long findSmallestNumberGreaterThanK(long N,
                                               int K)
    {
        String strN = Long.toString(N);
        int lenN = strN.length();
        long[] best = {
            Long.MAX_VALUE
        }; // Use an array to represent no valid number
           // found yet

        // Helper function to perform depth-first search
        // (DFS) currentNumber is the current partial number
        // being formed currentIndex is the index in the
        // string strN that we are considering This function
        // updates the best number found so far by
        // recursively exploring all possible combinations
        // of digits to form numbers greater than K The DFS
        // process is similar to backtracking but instead of
        // undoing changes, we just explore both including
        // and excluding the current digit in the number
        // being formed to cover all possible combinations
        // The base case is when currentIndex reaches lenN
        // In this case, we check if the currentNumber is
        // greater than K If it is, we update the best
        // number found so far and terminate this branch of
        // exploration Otherwise, we continue exploring both
        // including and excluding the current digit This
        // ensures that all possible combinations are
        // explored without missing any valid numbers
        // greater than K Time complexity of this approach
        // is O(2^N), where N is the number of digits in N
        // as we explore all possible combinations of digits
        // Space complexity is O(N) for the recursive call
        // stack where N is the number of digits in N as we
        // recurse to a depth of N to explore all possible
        // combinations of digits to form numbers greater
        // than K and O(N) for the string strN used to store
        // the digits of N

        // Start DFS from index 0 with an empty current
        // number
        dfs(0, "", strN, K, best);

        // If best is still Long.MAX_VALUE, it means no
        // valid number was found
        return (best[0] != Long.MAX_VALUE)
            ? best[0]
            : -1; // Return -1 if no number found
    }

    static void dfs(int currentIndex, String currentNumber,
                    String strN, int K, long[] best)
    {
        // Convert current partial number to long if it's
        // not empty
        if (!currentNumber.isEmpty()) {
            long num = Long.parseLong(currentNumber);
            // Check if the current number is a valid
            // candidate
            if (num > K) {
                best[0] = Math.min(best[0], num);
            }
        }

        // Recurse further if we're not at the end of the
        // string
        if (currentIndex < strN.length()) {
            // Include current digit in the number
            dfs(currentIndex + 1,
                currentNumber + strN.charAt(currentIndex),
                strN, K, best);
            // Exclude current digit from the number
            dfs(currentIndex + 1, currentNumber, strN, K,
                best);
        }
    }

    public static void main(String[] args)
    {
        long N = 121230;
        int K = 756;
        System.out.println(
            findSmallestNumberGreaterThanK(N, K));
    }
}