Description

Astronomers often examine star maps where stars are represented by points on a plane and each star has Cartesian coordinates. Let the level of a star be an amount of the stars that are not higher and not to the right of the given star. Astronomers want to know the distribution of the levels of the stars. 

For example, look at the map shown on the figure above. Level of the star number 5 is equal to 3 (it's formed by three stars with a numbers 1, 2 and 4). And the levels of the stars numbered by 2 and 4 are 1. At this map there are only one star of the level 0, two stars of the level 1, one star of the level 2, and one star of the level 3. 

You are to write a program that will count the amounts of the stars of each level on a given map.

Input

Output

Sample Input

5
1 1
5 1
7 1
3 3
5 5

Sample Output

1
2
1
1
0

 与树状数组的解法一样,  查询更新就可以了. 

	树状数组 解法传送门 : http://www.cnblogs.com/MiYu/archive/2010/08/26/1808963.html 

代码如下 : 

/*
Mail to   : miyubai@gamil.com
Link      : http://www.cnblogs.com/MiYu  || http://www.cppblog.com/MiYu
Author By : MiYu
Test      : 1
Complier  : g++ mingw32-3.4.2
Program   : POJ_2352
Doc Name  : Stars
*/
//#pragma warning( disable:4789 )
#include <iostream>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <utility>
#include <queue>
#include <stack>
#include <list>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
using namespace std;
struct P{
       int x, y;
}p[15010];
int seg[100000];
int NN = 32768, res[15010];
int get ( int &n ) {
    int i = 1;
    while ( i < n ) i << 1;
    return i;    
}
void modify ( int &pos ) {
     pos += NN;
     seg[pos] ++;
     while ( pos > 1 ) {
           if ( ~pos & 1 ) seg[pos>>1] ++;
           pos >>= 1;
     }
}
int query ( int pos ) {
     pos += NN;  
     int sum = seg[pos];
     while ( pos > 1 ) {
            if ( pos & 1 ) {
                 sum += seg[pos>>1];  
            }      
            pos >>= 1;
     }   
     return sum;
}
int main ()
{
    int N;
    while ( scanf ( "%d", &N ) == 1 ) {
           int pos;
           memset ( res, 0, sizeof ( res ) );
           memset ( seg, 0, sizeof ( seg ) );
           for ( int i = 0; i < N; ++ i ) {
                  scanf ( "%d%*d", &pos );
                  res[ query ( pos ) ] ++;
                  modify ( pos );   
           }   
           for ( int i = 0; i < N; ++ i ) {
                printf ( "%d\n", res[i] );     
           } 
    }
    return 0;
}

Man Down

The Game “Man Down 100 floors” is an famous and interesting game.You can enjoy the game from 
http://hi.baidu.com/abcdxyzk/blog/item/16398781b4f2a5d1bd3e1eed.html

We take a simplified version of this game. We have only two kinds of planks. One kind of the planks contains food and the other one contains nails. And if the man falls on the plank which contains food his energy will increase but if he falls on the plank which contains nails his energy will decrease. The man can only fall down vertically .We assume that the energy he can increase is unlimited and no borders exist on the left and the right.

First the man has total energy 100 and stands on the topmost plank of all. Then he can choose to go left or right to fall down. If he falls down from the position (Xi,Yi),he will fall onto the nearest plank which satisfies (xl <= xi <= xr)(xl is the leftmost position of the plank and xr is the rightmost).If no planks satisfies that, the man will fall onto the floor and he finishes his mission. But if the man’s energy is below or equal to 0 , he will die and the game is Over.

Now give you the height and position of all planks. And ask you whether the man can falls onto the floor successfully. If he can, try to calculate the maximum energy he can own when he is on the floor.(Assuming that the floor is infinite and its height is 0,and all the planks are located at different height).

4
10 5 10 10
5 3 6 -100
4 7 11 20
2 2 1000 10

140

 /*

  题目描述:  

          不同高度处有不同的水平板，跳到该板会有血量变化v，

          问当一个人从最高板开始，可以向左或者向右，

          竖直跳到下面的板，求下落到地面的最大血量，或者-1。

          线段树+dp  

          需要用线段树查询得到每个板的两个端点下落后会到哪个板；

          然后根据这个从最高的开始dp就可以了

          dp[i] = max ( dp[i], dp[i^].v )  // dp[i^] 代表能走到 i 的线段 

/* 

/*

Mail to   : miyubai@gamil.com

Link      : http://www.cnblogs.com/MiYu  || http://www.cppblog.com/MiYu

Author By : MiYu

Test      : 1

Complier  : g++ mingw32-3.4.2

Program   : HDU_3016

Doc Name  : Man Down

*/

//#pragma warning( disable:4789 )

#include <iostream>

#include <fstream>

#include <sstream>

#include <algorithm>

#include <string>

#include <set>

#include <map>

#include <utility>

#include <queue>

#include <stack>

#include <list>

#include <vector>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <cmath>

#include <ctime>

using namespace std;

struct seg_tree {

    int id, left, right;

    int mid () { return ( left + right )>>1; }  

}seg[333333];

inline void creat ( int x, int y, int rt = 1 ) {

     seg[rt].left = x;

     seg[rt].right = y;

     //0 代表地面 其他的自然数代表各层的木板编号  -1 代表有多条线段覆盖 

     seg[rt].id = 0;                  

     if ( x == y ) return ;

     int mid = seg[rt].mid();

     creat ( x, mid, rt << 1 );

     creat ( mid + 1, y, rt << 1 | 1 );     

}

inline void modify ( int x, int y, int id, int rt = 1 ) {

     //找到了线段, 直接修改ID 覆盖掉 

     if ( seg[rt].left == x && seg[rt].right == y ) {

         seg[rt].id = id;

         return;   

     }

     int LL = rt << 1, RR = rt << 1 | 1, mid = seg[rt].mid();

     // 前面没有return掉, 那么这条线段肯定是被覆盖的, 将它的标记下传后标记为-1 

     if ( seg[rt].id != -1 ) {      

         seg[LL].id = seg[RR].id = seg[rt].id;          

         seg[rt].id = -1;

     }      

     if ( y <= mid ) modify ( x, y, id, LL ); //分段修改 

     else if ( x > mid ) modify ( x, y, id, RR );

     else {

          modify ( x, mid, id, LL );

          modify ( mid + 1, y, id, RR );     

     }

}

inline int query ( int pos, int rt = 1 ) {   // 查询 Pos 所在线段的 id  

    if ( seg[rt].id != -1 ) return seg[rt].id; //线段被覆盖 直接返回 ID 

    int LL = rt << 1, RR = rt << 1 | 1, mid = seg[rt].mid();

    if ( pos <= mid ) return query ( pos, LL );             //分段查询 

    else return query ( pos, RR );    

}

inline bool scan_d(int &num)  //整数输入

{

        char in;bool IsN=false;

        in=getchar();

        if(in==EOF) return false;

        while(in!='-'&&(in<'0'||in>'9')) in=getchar();

        if(in=='-'){ IsN=true;num=0;}

        else num=in-'0';

        while(in=getchar(),in>='0'&&in<='9'){

                num*=10,num+=in-'0';

        }

        if(IsN) num=-num;

        return true;

}

struct Plank {

       int x,y,h,v,left,right; 

       //按高排序       

       friend bool operator < ( const Plank &a, const Plank &b ) {

              return a.h < b.h;

       }

}pk[100010];

int dp[100010];

int main ()

{

    int N, M;

    creat ( 1, 100000 );

    while ( scan_d ( N ) ) {

           M = -1;

           for ( int i = 1; i <= N; ++ i ) {

                scan_d ( pk[i].h );scan_d ( pk[i].x );scan_d ( pk[i].y );scan_d ( pk[i].v );

                if ( pk[i].y > M ) M = pk[i].y;       // 记录 区间最大值, 加速用的 

           }

           modify  ( 1, M, 0 );

           sort ( pk + 1, pk + N + 1 );               // 按高排序 

           memset ( dp, 0, sizeof ( dp ) );

           dp[N] = 100 + pk[N].v;

           // 自底向上 更新 线段, 记录 每条线段 左右端点能到达的 线段 ID 

           for ( int i = 1; i <= N; ++ i ) {          

                int x = pk[i].left = query ( pk[i].x );

                int y = pk[i].right = query ( pk[i].y );

                modify ( pk[i].x, pk[i].y, i );

           }

           int res = -1;

           //自顶向下 DP    dp[i] = max ( dp[i], dp[i^].v )  

           // dp[i^] 代表能走到 i 的线段 

           for ( int i = N; i >= 1; -- i ) {   

               if ( dp[ pk[i].left ] < dp[i] + pk[ pk[i].left ].v )

                    dp[ pk[i].left ] = dp[i] + pk[ pk[i].left ].v;

               if ( dp[ pk[i].right ] < dp[i] + pk[ pk[i].right ].v )

                    dp[ pk[i].right ] = dp[i] + pk[ pk[i].right ].v; 

           } 

           printf ( "%d\n",dp[0] > 0 ? dp[0] : -1 );

    }

    return 0;

}

Billboard

3 5 5
2
4
3
3
3

1
2
1
3
-1

一开始没想明白怎么做 ,  仔细想了想,   再次 读题后 发现 , n <= 200000;  也就是说  最多 也就 200000 条广告 , 你就算每行贴一张 ,

最多也就贴到 200000 行,  所以  不要被  h <= 10^9  次方吓到了  ,认为 线段树开不了那么大的数组  . 只要开 200000 就可以了 .

其他的 没什么 好说的 , 知道这个 就直接 暴 吧 ............将近 7000MS .=水过.................   g++提交 还华丽的 送出了 一次 TLE....

C++  水过了 ............

//    一直没明白 为什么我的 代码速度 那么 慢,  查询后 更新 的时间是 2000MS 左右  , 我的 是 查询 就更新了,

竟然要 将近 7000MS ? 非常 郁闷 ,  不信邪的 继续 检查 代码, 在 瞪了 1哥小时后 , 忽然想到 : 把 cout 改成

printf 会怎样?   结果 :  1640 MS  AC ..............鬼知道他的 数据量有多大..... cout 和 printf

竟然 差了 5000 MS 的时间 ...........无语

代码如下 :

 /*

Coded By  : MiYu

Link      : http://www.cnblogs.com/MiYu  || http://www.cppblog.com/MiYu

Author By : MiYu

Test      : 1

Program   : 2795

*/

//#pragma warning( disable:4789 )

#include <iostream>

#include <algorithm>

#include <string>

#include <set>

#include <map>

#include <utility>

#include <queue>

#include <stack>

#include <list>

#include <vector>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <cmath>

using namespace std;

struct ADV {

       int left, right, val;

       int mid () { return ( left + right ) >> 1; }     

}adv[800000];

int N, W, H, w;

void creat ( int l, int r, int rt = 1 ){

     adv[rt].left = l;

     adv[rt].right = r;

     adv[rt].val = W;

     if ( l == r )

        return ;

     int mid = adv[rt].mid();

     creat ( l, mid, rt << 1 );

     creat ( mid + 1, r, ( rt << 1 ) + 1 );

}

void add ( int rt = 1, int wei = w ){

    if ( wei <= adv[rt].val ){

         if ( adv[rt].left == adv[rt].right ){

              adv[rt].val -= wei;

              //cout << adv[rt].left << endl;  //杯具的 地方

printf ( "%d\n", adv[rt].left ); 

              return ;     

         } else if ( adv[rt<<1].val >= wei ) {

                add ( rt << 1 );

                adv[rt].val = max ( adv[rt<<1].val, adv[(rt<<1)+1].val );     

         } else {

                add ( ( rt << 1 ) + 1 );

                adv[rt].val = max ( adv[rt<<1].val, adv[(rt<<1)+1].val );        

         }   

    } else {

           //cout << -1 << endl;      //杯具的地方

puts ( "-1" );   

    }   

}

inline bool scan_ud(int &num)

{

    char in;

    in=getchar();

    if(in==EOF) return false;

    while(in<'0'||in>'9') in=getchar();

    num=in-'0';

    while(in=getchar(),in>='0'&&in<='9'){

        num*=10,num+=in-'0';

    }

    return true;

}

int main ()

{

    while ( scan_ud (H)&&scan_ud (W)&&scan_ud (N) ) {

           if ( H > 200000 )

               H = 200010;

           creat ( 1, H );

           for ( int i = 1; i <= N; ++ i ) {

                scan_ud (w);

                add ( );     

           }      

    }

    return 0;

}

另 附上 傻崽  神牛 代码 :

#include <iostream>

#include <algorithm>

#include <string>

#include <set>

#include <map>

#include <utility>

#include <queue>

#include <stack>

#include <list>

#include <vector>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <cmath>

#define FF(i,a) for( int i = 0 ; i < a ; i ++ )

#define FOR(i,a,b) for( int i = a ; i < b ; i ++ )

#define LL(a) a<<1

#define RR(a) a<<1|1

template<class T> inline void checkmin(T &a,T b) {if(a < 0 || a > b)a = b;}

template<class T> inline void checkmax(T &a,T b) {if(a < b) a = b;}

using namespace std;

struct Node {

int val;

int idx;

friend bool operator < (Node a , Node b) {

if(a.val == b.val) {

return a.idx > b.idx;

}

return a.val < b.val;

}

}error;

struct Seg_Tree{

int left,right;

Node node;

int mid() {

return (left + right)>>1;

}

}tt[800000];

int n , h , m;

void build(int l,int r,int idx) {

tt[idx].left = l;

tt[idx].right = r;

tt[idx].node.idx = l;

tt[idx].node.val = h;

if(l == r) return ;

int mid = tt[idx].mid();

build(l,mid,LL(idx));

build(mid+1,r,RR(idx));

}

void update(int l,int r,int val,int idx) {

if(l <= tt[idx].left && r >= tt[idx].right) {

tt[idx].node.val += val;

return ;

}

int mid = tt[idx].mid();

if(l <= mid) update(l,r,val,LL(idx));

if(mid < r) update(l,r,val,RR(idx));

tt[idx].node = max(tt[LL(idx)].node,tt[RR(idx)].node);

}

Node query(int w,int idx) {

if(tt[idx].node.val < w) {

return error;

}

if(tt[idx].left == tt[idx].right) {

return tt[idx].node;

}

if(tt[LL(idx)].node.val >= w) {

return query(w,LL(idx));

} else {

return query(w,RR(idx));

}

}

int main() {

error.idx = -1;

while(scanf("%d%d%d",&n,&h,&m) == 3) {

checkmin(n,m);

build(1,n,1);

while(m --) {

int w;

scanf("%d",&w);

Node ret = query(w,1);

printf("%d\n",ret.idx);

if(ret.idx != -1) {

update(ret.idx,ret.idx,-w,1);

}

}

}

return 0;

} 

Stars

5
B 581 145
B 581 145
Q 0 600 0 200
D 581 145
Q 0 600 0 200

1
0

题目分析 :

 与 HDU 1892 基本相同的一道题,  只是矩阵数组的值被限定在 [0,1] ,   是一道 二维 树状数组的 裸题,  直接 模板, 加上对题目数据做一些

处理即可.

代码如下 :

Stars

Astronomers often examine star maps where stars are represented by points on a plane and each star has Cartesian coordinates. Let the level of a star be an amount of the stars that are not higher and not to the right of the given star. Astronomers want to know the distribution of the levels of the stars. 



For example, look at the map shown on the figure above. Level of the star number 5 is equal to 3 (it's formed by three stars with a numbers 1, 2 and 4). And the levels of the stars numbered by 2 and 4 are 1. At this map there are only one star of the level 0, two stars of the level 1, one star of the level 2, and one star of the level 3. 

You are to write a program that will count the amounts of the stars of each level on a given map.

5
1 1
5 1
7 1
3 3
5 5

1
2
1
1
0

In the year 8888, the Earth is ruled by the PPF Empire . As the population growing , PPF needs to find more land for the newborns . Finally , PPF decides to attack Kscinow who ruling the Mars . Here the problem comes! How can the soldiers reach the Mars ? PPF convokes his soldiers and asks for their suggestions . “Rush … ” one soldier answers. “Shut up ! Do I have to remind you that there isn’t any road to the Mars from here!” PPF replies. “Fly !” another answers. PPF smiles :“Clever guy ! Although we haven’t got wings , I can buy some magic broomsticks from HARRY POTTER to help you .” Now , it’s time to learn to fly on a broomstick ! we assume that one soldier has one level number indicating his degree. The soldier who has a higher level could teach the lower , that is to say the former’s level > the latter’s . But the lower can’t teach the higher. One soldier can have only one teacher at most , certainly , having no teacher is also legal. Similarly one soldier can have only one student at most while having no student is also possible. Teacher can teach his student on the same broomstick .Certainly , all the soldier must have practiced on the broomstick before they fly to the Mars! Magic broomstick is expensive !So , can you help PPF to calculate the minimum number of the broomstick needed .
For example : 
There are 5 soldiers (A B C D E)with level numbers : 2 4 5 6 4;
One method :
C could teach B; B could teach A; So , A B C are eligible to study on the same broomstick.
D could teach E;So D E are eligible to study on the same broomstick;
Using this method , we need 2 broomsticks.
Another method:
D could teach A; So A D are eligible to study on the same broomstick.
C could teach B; So B C are eligible to study on the same broomstick.
E with no teacher or student are eligible to study on one broomstick.
Using the method ,we need 3 broomsticks.
……

After checking up all possible method, we found that 2 is the minimum number of broomsticks needed. 

4
10
20
30
04
5
2
3
4
3
4

1
2

题目分析:

相对来说这题用字典树的效率比较高些.....遗憾的是我现在只会做一些字典树的 水题....对字典树的理解现在还不是很好......所以,呵呵

这题我就直接筛选过了........

代码如下:

 /*

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

          http://www.cnblog.com/MiYu

Author By : MiYu

Test      : 1

Program   : 1800

*/

#include <iostream>

#include <algorithm>

using namespace std;

int num[3002];

bool hash[3002];

bool cmp ( const int &a, const  int &b )

{

     return a > b; 

}

int main ()

{

    int N;

    while ( scanf ( "%d", &N ) != EOF )

    {

           memset ( num, 0, 12008 );

           memset ( hash, 0, 3002 );

           for ( int i = 0; i != N; ++ i )

                 scanf ( "%d",num + i );

           sort ( num, num + N, cmp );

           int nCount = 0;

           for ( int i = 0; i < N; ++ i )

           {

                 if ( !hash[i] )

                 {

                      nCount ++;

                      int j = i ,k = j+1;

                      hash[j] = true;

                      while ( k < N ) 

                      {

                            if ( !hash[k] && num[k] < num[j] )

                            {

                                 hash[k] = true;

                                 j = k;

                            }

                            k++;

                      } 

                 }

           } 

           printf ( "%d\n",nCount );

    }

    return 0;

}

Hat’s Words

a
ahat
hat
hatword
hziee
word

ahat
hatword

题目分析 :

        字典树的题目, 这个题的方法比较暴力,  在输入的时候将每个单词都加入字典树,  并用数组将所有的串都存起来来.

在输入完成后,  对每个单词进行拆分, 也就是暴力枚举单词不同位置的前后部分, 看在字典树中是否存在, 存在即输出.

不过貌似数据比较弱, 说是按字典顺序输出, 但其实他的输入本就是按字典顺序输入的, 所以将排序也面了 , 呵呵.

    另外,其实这题用STL 做更简单, 当然追求效率除外.

trie 代码:

 /*

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

          http://www.cnblog.com/MiYu

Author By : MiYu

Test      : 1

Program   : 1247

*/

#include <iostream>

#include <algorithm>

#include <string>

using namespace std;

typedef struct dictor DIC;

DIC *root = NULL;

struct dictor {

       dictor (){ exist = false; memset ( child , 0 , sizeof ( child ) ); }

       void insert ( char *ins );

       bool find ( const char *ins );

private:

       DIC *child[26];

       bool exist; 

};

void dictor::insert ( char *ins )

{

            DIC *cur = root,*now;

            int len = strlen ( ins );

            for ( int i = 0; i < len; ++ i )

            {

                  if ( cur->child[ ins[i] - 'a' ] != NULL ) 

                  {

                       cur = cur->child[ ins[i] - 'a' ];

                  }

                  else

                  {

                       now = new DIC;

                       cur->child[ ins[i] - 'a' ] = now;

                       cur = now;

                  }

            } 

            cur->exist = true;

}

bool dictor::find ( const char *ins )

{

            DIC *cur = root;

            int len = strlen ( ins );

            for ( int i = 0; i < len; ++ i )

            {

                 if ( cur->child[ ins[i] - 'a' ] != NULL )

                      cur = cur->child[ ins[i] - 'a' ];  

                 else

                      return false; 

            } 

            return cur->exist;

}

char words[50050][100];

char s1[100],s2[100];

DIC dict;

int main ()

{

    root = &dict;

    int n = 0;

    while ( scanf ( "%s",words[n] ) != EOF )

    {

            dict.insert ( words[n++] );

    }

    for ( int i = 0; i < n; ++ i )

    {

          int len = strlen ( words[i] );

          for ( int j = 1; j < len; ++ j )

          {

                memset ( s1, 0, sizeof ( s1 ) );

                memset ( s2, 0, sizeof ( s2 ) );

                strncpy ( s1, words[i], j );

                strcpy ( s2, words[i]+j );

                if ( dict.find ( s1 ) && dict.find ( s2 ) )

                {

                     printf ( "%s\n", words[i] );

                     break; 

                }

          }  

    }  

    //system ( "pause" );

    return 0;

}

STL  代码 :

 /*

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

          http://www.cnblog.com/MiYu

Author By : MiYu

Test      : 2

Program   : 1247

*/

#include <iostream>

#include <string>

#include <map>

using namespace std;

map < string , int > mp;

string str[50005];

int main ()

{

    int n = 0;

    while ( cin >> str[n] ) mp[ str[n++] ] = 1;

    for ( int i = 0; i < n; ++ i )

    {

          unsigned len = str[i].size ();

          for ( unsigned j = 1; j < len; ++ j )

          {

               string s1 ( str[i], 0, j );

               string s2 ( str[i], j );

               if ( mp[s1] == 1 && mp[s2] == 1 )

               {

                    cout << str[i] << endl; 

                    break;

               }

          } 

    }

    return 0;

}