description: It is a complicated version of problem F1. The difference between them is the constraints (F1: k ≤ 2, F2: k ≤ 10).
  
  You are given an integer n. Find the minimum integer x such that x ≥ n and the number x is k-beautiful.
  
  A number is called k-beautiful if its decimal representation having no leading zeroes contains no more than k different digits. E.g. if k = 2, the numbers 3434443, 55550, 777 and 21 are k-beautiful whereas the numbers 120, 445435 and 998244353 are not.
  
  Input
  
  The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
  
  Each test case consists of one line containing two integers n and k (1 ≤ n ≤ 10^9, 1 ≤ k ≤ 10).
  
  Output
  
  For each test case output on a separate line x — the minimum k-beautiful integer such that x ≥ n.
  
  Example
  
  Input
  
  
  6
  2021 3
  177890 2
  34512 3
  724533 4
  998244353 1
  12345678 10
  
  
  Output
  
  
  2021
  181111
  34533
  724542
  999999999
  12345678
solution: import java.util.*;
  // import java.lang.*;
  import java.io.*;
  
  //           THIS TEMPLATE MADE BY AKSH BANSAL.
  
  public class Solution {
      static class FastReader {
          BufferedReader br;
          StringTokenizer st;
  
          public FastReader() {
              br = new BufferedReader(new InputStreamReader(System.in));
          }
  
          String next() {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
  
          int nextInt() {
              return Integer.parseInt(next());
          }
  
          long nextLong() {
              return Long.parseLong(next());
          }
  
          double nextDouble() {
              return Double.parseDouble(next());
          }
  
          String nextLine() {
              String str = "";
              try {
                  str = br.readLine();
              } catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
      }
      private static boolean[] isPrime;
      private static void primes(){
          int num = (int)1e6; // PRIMES FROM 1 TO NUM
          isPrime = new boolean[num];
       
          for (int i = 2; i< isPrime.length; i++) {
             isPrime[i] = true;
          }
          for (int i = 2; i< Math.sqrt(num); i++) {
             if(isPrime[i] == true) {
                for(int j = (i*i); j<num; j = j+i) {
                   isPrime[j] = false;
                }
             }
          }
      }
      static void sort(int a[]){ // int -> long
          ArrayList<Integer> arr=new ArrayList<>(); // Integer -> Long
          for(int i=0;i<a.length;i++)
          arr.add(a[i]);
          Collections.sort(arr);
          for(int i=0;i<a.length;i++)
          a[i]=arr.get(i);
          
      }
      private static long gcd(long a, long b){
          if(b==0)return a;
          return gcd(b,a%b);
      }
      private static long pow(long x,long y){
          if(y==0)return 1;
          long temp = pow(x, y/2);
          if(y%2==1){
              return x*temp*temp;
          }
          else{
              return temp*temp;
          }
      }
      // static ArrayList<Integer>[] adj;
      // static void getAdj(int n,int q, FastReader sc){
      //     adj = new ArrayList[n+1];
      //     for(int i=1;i<=n;i++){
      //         adj[i] = new ArrayList<>();
      //     }
      //     for(int i=0;i<q;i++){
      //         int a = sc.nextInt();
      //         int b = sc.nextInt();
  
      //         adj[a].add(b);
      //         adj[b].add(a);
      //     }
      // }
      static PrintWriter out;
      static FastReader sc ;
      public static void main(String[] args) throws IOException {
          sc = new FastReader();
          out = new PrintWriter(System.out);
          // primes();
          // ________________________________
  
          int test = sc.nextInt();
          StringBuilder output = new StringBuilder();
  
          while (test-- > 0) {
              int n = sc.nextInt();
              int k = sc.nextInt();
              // output.append().append("\n");
              solver(n, k);
          }
  
          out.println(output);
          // _______________________________
  
          // int n = sc.nextInt();
          // out.println(solver());
          // ________________________________
          out.flush();
      }
  
      public static void solver(int s, int k) {
          char[] arr = (s+"").toCharArray();
          int n = arr.length;
          
          while(true){
              HashSet<Character> set = new HashSet<>();
  
              for(int i=0;i<n;i++){
                  set.add(arr[i]);
                  if(set.size()>k){
                      while(arr[i]=='9'){
                          i--;
                      }
                      arr[i] = (char)(arr[i]+1);
                      i++;
                      while(i<n){
                          arr[i++] = '0';
                      }
                      break;
                  }
              }
  
              if(set.size()<=k){
                  break;
              }
          }
  
          for(int i=0;i<n;i++){
              out.print(arr[i]);
          }
          out.println();
      }
  }