hd1950 Bridging signals

Bridging signals

Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 1002    Accepted Submission(s): 660

Problem Description

'Oh no, they've done it again', cries the chief designer at the Waferland chip factory. Once more the routing designers have screwed up completely, making the signals on the chip connecting the ports of two functional blocks cross each other all over the place. At this late stage of the process, it is too
expensive to redo the routing. Instead, the engineers have to bridge the signals, using the third dimension, so that no two signals cross. However, bridging is a complicated operation, and thus it is desirable to bridge as few signals as possible. The call for a computer program that finds the maximum number of signals which may be connected on the silicon surface without rossing each other, is imminent. Bearing in mind that there may be housands of signal ports at the boundary of a functional block, the problem asks quite a lot of the programmer. Are you up to the task?

Figure 1. To the left: The two blocks' ports and their signal mapping (4,2,6,3,1,5). To the right: At most three signals may be routed on the silicon surface without crossing each other. The dashed signals must be bridged.
A typical situation is schematically depicted in figure 1. The ports of the two functional blocks are numbered from 1 to p, from top to bottom. The signal mapping is described by a permutation of the numbers 1 to p in the form of a list of p unique numbers in the range 1 to p, in which the i:th number pecifies which port on the right side should be connected to the i:th port on the left side.
Two signals cross if and only if the straight lines connecting the two ports of each pair do.

 

Input

On the first line of the input, there is a single positive integer n, telling the number of test scenarios to follow. Each test scenario begins with a line containing a single positive integer p<40000, the number of ports on the two functional blocks. Then follow p lines, describing the signal mapping: On the i:th line is the port number of the block on the right side which should be connected to the i:th port of the block on the left side.

 

Output

For each test scenario, output one line containing the maximum number of signals which may be routed on the silicon surface without crossing each other.

 

Sample Input

4

6 4 2 6 3 1 5

10 2 3 4 5  6 7 8 9 10 1

8 8 7 6 5 4 3 2 1

9 5 8 9 2 1 3 7 4 6

 

Sample Output

   
   

    
    3
9
1
4
   
   
   
   

    
     
   
   
   
   

    
    嗯，题目大意其实就是让求所给序列的最长上升子序列的长度
   
   
   
   

    
    嗯，上午学长讲的是题目只是让求长度，就可以只求长度而先不计较子序列的正确性。
   
   
   
   

    
    就是先把所给序列的第一个元素放进去，然后要放的下一个元素比它大就直接放进去，否则就往前查找直到找到比它小的那个元素然后放到那个元素后面
   
   
   
   

    
    例如4 2 6 3 1 5这个序列，我设置的now序列0号位置放0，然后放4在1号位置，然后2比4小比0大，就替换掉4放在1号位置，之后放6在2号位置，然后放3时，3比6小比2大，就替换掉6放在2号位置，之后放1,1比2小比0大，把它放到1号位置，之后放5在3号位置。虽然该序列并不是原序列的最长上升子序列但是长度是相等的。
   
   
   
   

    
    才发现，上午讲的二分，我却木用二分。。。。
   
   
   
   

    
    
#include<cstdio>//982ms
#include<cstring>
#include<algorithm>
using namespace std;
int rec[50000];
int now[50000];
int main()
{
	int t,n,i,top,m;
	scanf("%d",&t);
	while(t--)
	{
		memset(rec,0,sizeof(rec));
		scanf("%d",&n);
		for(i=0;i<n;++i)
		{
			scanf("%d",&rec[i]);
		}
		now[0]=0;
		now[1]=rec[0];
		top=1;
		for(i=1;i<n;++i)
		{
			if(rec[i]>now[top])
				now[++top]=rec[i];
			else 
			{
				m=top;
				while(m>=0)
				{
					if(rec[i]<now[m]&&rec[i]>now[m-1])
						now[m]=rec[i];
					else m--;
				}
			}
		}
		printf("%d\n",top);	
	}
	return 0;
}
   
   
   
   

    
    果然自己写的比较水，982ms,而。。
   
   
   
   

    
    
//STL里的lower_bound  78ms
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int rec[50000];
int now[50000];
int main()
{
	int t,n,i,top,m;
	scanf("%d",&t);
	while(t--)
	{
		memset(rec,0,sizeof(rec));
		scanf("%d",&n);
		for(i=0;i<n;++i)
		{
			scanf("%d",&rec[i]);
		}
		now[0]=0;
		now[1]=rec[0];
		top=1;
		for(i=1;i<n;++i)
		{
			if(rec[i]>now[top])
				now[++top]=rec[i];
			else 
			{
				int pos=lower_bound(now+1,now+top+1,rec[i])-now;
				now[pos]=rec[i];
			}
		}
		printf("%d\n",top);	
	}
	return 0;
}