uva1344 - Tian Ji -- The Horse Racing 田忌赛马

Here is a famous story in Chinese history.

That was about 2300 years ago. General Tian Ji was a high official in the country Qi. He likes to play horse racing with the king and others.

Both of Tian and the king have three horses in different classes, namely, regular, plus, and super. The rule is to have three rounds in a match; each of the horses must be used in one round. The winner of a single round takes two hundred silver dollars from the loser.

Being the most powerful man in the country, the king has so nice horses that in each class his horse is better than Tian's. As a result, each time the king takes six hundred silver dollars from Tian.

Tian Ji was not happy about that, until he met Sun Bin, one of the most famous generals in Chinese history. Using a little trick due to Sun, Tian Ji brought home two hundred silver dollars and such a grace in the next match.

It was a rather simple trick. Using his regular class horse race against the super class from the king, they will certainly lose that round. But then his plus beat the king's regular, and his super beat the king's plus. What a simple trick. And how do you think of Tian Ji, the high ranked official in China?

Were Tian Ji lives in nowadays, he will certainly laugh at himself. Even more, were he sitting in the ACM contest right now, he may discover that the horse racing problem can be simply viewed as finding the maximum matching in a bipartite graph. Draw Tian's horses on one side, and the king's horses on the other. Whenever one of Tian's horses can beat one from the king, we draw an edge between them, meaning we wish to establish this pair. Then, the problem of winning as many rounds as possible is just to find the maximum matching in this graph. If there are ties, the problem becomes more complicated, he needs to assign weights 0, 1, or -1 to all the possible edges, and find a maximum weighted perfect matching...

However, the horse racing problem is a very special case of bipartite matching. The graph is decided by the speed of the horses -- a vertex of higher speed always beat a vertex of lower speed. In this case, the weighted bipartite matching algorithm is a too advanced tool to deal with the problem.

In this problem, you are asked to write a program to solve this special case of matching problem.

Input 

The input consists of up to 50 test cases. Each case starts with a positive integern ( n1000) on the first line, which is the number of horses on each side. The nextn integers on the second line are the speeds of Tian's horses. Then the nextn integers on the third line are the speeds of the king's horses. The input ends with a line that has a single `0' after the last test case.

Output 

For each input case, output a line containing a single number, which is the maximum money Tian Ji will get, in silver dollars.

Sample Input 

3 
92 83 71  
95 87 74 
2 
20 20 
20 20 
2 
20 19 
22 18 
0

Sample Output 

200 
0 
0

  这个让我想到校赛的时候那个“田忌赛马” ，当时没看清题就当真的田忌赛马来做，结果一直做到比赛结束还没做出来。。。这次是真的。。

  赢一次200块，输一次输200，平局不赔钱。

  开始WA了几次，每次WA了之后都找到了错误的样例，主要是坑在平局的问题上。。正确做法应该是这样：先排序，把田忌最左边的和齐王最左边的比较，能赢就比赛。把田忌最右边的和齐王最右边的比较，能赢就比赛。如果左边右边都不赢，那就那田忌最左边的和齐王最右边的比赛。

  设田忌最左边为A1,最右边为A2，齐王最左边为B1，最右边为B2。

  A1>B1:  那肯定A1去和B1比最划算，赢一把。

  A2>B2:  A2和B2比，赢一把。会不会有可能存在比A2小的也比B2大，用那个更划算？确实可能存在比A2小的也比B2大，这就说明它比最大的都大了，肯定比B2之前的都大，说明它和A2的效果是一样的都能赢齐王剩下的任何马，所以用它和B2比和用A2和B2比是没什么区别的。

  A1=B1,A2=B2: 若A1<A2，也就是A1<B2，过去虽然还亏了200块，但是这样说明B1<A2，拿这两个比的话赚200，等于不赚不亏。若A1=A2，也是不赚不亏。所以这种情况用这个方法也不矛盾。

  A1<B1,A2=B2 : A1反正也是输，输给B2或许A2还能赢B1。

  A1=B1,A2<B2: 已经没有马能打过B2了，必输一次，就拿最垃圾的马过去，不要浪费了好马=。=

  A1<B1,A2<B2 : 同上，反正怎样都要输给B2。

#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#define INF 0x3f3f3f3f
#define MAXN 1010
#define MAXM 60
#define eps 1e-9
#define pii pair<int,int>
using namespace std;
int N,a[MAXN],b[MAXN],B[MAXN];
int main(){
    freopen("in.txt","r",stdin);
    while(scanf("%d",&N),N){
        for(int i=0;i<N;i++) scanf("%d",&a[i]);
        for(int i=0;i<N;i++) scanf("%d",&b[i]);
        sort(a,a+N);
        sort(b,b+N);
        int tp1=0,tp2=N-1,gp1=0,gp2=N-1,win=0;
        while(tp1<=tp2){
            if(a[tp1]>b[gp1]){
                win++;
                tp1++;
                gp1++;
            }
            else if(a[tp2]>b[gp2]){
                win++;
                tp2--;
                gp2--;
            }
            else{
                if(a[tp1]<b[gp2]) win--;
                tp1++;
                gp2--;
            }
        }
        printf("%d\n",win*200);
    }
    return 0;
}