笔试刷题-头条2018-06-01

题目描述：

/**
为了不断优化推荐效果，今日头条每天要存储和处理海量数据。
假设有这样一种场景：我们对用户按照它们的注册时间先后来标号，
对于一类文章，每个用户都有不同的喜好值，
我们会想知道某一段时间内注册的用户（标号相连的一批用户）中，
有多少用户对这类文章喜好值为k。
因为一些特殊的原因，
不会出现一个查询的用户区间完全覆盖另一个查询的用户区间(不存在L1<=L2<=R2<=R1)。

输入描述:
输入： 第1行为n代表用户的个数 第2行为n个整数，
第i个代表用户标号为i的用户对某类文章的喜好度
第3行为一个正整数q代表查询的组数  第4行到第（3+q）行，
每行包含3个整数l,r,k代表一组查询，
即标号为l<=i<=r的用户中对这类文章喜好值为k的用户的个数。
数据范围n <= 300000,q<=300000 k是整型


输出描述:
输出：一共q行，每行一个整数代表喜好值为k的用户的个数

输入例子1:
5
1 2 3 3 5
3
1 2 1
2 4 5
3 5 3

输出例子1:
1
0
2

例子说明1:
样例解释:
有5个用户，喜好值为分别为1、2、3、3、5，
第一组询问对于标号[1,2]的用户喜好值为1的用户的个数是1
第二组询问对于标号[2,4]的用户喜好值为5的用户的个数是0
第三组询问对于标号[3,5]的用户喜好值为3的用户的个数是2
*/ 

思路如下：
把用户按照k值排序，然后用两次二分查找找出了每次查询所有符合条件的其k值与查询相同的用户，然后再根据查询的l，r筛选出合法的用户并计数即可。

代码如下：

#include<stdio.h>
#include<iostream>
#include<map>
#include<algorithm>

#define MAX_N 300005
#define MAX_Q 300005

using namespace std;

//方法：根据k值排序，然后通过二分查找确定候选的用户，然后再在候选用户中判断合法时间段

struct Node{
    int val=-1, idx=-1;
    Node(){}
    Node(int val, int idx){
        this->val = val;
        this->idx = idx;
    }
    Node(const Node &node){
        this->val = node.val;
        this->idx = node.idx;
    }
};

bool NodeCmpByVal(const Node &n1, const Node &n2){
    return n1.val<n2.val;
}

Node nodes[MAX_N];

//找第一个大于等于target的下标
int bin_search1(int target, int N);
//找最后一个小于等于target的下标
int bin_search2(int target, int N);

int main(){
    int N, Q;
    scanf("%d", &N);
    for(int i=0; i<N; i++){
        int val;
        scanf("%d", &val);
        nodes[i]=Node(val, i);
    }
    //按val排序
    sort(nodes, nodes+N, NodeCmpByVal);
    scanf("%d", &Q);
    for(int q=0; q<Q; q++){
        int l, r, k, startIdx, endIdx;
        scanf("%d%d%d", &l, &r, &k);
        l--;
        r--;
        startIdx = bin_search1(k, N);
        endIdx = bin_search2(k, N);
        int cnt=0;
        for(int cur=startIdx; cur<=endIdx; cur++){
            if(nodes[cur].idx>=l && nodes[cur].idx<=r){
                cnt++;
            }
        }
        printf("%d\n", cnt);
    }
    return 0;
}

//找第一个大于等于target的下标
int bin_search1(int target, int N){
    int l=0, r=N-1;
    while(l<=r){
        int mid = (l+r)/2;
        if(nodes[mid].val<target){
            l = mid+1;
        }
        else{
            r = mid-1;
        }
    }
    return l;
}
//找最后一个小于等于target的下标
int bin_search2(int target, int N){
    int l=0, r=N-1;
    while(l<=r){
        int mid = (l+r)/2;
        if(nodes[mid].val<=target){
            l = mid+1;
        }
        else{
            r = mid-1;
        }
    }
    return l-1;
}