Codeforces 794C - Naming Company

C. Naming Company time limit per test2 secondsmemory limit per test256 megabytes 

inputstandard input
outputstandard output
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 n letters (which might contain multiple copies of the same letter, the sets can be different). Initially, the company name is denoted by n question 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串中第一个要大于等于b串第一个，那么也就是说b中所有的都小于等于a中的，那么我们考虑这时是谁选择位置，如果是a那么，很明显a会尽量把此时最大的元素放到最右边的位置，，如果是b的话，b会尽量把最小的放发到最右边。如果a[l]<b[l]的话，是比较简单的就放尽量左边的位置就行了。需要注意的是大于等于，为什么呢，因为当等于的时候，b中后面的元素最差的情乱是和a中后面的元素相同，大于的情况就不满足了，比如 ceee cddd

ac代码：
  

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<sstream>
#include<cmath>
using namespace std;
const int maxn = 3*1e5+55;
char a[maxn];
char b[maxn];
char ans[maxn];
int cmp(char a,char b)
{
    return a>b;
}
int cmp2(char a,char b)
{
    return a<b;
}
int main()
{
    while(~scanf("%s",a))
    {
        scanf("%s",b);
        memset(ans,0,sizeof(ans));
        int lena = strlen(a);
        int lenb = strlen(b);
        int n = lena;
        sort(a,a+lena,cmp2);
        sort(b,b+lenb,cmp);
        int l1=0,l2=0;
        int r1 = (n-1)/2+1;
        int r2 = n/2;
        int flag = 0;
        int e = n;
        int s = 0;
        for(int i = 0;i<n;i++)
        {
            if(!flag){
            if(a[l1]>=b[l2])
            {
                ans[--e] = a[--r1];
            }
            else
            {
                ans[s++] = a[l1++];
            }
            flag = 1;
            }
            else
            {
                if(a[l1]>=b[l2])
                {
                    ans[--e] = b[--r2];
                }
                else
                {
                    ans[s++] = b[l2++];
                }
                flag = 0;
            }
        }

        cout<<ans<<endl;
    }
}