字节跳动2018校招算法方向（第一批）（编程题详解）

编程题1：

P为给定的二维平面整数点集。定义 P 中某点x，如果x满足 P 中任意点都不在 x 的右上方区域内（横纵坐标都大于x），则称其为“最大的”。求出所有“最大的”点的集合。（所有点的横坐标和纵坐标都不重复, 坐标轴范围在[0, 1e9) 内）

如下图：实心点为满足条件的点的集合。请实现代码找到集合 P 中的所有 ”最大“ 点的集合并输出。

思路分析：按照x坐标排序，排序完用y坐标构造一棵线段树，先找出【1，n】中所有y坐标的最大值（线段树query操作），假设最大值对应的y坐标为下标为a，则接下来在区间【a+1，n】中找下一个最大值，依此类推，打印出所有最大值对应的横纵坐标即可。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstdlib>
#define N 500005
using namespace std;
struct input{
    int x;
    int y;
}a[N];
int tree[4*N];
int ans;
bool cmp(const input& a, const input&b)
{
    return a.x<b.x;
}
void build(int l, int r, int k)
{
    if(l==r){
        tree[k]=a[l-1].y;
        return;
    }
    int m=l+((r-l)>>1);
    build(l,m,k<<1);
    build(m+1,r,k<<1|1);
    tree[k]=max(tree[k<<1], tree[k<<1|1]);
}
void query(int L, int R, int l,int r, int k)
{
    if(L<=l&&r<=R)
    {
        ans = max(ans, tree[k]);
        return;
    }
    int m=l+((r-l)>>1);
    if(m>=L)query(L,R,l,m,k<<1);
    if(m<R)query(L,R,m+1,r,k<<1|1);
}
int main()
{
    int n,x,y;
    scanf("%d",&n);
    for(int i=0;i<n;++i)
    {
        scanf("%d%d",&x,&y);
        a[i].x=x;
        a[i].y=y;
    }
    sort(a,a+n,cmp);
    build(1, n, 1);
    int start = 0;
    while(start<n)
    {
        ans = a[start].y;
        query(start+1,n,1,n,1);
        for(int i=start;i<n;++i)
        {
            if(a[i].y==ans)
            {
                printf("%d %d\n",a[i].x, a[i].y);
                start=i+1;
                break;
            }
        }
    }
    return 0;
}

编程题2：

给定一个数组序列, 需要求选出一个区间, 使得该区间是所有区间中经过如下计算的值最大的一个：

区间中的最小数 * 区间所有数的和最后程序输出经过计算后的最大值即可，不需要输出具体的区间。如给定序列 [6 2 1]则根据上述公式, 可得到所有可以选定各个区间的计算值:

[6] = 6 * 6 = 36;

[2] = 2 * 2 = 4;

[1] = 1 * 1 = 1;

[6,2] = 2 * 8 = 16;

[2,1] = 1 * 3 = 3;

[6, 2, 1] = 1 * 9 = 9;

从上述计算可见选定区间 [6] ，计算值为 36，则程序输出为 36。

区间内的所有数字都在[0, 100]的范围内;

思路分析：简单题，因为数字范围在【0，100】之间，而0对应的乘积一定是0，所以只需遍历1到100。假设遍历到x，就把所有数按照x拆成多份，其中每份的值都必须大于等于x，其中和最大的那一份就是x对应的乘积最大值，答案就是所有乘积最大值中最大的那个。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstdlib>
#define N 500005
using namespace std;
int a[N];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;++i)
    {
        scanf("%d",&a[i]);
    }
    long long ans = 0;
    for(int i=1;i<=100;++i)
    {
        long long sum = 0;
        for(int j=0;j<n;++j)
        {
            if(a[j]>=i)sum+=a[j];
            else
            {
                ans = max(ans, sum*i);
                sum = 0;
            }
        }
        ans = max(ans, sum*i);
    }
    printf("%lld\n",ans);
    return 0;
}

编程题3：

产品经理(PM)有很多好的idea，而这些idea需要程序员实现。现在有N个PM，在某个时间会想出一个 idea，每个 idea 有提出时间、所需时间和优先等级。对于一个PM来说，最想实现的idea首先考虑优先等级高的，相同的情况下优先所需时间最小的，还相同的情况下选择最早想出的，没有 PM 会在同一时刻提出两个 idea。

同时有M个程序员，每个程序员空闲的时候就会查看每个PM尚未执行并且最想完成的一个idea,然后从中挑选出所需时间最小的一个idea独立实现，如果所需时间相同则选择PM序号最小的。直到完成了idea才会重复上述操作。如果有多个同时处于空闲状态的程序员，那么他们会依次进行查看idea的操作。

求每个idea实现的时间。

输入第一行三个数N、M、P，分别表示有N个PM，M个程序员，P个idea。随后有P行，每行有4个数字，分别是PM序号、提出时间、优先等级和所需时间。输出P行，分别表示每个idea实现的时间点。

思路分析：不需要用到什么高级数据结构，就用1个优先队列数组存每个PM在当前时间点已经提出的需求，1个优先队列存所有程序员空闲的时间（这个队列的大小一直是M），其他细节看代码就行，不难理解。

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<algorithm>
#define N 3005
using namespace std;
struct node{
    int pm;
    int start;
    int pri;
    int need;
    int task_id;
}no[N];
bool cmp(const node& a, const node& b)
{
    return a.start<b.start;
}
struct CmpStruct{
    bool operator()(node a, node b)
    {
        return a.pri<b.pri||(a.pri==b.pri&&a.need>b.need)||
            (a.pri==b.pri&&a.need==b.need&&a.start>b.start);
    }
};
vector<node> vec[N];
priority_queue<node, vector<node>, CmpStruct> q[N];
priority_queue<int, vector<int>, greater<int> > q_time;
int ans[N];
int main()
{
    int n,m,p;
    scanf("%d%d%d",&n,&m,&p);
    for(int i=0;i<p;++i)
    {
        scanf("%d%d%d%d",&no[i].pm, &no[i].start, &no[i].pri, &no[i].need);
        no[i].task_id=i+1;
    }
    sort(no, no+p, cmp);
 
    int start_task_id = 0;
    for(int i=0;i<m;++i)q_time.push(1);
    int start_time = q_time.top();
    int task_finish_cnt = 0;
    while(1)
    {
        int i=start_task_id;
        for(;i<p;++i)
        {
            if(no[i].start<=start_time)q[no[i].pm].push(no[i]);
            else break;
        }
        start_task_id=i;
 
        q_time.pop();
        int minn = 3001;
        int pm_id = 0;
        for(int i=1;i<=n;++i)
        {
            if(!q[i].empty() && q[i].top().need<minn)
            {
                minn=q[i].top().need;
                pm_id = i;
            }
        }
        if(pm_id>0)
        {
            int finish_time = start_time+q[pm_id].top().need;
            ans[q[pm_id].top().task_id]=finish_time;
            task_finish_cnt++;
            if(task_finish_cnt==p)break;
            q_time.push(finish_time);
            start_time = q_time.top();
            q[pm_id].pop();
        }
        else
        {
            q_time.push(start_time+1);
            start_time = q_time.top();
        }
    }
    for(int i=1;i<=p;++i)
    {
        printf("%d\n",ans[i]);
    }
    return 0;
}

字节跳动2018校招算法方向（第一批）（编程题详解）

相关推荐