递归和分治的应用(pku 2287)

 

Tian Ji -- The Horse Racing
Time Limit:5000MS  Memory Limit:65536K
Total Submit:2453 Accepted:659

Description
Here is a famous story in Chinese history.

 

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

 

Sample Output

 

Source
Shanghai 2004

解答:  递归和分治的应用

对于这个经典问题首先我们从题目中可以得到这么一个信息这是一个最优问题，类似于我们上面讲到的背包问题。与背包问题不同的是田忌赛马是一个由双方共同来决定最优。那么根据背包的思路可以得到，要想做到最优，那么就要使马赢得最优。也就是说田忌略胜一筹就可以了。所以我们首先把双方的马按速度排序起来。这样我们只要算出田忌能赢的场数和平的场数计算出来就可以了。田忌和国王的马都从强到弱遍历。这样我们就可以根据实力的不同产生3个分支，田忌的马胜，那双方都遍历下一个，田忌的马平就产生两个分支，一种是那双方都遍历下一个，另一种国王去遍历下一个（田忌拿这马去和国王的下匹马比），如果国王的马胜，那国王遍历下一个。我的源码写的是从小到大遍历，情况类似。。。

/**/ /*
writen by sunboy
07.8.12
思路: 递归和分治的应用
*/
#include  < iostream >
#include  < vector >
#include  < algorithm >
using   namespace  std;
vector < int >  tian,king;
int  horses;
int  win,tie,loss;
int  matrix[ 1024 ][ 1024 ];
void  Init()
... {
    int i,j;
    tian.clear();
    king.clear();
    win=tie=loss=0;
    for(i=0;i<1024;i++)
     for(j=0;j<1024;j++)
      matrix[i][j]=-1;
}
bool  Input()
... {
    Init();
    cin>>horses;
    if(!horses) return false;
    int i,tmp;
    for(i=0;i<horses;i++)
      ...{  
             cin>>tmp;
             tian.push_back(tmp);
      }  
    for(i=0;i<horses;i++)
      ...{  
             cin>>tmp;
             king.push_back(tmp);
      }
      sort(tian.begin(),tian.end());
      sort(king.begin(),king.end());       
   return true; 
}
int  max( int  a, int  b)
... {
    return a>b?a:b;
}
int  fun( int  x, int  y)
... {
    if(matrix[x][y]!=-1) return matrix[x][y];
    if(x>=horses||y>=horses) return matrix[x][y]=0;
    if(tian[x]>king[y]) return matrix[x][y]=fun(x+1,y+1)+200;
    if(tian[x]<king[y]) return matrix[x][y]=fun(x+1,y)-200;
    if(tian[x]==king[y]) return matrix[x][y]=max(fun(x+1,y+1),fun(x+1,y)-200);
    return 0;
}
void  Solve()
... {
  cout<<fun(0,0)<<endl;    
}
int  main()
... {

 while(Input())
  Solve();
    
  return 0;
}

200
0
0

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

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.