Naming Company
Oleg the client and Igor the analyst are good friends. However, sometimes they argue over little things. Recently, they started a new company, but they are having trouble finding a name for the company.
To settle this problem, they've decided to play a game. The company name will consist of n letters. Oleg and Igor each have a set of nletters (which might contain multiple copies of the same letter, the sets can be different). Initially, the company name is denoted by nquestion marks. Oleg and Igor takes turns to play the game, Oleg moves first. In each turn, a player can choose one of the letters c in his set and replace any of the question marks with c. Then, a copy of the letter c is removed from his set. The game ends when all the question marks has been replaced by some letter.
For example, suppose Oleg has the set of letters {i, o, i} and Igor has the set of letters {i, m, o}. One possible game is as follows :
Initially, the company name is ???.
Oleg replaces the second question mark with 'i'. The company name becomes ?i?. The set of letters Oleg have now is {i, o}.
Igor replaces the third question mark with 'o'. The company name becomes ?io. The set of letters Igor have now is {i, m}.
Finally, Oleg replaces the first question mark with 'o'. The company name becomes oio. The set of letters Oleg have now is {i}.
In the end, the company name is oio.
Oleg wants the company name to be as lexicographically small as possible while Igor wants the company name to be as lexicographically large as possible. What will be the company name if Oleg and Igor always play optimally?
A string s = s1s2...sm is called lexicographically smaller than a string t = t1t2...tm (where s ≠ t) if si < ti where i is the smallest index such that si ≠ ti. (so sj = tj for all j < i)
Input
The first line of input contains a string s of length n (1 ≤ n ≤ 3·105). All characters of the string are lowercase English letters. This string denotes the set of letters Oleg has initially.
The second line of input contains a string t of length n. All characters of the string are lowercase English letters. This string denotes the set of letters Igor has initially.
Output
The output should contain a string of n lowercase English letters, denoting the company name if Oleg and Igor plays optimally.
Examples
Input
tinkoff zscoder
Output
fzfsirk
Input
xxxxxx xxxxxx
Output
xxxxxx
Input
ioi imo
Output
ioi
Note
One way to play optimally in the first sample is as follows :
- Initially, the company name is ???????.
- Oleg replaces the first question mark with 'f'. The company name becomes f??????.
- Igor replaces the second question mark with 'z'. The company name becomes fz?????.
- Oleg replaces the third question mark with 'f'. The company name becomes fzf????.
- Igor replaces the fourth question mark with 's'. The company name becomes fzfs???.
- Oleg replaces the fifth question mark with 'i'. The company name becomes fzfsi??.
- Igor replaces the sixth question mark with 'r'. The company name becomes fzfsir?.
- Oleg replaces the seventh question mark with 'k'. The company name becomes fzfsirk.
For the second sample, no matter how they play, the company name will always be xxxxxx.
题意：A有一个字符串 S， B有一个字符串 T，长度都为 N 。两人需要构造一个新的长度为 N 的字符串，新串起始全为 '?' 。两人轮流操作，A 可以取 S 串中的 任意一个字符，放在 新串的任意 '?' 位置，B可以取 T 中的任一字符 放在任意 ‘?’ 位置 。A 想 新串的字典序尽量小， B想 新串的字典序尽量大，两人都采取最佳策略，问最后的 新串是什么。。 A 先手。一个字符只能用一次
思路：很显然这是个贪心题。最容易想到的就是， A 每次都将 目前最小的字符放最前面， B 每次将目前最大的放前面。 但是这样会有一个问题，就是 A 的最小字符 都 大于等于 B 的最大字符的时候，这样贪心就错了 。 很显然， A 只需要取前 n / 2 小的字符,B 取前 n / 2 大的字符，在 A 的最小字符 都 大于等于 B 的最大字符 的情况下，A 就应该将自己手中最大的放在最后，而 B 就将自己手中最小的放在最后。
AC代码：
#include<bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
char s[maxn],t[maxn];
int main()
{
while(~scanf("%s",s)){
scanf("%s",t);
int lens = strlen(s);
int lent = strlen(t);
sort(s,s + lens);
sort(t,t + lent,greater<char>());
int coun = 0;
int ps = 0,pt = 0;
int pps = lens / 2 + (lens % 2 == 1) - 1; ///这是下标
int ppt = lent / 2 - 1;
char ans[maxn] = {0};
int pa = 0,ppa = 1; ///正着放，倒着放
while(coun < lens){
if(coun % 2 == 0){
if(s[ps] < t[pt]) ans[pa ++] = s[ps ++];
else{
ans[lens - ppa] = s[pps--];
ppa ++;
}
}
else {
if(t[pt] > s[ps]) ans[pa ++] = t[pt ++];
else {
ans[lens - ppa] = t[ppt--];
ppa ++;
}
}
coun ++;
}
puts(ans);
}
return 0;
}