HDU1052

Tian Ji -- The Horse Racing

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 15975    Accepted Submission(s): 4622

Problem Description

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 integer n (n <= 1000) on the first line, which is the number of horses on each side. The next n integers on the second line are the speeds of Tian’s horses. Then the next n 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
  
  

 

题意：没啥好说的，田忌赛马问题，要让田忌赢得更多的场次。
思路：蛮麻烦的一个贪心过程，我是在有三匹马的状态下画了可能的21种情况，然后21种状态下的出马过程推得，然后学习了别人的贪心过程，拿来与之分享。

先对田忌和国王的马进行排序。

贪心的策略：

一、当田忌最快的马比国王最快的马快时，用田忌最快的马赢国王最快的马。
二、当田忌最快的马比国王最快的马慢时，用田忌最慢的马输给国王最快的马。
三、当田忌最快的马跟国王最快的马一样快时，分情况。

证明一、：假设现在国王最快的马是K，田忌最快的马是T，如果存在一种更优的比赛策略，让T的对手不是K，而使得田忌赢更多的钱的话，那么设此时K的对手是t，T的对手是k：(T>K&&T>t&& K>k)
1、若t>K，则有T>k，t>K。这个结果和T>K，t>k是相同的。
2、若k<t≤K，则有T>k，t≤K。这个结果不如T>K，t>k来得优秀。
3、若t≤k≤K，则有T>k，t≤K。这个结果和T>K，t≤k是相同的。
由此可知，交换各自对手后，一定不会使得结果变劣，那么假设是不成立的。

得证！！

证明二、：因为田忌最快的马比国王最快的马慢，所以田忌所有的马都比国王最快的马慢，也就是说此时田忌的所有马都赢不了国王的马，而出于贪心的思想，应该保留相比之下更快的马，因此用最慢的马去输一定不会比用别的马去输来得劣。

得证！！

其实上面这两个很容易就想得到，最难的是相等的时候。因为不可以直接让田忌最快的马跟国王最快的马打平，或者直接用最慢的马去输给国王最快的马。（存在反例）

1、如果选择全部打平，那么对于田忌 1 2 3 4，国王 1 2 3 4 ，这组数据，田忌什么黄金也得不到。但是如果选择1->4, 4->3, 3->2,2->1田忌可以得到400两黄金。 (大雄想的)

2、如果选择用最慢的马输掉比赛的话，对于田忌   3 4，国王 1    4，这组数据，田忌一胜一负，什么黄金也得不到，但是如果田忌选择 3->1 ,4->4 ,一胜一平，田忌可以得到200两黄金。

所以：对于情况三，我们应该从最慢的马开始考虑了

1、当田忌最慢的马比国王最慢的马快，那么用田忌最慢的马赢国王最慢的马

2、当田忌最慢的马比国王最慢的马慢，那么用田忌最慢的马输给国王最快的马

3、当田忌最慢的马跟国王最慢的马相等的时候，用田忌最慢的马跟国王最快的马比

证明1、：假设现在国王最慢的马是K，田忌最慢的马是T，如果存在一种更优的比赛策略，让T的对手不是K，而使得田忌赢更多的钱的话，那么设此时K的对手是t，T的对手是k：(T>K&&t>T&& k>K)
1、若T>k，则有T>k，t>K。这个结果和T>K，t>k是相同的。
2、若T<k≤t，则有T<k，t>K。。这个结果不如T>K，t>k来得优秀。
3、若K≤t≤k，则有T>k，t≤K。这个结果和T>K，t≤k是相同的.

由此可知，交换各自对手后，一定不会使得结果变劣，那么假设是不成立的。

得证！！

证明2、：因为田忌最慢的马比国王最慢的马慢，所以田忌最慢的马都比国王所有的马慢，也就是说此时田忌最慢的马赢不了国王的任何一匹马，而出于贪心的思想，应该去掉

国王最快的马，因此输给国王最快的马一定不会比输给其他的马来得劣。

得证！！

证明3、：因为田忌最快T和最慢t的马与国王最快K和最慢k的马都相等，如果用最快的马跟国王最快的马比，最慢的马和国王最慢的马比，那么田忌什么收获也没有。此时是T->K,t->k,

其实这个时候我们可以换个角度想，上面这种情况跟T->k,t->k,没有什么区别，都是双方少了最快和最慢的马。但是从证明二可知，我们必须让最慢的马输给国王最快的马，

而在田忌的马中找任何一匹比最慢的马快一点的马去赢国王最慢的马都行，这样田忌在同样一胜一负的情况下，保留了跑得更快的马，会比把最快的马拿去比赛来得更优些。

得证！！

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
bool cmp(int a,int b)
{
    return a>b;
}
int main()
{
    int a[1005],b[1005];
    int n;
    while(cin>>n)
    {
        if(n==0)
            return 0;
        int i,j;
        for(i=0;i<n;i++)
            cin>>a[i];
        for(i=0;i<n;i++)
            cin>>b[i];
        sort(a,a+n,cmp);
        sort(b,b+n,cmp);
        int sum=0;
        int s1,s2;
        s1=s2=0;
        int e1,e2;
        e1=e2=n-1;
        for(i=0;i<n;i++)
        {
            if(a[s1]>b[s2])
            {
                s1++;
                s2++;
                sum++;
            }
            else
                if(a[s1]<b[s2])
            {
                e1--;
                sum--;
                s2++;

            }
            else
            {
                if(a[e1]>b[e2])
                {
                    sum++;
                    e1--;
                    e2--;
                }
                else
                    if(a[e1]<b[e2])
                {
                    e1--;
                    s2++;
                    sum--;
                }
                else
                {
                    if(a[e1]<b[s2])
                    {
                        e1--;
                        s2++;
                        sum--;
                    }
                }
            }
        }
        cout<<sum*200<<endl;

    }
    return  0;



}