HDU P5200 Trees

Trees

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 193    Accepted Submission(s): 65

Problem Description

Today CodeFamer is going to cut trees.There are  N  trees standing in a line. They are numbered from  1  to  N . The tree numbered  i  has height  hi . We say that two uncutted trees whose numbers are  x  and  y  are in the same block if and only if they are fitting in one of blow rules:

1)x+1=y or y+1=x;

2)there exists an uncutted tree which is numbered  z , and  x  is in the same block with  z , while  y  is also in the same block with  z .

Now CodeFamer want to cut some trees whose height is not larger than some value, after those trees are cut, how many tree blocks are there?

 

Input

Multi test cases (about  15 ).

For each case, first line contains two integers  N  and  Q  separated by exactly one space, N indicates there are  N  trees,  Q  indicates there are  Q  queries.

In the following  N  lines, there will appear  h[1],h[2],h[3],…,h[N]  which indicates the height of the trees.

In the following  Q  lines, there will appear  q[1],q[2],q[3],…,q[Q]  which indicates CodeFamer’s queries.

Please process to the end of file.

[Technical Specification]

1 \leq N, Q \leq 50000

0≤h[i]≤1000000000(109)

0≤q[i]≤1000000000(109)

 

Output

For each  q[i] , output the number of tree block after CodeFamer cut the trees whose height are not larger than  q[i] .

 

Sample Input

  
  

   
   3 2
5
2
3
6
2
  
  

 

Sample Output

  
  

   
   0
2


   
   

    
    

     
     Hint
    
    
In this test case, there are 3 trees whose heights are 5 2 3.

For the query 6, if CodeFamer cuts the tree whose height is not large than 6, the height form of left trees are -1 -1 -1(-1 means this tree was cut). Thus there is 0 block.

For the query 2, if CodeFamer cuts the tree whose height is not large than 2, the height form of left trees are 5 -1 3(-1 means this tree was cut). Thus there are 2 blocks.
   
   
   
    
  
  
  
  

   
   

  
  

BC#36的第三道题，官方做法是线段树，但是其实很多人和我一样用了贪心完成了这题。

题意为n颗树，q条指令，指令为斩掉长度为q[i]及以下的树枝，问我们还剩几个树堆。所谓树堆其实就是挨在一块的树群。

可以想到，一开始是一个树堆，怎么样会增加树堆呢？当一个底谷树被砍掉的时候增加。高峰被砍掉的必减少一个树堆。所以我们可以先把数列中的底谷和高峰排序，并把指令也排序，根据指令来一步步砍掉从矮到高的底谷或高峰，答案就出来了，并且时间复杂度也允许。不过注意一下，当数列中出现3 2 2 2 3即底谷或高峰出现连续相同数字的时候，只能计一个底谷或高峰。

代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<ctime>
#include<string>
#include<cstring>
#include<algorithm>
#include<fstream>
#include<queue>
#include<stack> 
#include<vector>
#include<cmath>
#include<iomanip>
#define rep(i,n) for(i=1;i<=n;i++)
#define MM(a,t) memset(a,t,sizeof(a))
#define INF 1e9
typedef long long ll;
#define mod 1000000007
using namespace std;
class node{
  public:
    int op;
	int num;	
}a[100020];
int m[100020];
class qu{
  public:
    int ind;
	int v;	
}q[100020];
int n,m2,n2; 
int res[100020];
bool cmp(node a,node b){
  return a.num<b.num;	
}
bool cmp2(qu a,qu b){
  return a.v<b.v;	
}
int main()
{
	int i,j,cnt;

    while(scanf("%d%d",&n,&m2)!=EOF){
      rep(i,n) scanf("%d",&m[i]);
	  m[0]=-1; m[n+1]=-1;
      i=1; n2=0;
	  while(i<=n){
  	    int pr=i-1,now=m[i];
		while(i<=n && m[i+1]==now) i++;
		if(m[pr]>now && m[i+1]>now){
		  n2++;
		  a[n2].op=0;
		  a[n2].num=now;	
		}  	
		if(m[pr]<now && m[i+1]<now){
		  n2++;
		  a[n2].op=1;
		  a[n2].num=now;	
		}
		i++;
  	  } 	
  	  sort(a+1,a+n2+1,cmp);
  	  rep(i,m2){
  	    q[i].ind=i;
		scanf("%d",&q[i].v);	
  	  }
  	  sort(q+1,q+m2+1,cmp2);
  	  cnt=1; j=1;
  	  rep(i,m2){
  	    int now=q[i].v;
		while(j<=n2 && now>=a[j].num){
		  if(a[j].op==1) cnt--;
		  else           cnt++;
		  j++;	
		}	
		res[q[i].ind]=cnt;
  	  }
  	  rep(i,m2) printf("%d\n",res[i]);
    }
	
	return 0;
}