Minimizing maximizer(POJ 1769)

• 原题如下：
  Minimizing maximizer

  Time Limit: 5000MS		Memory Limit: 30000K
  Total Submissions: 5104		Accepted: 2066

  Description

  The company Chris Ltd. is preparing a new sorting hardware called Maximizer. Maximizer has n inputs numbered from 1 to n. Each input represents one integer. Maximizer has one output which represents the maximum value present on Maximizer's inputs. 
  
  Maximizer is implemented as a pipeline of sorters Sorter(i1, j1), ... , Sorter(ik, jk). Each sorter has n inputs and n outputs. Sorter(i, j) sorts values on inputs i, i+1,... , j in non-decreasing order and lets the other inputs pass through unchanged. The n-th output of the last sorter is the output of the Maximizer. 
  
  An intern (a former ACM contestant) observed that some sorters could be excluded from the pipeline and Maximizer would still produce the correct result. What is the length of the shortest subsequence of the given sequence of sorters in the pipeline still producing correct results for all possible combinations of input values? 
  
  Task 
  Write a program that: 
  
  reads a description of a Maximizer, i.e. the initial sequence of sorters in the pipeline, 
  computes the length of the shortest subsequence of the initial sequence of sorters still producing correct results for all possible input data, 
  writes the result. 

  Input

  The first line of the input contains two integers n and m (2 <= n <= 50000, 1 <= m <= 500000) separated by a single space. Integer n is the number of inputs and integer m is the number of sorters in the pipeline. The initial sequence of sorters is described in the next m lines. The k-th of these lines contains the parameters of the k-th sorter: two integers ik and jk (1 <= ik < jk <= n) separated by a single space.

  Output

  The output consists of only one line containing an integer equal to the length of the shortest subsequence of the initial sequence of sorters still producing correct results for all possible data.

  Sample Input

  40 6
  20 30
  1 10
  10 20
  20 30
  15 25
  30 40
  

  Sample Output

  4
  

  Hint

  Huge input data, scanf is recommended.
• 题解：首先，考虑在什么情况下可以正常工作，假设输入的第i个数是应该输出的最大值，此时在第一个满足s_k≤i≤t_k的Sorter的输出中，这个值被移动到了第t_k个位置，接下去，在一个满足s_k'≤t_k≤t_k'且k'>k的Sorter的输出中，这个值又被移动到了第t_k'个。不断重复这样的操作，如果最后可以被移动到第n个，那么就表示Maximizer可以正常工作（实际上，就是要按照线段的输入顺序，将[1, n]从左到右依次覆盖，求所需线段个数的最小值）。因此只要i=1的情况可以正常工作，那么对于任意的i都可以正常工作。不妨假设第一个数是应该输出的最大值，考虑DP：
    dp[i][j]:=到第i个Sorter为止，最大值被移动到第j个位置所需要的最短的子序列的长度（INF表示不存在这样的序列）
    dp[0][1]=0
    dp[0][j]=INF(j>1)
    dp[i+1][j]=①dp[i][j] (t_i ≠ j)
                    ②min( dp[i][j] , min{dp[i][j']|s_i≤j'≤t_i}+1 ) (t_i = j)
  由于这个DP的复杂度是O(nm)的，仍然无法在规定的时间内求出答案。但是对于(t_i ≠ j)时有dp[i+1][j]=dp[i][j]，我们可以使用同一个数组不断对自己更新：
    dp[j]:=最大值被移动到第j个位置所需要的最短的子序列的长度。(INF表示不存在这样的序列)
  初始化：
    dp[1]=0
    dp[j]=INF(j>1)
  对于每个i，这样更新：
    dp[t_i]=min(  dp[t_i], min{dp[j']|s_i≤j'≤t_i}+1 )
  这样，对于每个i都只需更新一个值就可以了，但求最小值时，最坏情况下要O(n)的时间，最后复杂度还是O(nm)。如果使用线段树来维护，就可以在O(mlogn)时间内求解了。
• 代码：

  #include <cstdio>
  #include <cctype>
  #include <algorithm>
  #define number s-'0'
  
  using namespace std;
  
  const int INF=0x3f3f3f3f;
  const int MAX_N=500005;
  const int MAX_M=500005;
  int n,m;
  int s[MAX_M], t[MAX_M];
  int dp[MAX_N+1];
  int dat[4*MAX_N];
  
  void read(int &x)
  {
      char s;
      bool flag=0;
      x=0;
      while (!isdigit(s=getchar()))
          (s=='-')&&(flag=true);
      for (x=number; isdigit(s=getchar());x=x*10+number);
      (flag)&&(x=-x);
  }
  
  void write(int x)
  {
      if (x<0)
      {
          putchar('-');
          x=-x;
      }
      if (x>9) write(x/10);
      putchar(x%10+'0');
  }
  
  void rmq_init(int k, int l, int r);
  void update(int u, int v, int k, int l, int r);
  int query(int a, int b, int k, int l, int r);
  
  int min(int x, int y)
  {
      if (x<y) return x;
      return y;
  }
  
  int main(int argc, char * argv[])
  {
      read(n);read(m);
      for (int i=0; i<m; i++)
      {
          read(s[i]);read(t[i]);
          s[i]--;t[i]--;
      }
      rmq_init(0, 0, n);
      fill(dp, dp+MAX_N, INF);
      dp[0]=0;
      update(0, 0, 0, 0, n);
      for (int i=0; i<m; i++)
      {
          int v=min(dp[t[i]], query(s[i], t[i]+1, 0, 0, n)+1);
          dp[t[i]]=v;
          update(t[i], v, 0, 0, n);
      }
      write(dp[n-1]);putchar('
  ');
  }
  
  void rmq_init(int k, int l, int r)
  {
      dat[k]=INF;
      if (r-l==1) return;
      rmq_init(k*2+1, l, (l+r)/2);
      rmq_init(k*2+2, (l+r)/2, r);
  }
  
  void update(int u, int v, int k, int l, int r)
  {
      if (r-l==1)
      {
          dat[k]=v;
          return;
      }
      else
      {
          int m=(l+r)/2;
          if (u<m) update(u, v, k*2+1, l, m);
          else update(u, v, k*2+2, m, r);
          dat[k]=min(dat[k*2+1], dat[k*2+2]);
      }
  }
  
  int query(int a, int b, int k, int l, int r)
  {
      if (r<=a || b<=l) return INF;
      if (a<=l && r<=b) return dat[k];
      else 
      {
          int m=(l+r)/2;
          int vl=query(a, b, k*2+1, l, m);
          int vr=query(a, b, k*2+2, m, r);
          return min(vl, vr);
      }
  }