hdu-----2491Priest John's Busiest Day（2008 北京现场赛G)

Priest John's Busiest Day

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1420    Accepted Submission(s): 415

Problem Description

John is the only priest in his town. October 26th is the John's busiest day in a year because there is an old legend in the town that the couple who get married on that day will be forever blessed by the God of Love. This year N couples plan to get married on the blessed day. The i-th couple plan to hold their wedding from time Si to time Ti. According to the traditions in the town, there must be a special ceremony on which the couple stand before the priest and accept blessings. Moreover, this ceremony must be longer than half of the wedding time and can’t be interrupted. Could you tell John how to arrange his schedule so that he can hold all special ceremonies of all weddings?
Please note that:
John can not hold two ceremonies at the same time. John can only join or leave the weddings at integral time. John can show up at another ceremony immediately after he finishes the previous one.

 

Input

The input consists of several test cases and ends with a line containing a zero.
In each test case, the first line contains a integer N ( 1 ≤ N ≤ 100,000) indicating the total number of the weddings.
In the next N lines, each line contains two integers Si and Ti. (0 <= Si < Ti <= 2147483647)

 

Output

For each test, if John can hold all special ceremonies, print "YES"; otherwise, print “NO”.

 

Sample Input

3

1 5

2 4

3 6

2

1 4

5 6

0

 

Sample Output

NO

YES

 

Source

2008 Asia Regional Beijing

 

 题意：

           小镇有n场婚礼在一天之内进行，第i场婚礼的开始时间为s,结束时间为t,在每一场婚礼中，有一个重要的仪式。即牧师给与两位新人传达主的祝福，对于第i场婚礼，祝福仪式可以在[s  , t]中任何时候举行，但是必须超过总时间的一半以上。

          小镇只有一位牧师，所有的祝福仪式都必须要他在场吗。同时，牧师必须在整数时刻开始或者结束祝福仪式，不过他可以在结束之后立刻开始另一场。

现在给你所有的婚礼的信息请问是否能够安排好一个祝福仪式的顺序，使得牧师能够给所有的新人带去幸福......

          现在给你所有婚礼的信息，请问是否能够安排好一个祝福仪式的顺序，使得牧师能够给所有新人带去幸福...

 

 

自己写了个搓代码：

先展示一下大神的代码把！...

然后再看弱屌的代码....

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 100100;
struct tnode
{
    int s,e;
    int ms,me;
    int keyinterval;
    int id;
}c[maxn];

bool operator < (const tnode &a , const tnode &b)
{
    return (a.ms <b.ms ||(a.ms==b.ms&&a.me<b.me));
}
int n , i;
void init()
{
    for(i=0 ; i<n ;i++ ){
      scanf("%d%d",&c[i].s,&c[i].e);
      c[i].id=i;
      c[i].keyinterval = (c[i].e - c[i].s +2)/2 ;
      c[i].ms=c[i].s+(c[i].e - c[i].s -1)/2;
      c[i].me=c[i].s+1;
      if((c[i].e-c[i].s)%2==0)
           ++c[i].me;
    }
   sort(c,c+n);
}
bool work()
{
    int now_s , now_e ,last_e;
    last_e=0;
    for(int i=0 ; i<n ;i++)
    {
        now_s =c[i].s;
        if(now_s<last_e) now_s=last_e;
        now_e=now_s+c[i].keyinterval;
        if(now_e>c[i].e) return false;
        last_e = now_e;
    }
    return true ;
}

  int main()
  {
      while(scanf("%d",&n),n!=0)
      {
          init();
          if(work())
             printf("YES
");
          else
             printf("NO
");
      }
      return 0;
  }

 运用STL之后，速度更搓，空间开销也增大了不少....

 代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn = 100100;
struct tnode
{
    int s,e;
    int ms,me;
    int keyinterval;
    int id;
    bool operator < (const tnode &b) const
    {
      return (ms <b.ms ||(ms==b.ms&&me<b.me));
    }
};

int n , i;
tnode cc;
vector<tnode>c;
void init()
{
       c.clear();
    for(i=0 ; i<n ;i++ ){
      scanf("%d%d",&cc.s,&cc.e);
      cc.id=i;
      cc.keyinterval = (cc.e - cc.s +2)/2 ;
      cc.ms=cc.s+(cc.e - cc.s -1)/2;
      cc.me=cc.s+1;
      if((cc.e-cc.s)%2==0)
           ++cc.me;
      c.push_back(cc);
    }
   sort(c.begin(),c.end());
}
bool work()
{
    int now_s , now_e ,last_e;
    last_e=0;
    for(int i=0 ; i<n ;i++)
    {
        now_s =c[i].s;
        if(now_s<last_e) now_s=last_e;
        now_e=now_s+c[i].keyinterval;
        if(now_e>c[i].e) return false;
        last_e = now_e;
    }
    return true ;
}

  int main()
  {
      while(scanf("%d",&n),n!=0)
      {
          init();
          if(work())
             printf("YES
");
          else
             printf("NO
");
      }
      return 0;
  }

然后自己有写了一次..........!

 代码：

手动的扩栈....

#program comment （linker ,"/STACK :102400000  102400000"）

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#pragma comment(linker, "/STACK:102400000,102400000")  //由于用内分装之后会出现溢栈的情况，所以手动扩栈
using namespace std;

 const int maxn =100100 ;

 struct tnode
 {
     int s,e;
     int ms,me;
     int mid;
     bool operator < (const tnode b) const
     {
       return (ms<b.ms||(ms==b.ms)&&me<b.me);
     }
 };
 class  node
 {
  private:
   tnode str[maxn];
   int i;
  public :
     int n;
     void init();
     bool work();
 };

void  node::init()
 {
     for(i=0;i<n;i++)
     {
       scanf("%d%d",&str[i].s,&str[i].e) ;
       str[i].mid=(str[i].e-str[i].s)/2 +1 ;
       str[i].ms= str[i].s+(str[i].e-str[i].s-1)/2 ;
       str[i].me=str[i].s+1 ;
       if((str[i].e-str[i].s)%2==0) str[i].me++;
     }
     sort(str,str+n);
 }
  bool node::work()
  {
      int temp_s,temp_e,last_e=0;
      for( i=0 ; i<n ; i++ )
      {
          temp_s=str[i].s;
       if(temp_s<last_e) temp_s=last_e;
         temp_e = temp_s+str[i].mid;
        if(temp_e>str[i].e) return false;
          last_e=temp_e;
      }
      return true ;
  }
 int main()
 {
    node  a;
    while(scanf("%d",&a.n)!=EOF&&a.n)
    {
        a.init();
       if(a.work())printf("YES
");
       else printf("NO
");
    }
     return 0;
 }