LightOj1089(求点包含几个线段 + 线段树）

题目链接

题意：n（ n <= 50000 ) 个线段，q ( q <= 50000) 个点，问每个点在几个线段上

线段端点的和询问的点的值都很大，所以必须离散化

第一种解法：先把所有的线段端点和询问点，离散处理，然后对于每条选段处理，c[x]++, c[y + 1]--，然后令c[x] = c[x] + c[x - 1]，所以c[x]就保存了被几个线段覆盖，然后对对于每个询问点，查找他在离散后的位置，然后直接读取c[]，这种方法很巧妙，佩服佩服

 #include <iostream>
 #include <algorithm>
 #include <cstdio>
 #include <cstring>
 using namespace std;
 const int Max =  + ;
 int c[ * Max],a[Max],b[Max],querry[Max];
 int id[ * Max],cnt;
 int main()
 {
     int n, p, test;
     scanf("%d", &test);
     for(int t = ; t <= test; t++)
     {
         printf("Case %d:\n", t);
         scanf("%d%d", &n, &p);
         memset(c, , sizeof(c));
         cnt = ;
         for(int i = ; i <= n; i++)
         {
             scanf("%d%d", &a[i], &b[i]);
             id[cnt++] = a[i];
             id[cnt++] = b[i];
         }
         for(int i = ; i <= p; i++)
         {
             scanf("%d", &querry[i]);
             id[cnt++] = querry[i];
         }
         sort(id, id + cnt);
         cnt = unique(id, id + cnt) - id;
         for(int i = ; i <= n; i++)
         {
             int x = lower_bound(id, id + cnt, a[i]) - id;
             int y = lower_bound(id, id + cnt, b[i]) - id;
             c[x]++;
             c[y + ]--;
         }
         for(int i = ; i <  * Max; i++)
             c[i] += c[i - ];

         for(int i = ; i <= p; i++)
         {
             int x = lower_bound(id, id + cnt, querry[i]) - id;
             printf("%d\n", c[x]);
         }
     }
     return ;
 }

线段树也可解，只是RE

 #include <iostream>
 #include <algorithm>
 #include <cstdio>
 #include <cstring>
 using namespace std;
 const int Max =  + ;
 struct node
 {
     int l,r;
     int tag,cnt;
 };
 node tree[ * Max];
 int a[ * Max], b[ * Max], c[ * Max], querry[Max];
 int tot;
 void buildTree(int left, int right, int k)
 {
     tree[k].l = left;
     tree[k].r = right;
     tree[k].tag = -;
     tree[k].cnt = ;
     if(left == right)
         return;
     int mid = (left + right) / ;
     buildTree(left, mid, k * );
     buildTree(mid + , right, k *  + );
 }
 void upDate(int left, int right, int k, int newp)
 {
     if(tree[k].tag != -)
     {
         tree[k * ].tag = tree[k *  + ].tag = tree[k].tag;
         tree[k * ].cnt++;
         tree[k *  + ].cnt++;
         tree[k].tag = -;
     }
     if(tree[k].l == left && tree[k].r == right)
     {
         tree[k].cnt++;
         tree[k].tag = newp;
         return;
     }
     int mid = (tree[k].l + tree[k].r) / ;
     if(right <= mid)
         upDate(left, right, k * , newp);
     else if(mid < left)
         upDate(left, right, k *  + , newp);
     else
     {
         upDate(left, mid, k * , newp);
         upDate(mid + , right, k *  + , newp);
     }
 }
 int Search(int k, int value)
 {
     if(tree[k].l == tree[k].r)
         return tree[k].cnt;
     if(tree[k].tag != -)
     {
         tree[k * ].tag = tree[k *  + ].tag = tree[k].tag;
         tree[k * ].cnt++;
         tree[k *  + ].cnt++;
         tree[k].tag = -;
     }

     int mid = (tree[k].l + tree[k].r) / ;
     if(value <= mid)
         return Search(k * , value);
     else
         return Search(k *  + , value);
 }
 int main()
 {
     int test, n, q;
     scanf("%d", &test);
     for(int t = ; t <= test; t++)
     {
         scanf("%d%d", &n, &q);
         tot = ;
         for(int i = ; i <= n; i++)
         {
             scanf("%d%d", &a[i], &b[i]);
             c[tot++] = a[i];
             c[tot++] = b[i];
         }
         for(int i = ; i <= q; i++)
         {
             scanf("%d", &querry[i]);
             c[tot++] = querry[i];
         }
         sort(c, c + tot);
         tot = unique(c, c + tot) - c;
         buildTree(, tot, );
         for(int i = ; i <= n; i++)
         {
             int x = lower_bound(c, c + tot, a[i]) - c + ;
             int y = lower_bound(c, c + tot, b[i]) - c + ;
             upDate(x, y, , );
         }
         printf("Case %d:\n", t);
         for(int i = ; i <= q; i++)
         {
             int x = lower_bound(c, c + tot, querry[i]) - c + ;
             printf("%d\n", Search(, x));
         }
     }
     return ;
 }

未AC