df

hdu 1052 Tian Ji -- The Horse Racing

  (2011-08-26 08:32:51)

转载▼

标签：  杂谈

分类： acm杂谈

Tian Ji -- The Horse Racing

Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 65536/32768K (Java/Other)

Total Submission(s) : 3   Accepted Submission(s) : 1

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

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

开始我自己做了几下，WA，后发现等于的情况时没考虑，哎，开始以为这题目简单，原来不是我想的

那样简单，后看如别人的写的思路和证明才模拟写的，现在吧别人的给大家看下（转载臭臭吧）：

题目大意：田忌和国王赛马，给出马的数量n，然后是田忌的n匹马，国王的n匹马。问田忌最多可以赢得多少比赛（一场200块）。

这道题目以前看过，但是没有弄出来，思路是：田忌的最快的马比国王最快的马快，就用田忌最快的马跟国王最快的马比；如果田忌最快的马比国王最快的马慢，就用田忌最慢的马比。

因为只是知道要这样，但对于其他的情况，根本弄不明白要怎么比法，当马的速度一样快的时候，就

    

因为比赛的时候，是国王先出马，然后田忌再出，田忌有主动权上的优势。

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

贪心的策略：

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

证明一、：假设现在国王最快的马是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<iostream>
#include<algorithm>
using namespace std;

#define N 1010
int T[N],K[N];

bool cmp(int a,int b)
{
       return a>b;
}

int main()
{
       int ti,tj,ki,kj,win,n;
       while(scanf("%d",&n)&&n!=0)
      {
             for(int i=0;i<n;i++)
             scanf("%d",&T[i]);
             for(i=0;i<n;i++)
             scanf("%d",&K[i]);

             sort(T,T+n,cmp);
             sort(K,K+n,cmp);
             ti=ki=0;
             tj=kj=n-1;

             for(i=0,win=0;i<n;i++)
             {
                   if(T[ti]>K[ki])
                   {
                         ti++;
                         ki++;
                         win++;
                   }
                  else if(T[ti]<T[ki])
                  {
                        tj--;
                        ki++;
                        win--;
                  }
                 else
                 {
                        if(T[tj]>K[kj])
                        {
                              tj--;
                             kj--;
                             win++;
                         }
                        else if(T[tj]<K[kj])
                        {
                              tj--;
                              ki++;
                              win--;
                        }
                        else
                        {
                              if(T[tj]<K[ki])
                              {
                                     tj--;
                                   ki++;
                                   win--;
                              }
                        }
                }
     }
    printf("%d ",win*200);
 }
 return 0;
}