Tian Ji -- The Horse Racing

Time Limit : 2000/1000ms (Java/Other) Memory Limit : 65536/32768K (Java/Other)
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

Source
2004 Asia Regional Shanghai

首先表示当看到大段英文时，心里就不想做了；其次理解题意后，也并无思路。在看了众多博客后，得此结果。
算法：贪心算法（局部最优）
思路：所谓“略胜一筹”原则，也就是贪心算法，尽可能多赢，注意：每次参赛的只有最优或最劣的马，参完赛后，最优或者最劣的马就会被消耗掉，也就是从双方的数组中剔除，双方剩下的马仍然是一个有着最优和最劣的相等的数组。（注：将数组升序）
情况：从局部来看每组情况中均要考虑双方最优或最劣马的比赛情况，有以下三种情况：
（1）如果田忌的最劣马比国王的最劣马速度快，则田忌赢得200元，同时将跳过双方存在此次参赛的马的数组元素进行下一轮。
（2）如果田忌的最劣马比国王的最劣马速度慢，则田忌输 200元，同时以田忌最劣马消耗国王最优马，同时下一轮跳过含有此次参赛的马。
（3）平局，则比较田忌最优马和国王最优马，（1）如果又相等，则说明田忌和国王的马速度均相同，平局。（2）如果田忌最劣马速度小于国王最优马， 以局部最优法则来看，应以田忌最劣马消耗国王最优马，田忌输200元。
排序方法：qsort，函数名：#include<stdlib.h> 主函数中的调用：qsort(s（数组）,n,sizeof(type),cmp);
函数体：
int cmp ( const void *a , const void *b )

{
return *(int *)a - *(int *)b; //升序排序

//return *(int *)b - *(int *)a; //降序排序
}

代码：

#include<stdio.h>
#include<stdlib.h>
int compare(const void *a,const void *b){//升序
	return (*(int *)a - *(int *)b);
}
int main(){
	int n,a[1000],b[1000];
	while(scanf("%d",&n)){
		int count=0;
		int as=0,ae=n-1;
		int bs=0,be=n-1;
		if(n==0)
			break;
		for(int i=0;i<n;i++){
			scanf("%d",&a[i]);
		}
		for(int i=0;i<n;i++){
			scanf("%d",&b[i]);
		}
		qsort(a,n,sizeof(int),compare);
		qsort(b,n,sizeof(int),compare);
		while(as<=ae&&bs<=be){
			if(a[as]>b[bs]){//田忌最劣马优于国王最劣马
				count+=200;
				as++;
				bs++;
			}
			else if(a[as]<b[bs]){//田忌最劣马劣于国王最劣马
				count-=200;
				as++;
				be--;
			}
			else{//平局
				if(a[ae]>b[be]){//田忌最优马优于国王最优马
					count+=200;
					ae--;
					be--;
				}
				else if(a[ae]<b[be]){//田忌最优马劣于国王最优马
					count-=200;
					as++;
					be--;
				}
				else{//双方优马同，劣马同
					if(a[as]<b[be]){//田忌最劣马劣于国王最优马，田忌用劣马消耗国王优马
						count-=200;
						as++;
						be--;
					}
					else
					   break;//双方马均相同，平局
				}
				
			}
		}
		printf("%d\n",count);
}
	return 0;
}