贪心思想（2021/7/15）

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
老长的一段文字说明，这里说说大意：就是田忌现在有n匹马，秦王现在也有n匹马，赢一把加200，输一把扣200，平局不加不扣。给数据，求田忌能获得的最大钱数。
乍一看觉得简单：（WA了五次，最后终于想明白问题在哪了）
首先田忌赛马的思路是假设局面已经给定了，我们想象用线将田忌的马和秦王的马连在一块，表示这两匹马比赛。
注意：（我们是由必定的子情况中找出对田忌可能最有利的，这样才能说明全部最优是当前局部最优的子集，相当于一直缩小子集范围，一直循环到最后，则当前最优就是整体最优）后面所有提到的强都是将这些马从强到弱排好队后，队首的那一个，有可能队首和队首后一个一样强，为了方便叙述采取了这么一个不严谨的说法
如果田忌最拉的马比亲王最拉的马还拉，说明对应所有情况（n^n）中田忌的这匹马必输，那么输就要输给最强的马，这样剩余的局面才可能对田忌最有利。
如果两者最拉的马一样强，就出现问题了，到底是把两者比掉，还是说让田忌的这匹马当炮灰，输给秦王最强的马呢。
因为这不是一个确定的情况（因为可以不变也可以-200，-200情况中不一定不包含整体最优），所以我们从两人最强的马比较（换切入口），如果田忌最强的马比秦王的还强，那么这匹马比秦王所有马强，整体最优一定包含在这匹马选择与秦王最强的马比赛的情况中。如果不比秦王最强马强，那么就需要最弱的炮灰将秦王当前最强马换掉，这样才是最划算的。这里一定要想清楚，而不是选择强强对决（0或-200）或者弱弱对决（0）。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<deque>
using namespace std;
const int N=1005;
bool cmp(int x,int y){//从大到小排序 
	return x>y;
}
deque<int>q;
deque<int>q1;

int main(){
	int a[N]={0},b[N]={0};
	int t;
	while(~scanf("%d",&t)){
		if(t==0)
			break;
		q.clear();
		q1.clear();
		for(int i=0;i<t;i++)
			scanf("%d",&a[i]);
		for(int i=0;i<t;i++)
			scanf("%d",&b[i]);
		sort(a,a+t,cmp);
		sort(b,b+t,cmp);
		for(int i=0;i<t;i++){//双端队列头的最大 
			q.push_back(a[i]);
			q1.push_back(b[i]);
		}
		int ans=0;
		while(!q.empty()&&!q1.empty()){
			if(q.back()>q1.back()){
				ans+=200;
				q.pop_back();
				q1.pop_back();
			}
			else if(q.back()==q1.back()){
				while(!q.empty()&&!q1.empty()){//提高效率 
					if(q.front()>q1.front()){
						ans+=200;
						q.pop_front();
						q1.pop_front();
					}
					else{//改变了尾巴跳出循环 
						if(q.back()<q1.front())//
							ans-=200;
						q1.pop_front();
						q.pop_back();
						break;
					}
				}		
			}
			else{
				ans-=200;
				q1.pop_front();
				q.pop_back();
			}		
		}
		cout<<ans<<endl;
	}	
	return 0;
}

贪心思想其实比较难以把握，据说这道题还有二分匹配的解法。