【CUGBACM15级BC第20场 B】hdu 5124 lines

lines

Time Limit: 5000/2500 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1837    Accepted Submission(s): 782

Problem Description

John has several lines. The lines are covered on the X axis. Let A is a point which is covered by the most lines. John wants to know how many lines cover A.

 

Input

The first line contains a single integer T(1≤T≤100) (the data for N>100 less than 11 cases),indicating the number of test cases.
Each test case begins with an integer N(1≤N≤105) ,indicating the number of lines.
Next N lines contains two integers Xi and Yi(1≤Xi≤Yi≤109) ,describing a line.

 

Output

For each case, output an integer means how many lines cover A.

 

Sample Input

  
  

   
   2
5
1 2 
2 2
2 4
3 4
5 1000
5
1 1
2 2
3 3
4 4
5 5
  
  

 

Sample Output

  
  

   
   3
1
  
  

 

题意：x轴上很多段区间，求覆盖最多的一个点的覆盖次数

思路：首先很容易想到这个点一定可以是某一段区间的端点，然后这里给了区间，要求一个点的出现次数，想到什么？

没错，区间更新，单点求和。 当然用线段树更加直观，只是本人确实不是很喜欢线段树...于是就用树状数组实现了

与单点求和，区间求和的区别在于更新区间的时候add(l,1)和add(r+1,-1)  单点求和就是直接sum(i)就可以了

记得要离散化处理

#include <iostream>
#include <set>
#include <map>
#include <stack>
#include <cmath>
#include <queue>
#include <cstdio>
#include <bitset>
#include <string>
#include <vector>
#include <iomanip>
#include <cstring>
#include <algorithm>
#include <functional>
#define PI acos(-1)
#define eps 1e-8
#define inf 0x3f3f3f3f
#define debug(x) cout<<"---"<<x<<"---"<<endl
typedef long long ll;
using namespace std;
const int N = 1e5 + 10;

int a[N], b[N], p[2 * N], maxn;
int lowbit(int x)
{
    return x & (-x);
}
///区间修改+单点查询
int arr[N * 2];
inline int sum(int x)
{
    int res = 0;
    while (x)
    {
        res += arr[x], x -= lowbit(x);
    }
    return res;
}
inline void add(int x, int n)
{
    while (x < maxn)
    {
        arr[x] += n, x += lowbit(x);
    }
}
inline void update(int x, int y, int n)///区间修改
{
    add(x, n);
    add(y + 1, -n);
}
int main()
{
    std::ios::sync_with_stdio(false);
    int t;
    cin >> t;
    while (t--)
    {
        int n;
        cin >> n;
        memset(arr, 0, sizeof(arr));
        maxn = 2 * n;
        for (int i = 1; i <= n; i++)
        {
            cin >> a[i] >> b[i];
            p[i] = a[i];
            p[i + n] = b[i];
        }
        sort(p + 1, p + 1 + 2 * n);
        for (int i = 1; i <= n; i++)
        {
            int l = lower_bound(p + 1, p + 1 + 2 * n, a[i]) - p;
            int r = lower_bound(p + 1, p + 1 + 2 * n, b[i]) - p;
            update(l, r, 1);
        }
        int ans = 1;
        for (int i = 1; i <= 2 * n; i++)
        {
            int s = sum(i);
            ans = max(ans, s);
        }
        cout << ans << endl;
    }
    return 0;
}