E. Playing with numbers

time limit per test 2.0 s memory limit per test 64 MB input standard input output standard output

Folan and Eltan are brothers. However, as all brothers are, they always fight. One day their mom had to go to work, so she decided to give them a task to keep them busy while she is away.

She gave them two numbers S and N.

She told Folan that he has to delete exactly N digits from the number S, so that the resulting number is as small as possible.

Then, she told Eltan that he has to delete exactly N digits from the number S, so that the resulting number is as big as possible.

Folan and Eltan are ex ACMers. They decided to write a program to solve this problem, so they can go back to fighting again.

When their mom heard the evil plan, she decided to make the number S very big, and she may have added leading zeros to it.

The boys were really upset because they couldn’t find a way to write a program that would solve this problem fast enough before their mom returns, so they asked for your help.

Can you help them with this program, so they can go back to fighting again?

Input

The first line of the input consists of a single integer t, the number of test cases. Each test case consists of two numbers S and N separated by a single space. where (0 ≤ S < 10100000) and it may contain leading zeros, and (0 ≤ N < |S|).

Note that |S| means the length of the number S.

Output

For each test case, print two lines.

The first line should contain the smallest number Folan can get after deleting exactly N digits from S.

The second line should contain the biggest number Eltan can get after deleting exactly N digits from S.

Please note that in case some of the leading zeros were not deleted, you have to print the resulting number with the remaining leading zeros.

Example input Copy

3
00123 2
00123 3
234714812741111111111111111111 4

output Copy

001
123
00
23
14812741111111111111111111
74812741111111111111111111

题意：给出一个长度最大为100000位的数字，求从中剔除掉N个数字后得到到最大数和最小数。


题解：
若是找最小数，那么维持原来的数字单调递增，若递减，则把前面的数字删去直到递增，遍历一遍后如果没删够，则从后面删。 
若是找最大数，那么维持原来的数字单调递减，若递增，则把前面的数字删去直到递减，便利一遍后如果每删够，则从后面删。

#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<vector>
#include<stack>
#include<math.h>
#define mod 998244353
#define ll long long
#define MAX 0x3f3f3f3f
using namespace std;
string s;
string ss;
stack<char>p;
int n,len,cnt,t;
int main()
{
    cin>>t;
    while(t--)
    {
        cin>>s;
        cin>>n;
        cnt=n,ss.clear();
        for(int i=0;s[i];i++)
        {
            while(!p.empty()&&s[i]<p.top()&&cnt)//删除之后最小，维持栈单调递增
            {
                p.pop();
                cnt--;
            }
            p.push(s[i]);
        }
        while(cnt--)//遍历完之后还没删够
        {
            p.pop();
        }
        while(!p.empty())
        {
            ss=ss+p.top();
            p.pop();
        }
        len=ss.length();
        for(int i=len-1;i>=0;i--)
            cout<<ss[i];
        cout<<endl;
        cnt=n;
        ss.clear();
        for(int i=0;s[i];i++)//删除之后最大，维持站内单调递减
        {
            while(!p.empty()&&s[i]>p.top()&&cnt)
            {
                p.pop();
                cnt--;
            }
            p.push(s[i]);
        }
        while(cnt--)
        {
            p.pop();
        }
        while(!p.empty())
        {
            ss=ss+p.top();
            p.pop();
        }
        len=ss.length();
        for(int i=len-1;i>=0;i--)
            cout<<ss[i];
        cout<<endl;

    }
}