优化：Hackerearth Postman 软件工程师实习生问题

Posted 2023-02-19

【中文标题】优化：Hackerearth Postman 软件工程师实习生问题

【英文标题】：Optimize: Hackerearth Postman Software engineer intern question

【发布时间】：2020-01-29 03:11:50

【问题描述】：

您想购买一台笔记本电脑。每台笔记本电脑都有两个参数：评级和价格。您的任务是购买给定价格范围内评级最高的笔记本电脑。给定 Q 个任务，每个查询都包含所需的价格范围，您必须打印在该价格范围内可以购买的评分最高的笔记本电脑。

输入格式：

第一行包含 N 表示输入的数量。

以下 N 行包含 P&R，表示笔记本电脑的价格和范围。

下一行包含 Q 表示查询的数量。

以下 Q 行包含两个整数 X 和 Y，表示价格范围（含）。

输出格式：

对于每个任务 Q，打印该范围内可以购买的最高评分。

如果您无法在该范围内获得任何笔记本电脑，请打印 -1。

约束：

1

0

1

时间限制：每个输入 6 秒

示例输入：

5
1000 300
1100 400
1300 200
1700 500
2000 600
3
1000 1400
1700 1900
0 2000

样本输出：

400
500
600

我的方法

构建（键、值）映射

而 Y--> X 做，

迭代器 = map.find(Y)

如果是迭代器，那么，max_rating = max(max_rating, iterator.value)

返回 max_rating

这是我的解决方案

int solve(vector<int> P, vector<int> R, int X, int Y)

      int max_value=-1;
      map<int,int> price_rating;
      for(int i=0;i<N;i++)
      
            price_rating.insert(pair<int, int>(P[i],R[i]));
      

      while(y>x)
      
            auto iterator = price_rating.find(y);
            if(iterator!=price_rating.end())
            
                   max_rating = max(max_rating,iterator->second);
            
            y-=1;
      
      return max_rating;

使用上述解决方案只有少数测试用例通过，而其他测试用例由于 TLE（超出时间限制）而失败。很高兴知道更好的解决方案。

【问题讨论】：

我想不出任何其他的解决方案 -- 如果你真的相信你所需要的只是一点优化，这个：map<int,int> price_rating; 可能是std::unordered_map<int,int>。另外，通过const reference 传递你的向量，而不是通过值。

您可以有一个排序的价格列表（连同评级）。当您获得一个范围时，您可以从最低价格到最高价格在列表中进行交互并找到最高评级。如果 min 到 max 之间的列表长度为 0，则可以返回 -1。

@YuvrajJaiswal 只要你有一个排序数组，你就可以使用二分搜索。

@Jason 想到了这一点，但我们有一个按价格排序的数组，我们需要找到最高评分。我们将无法决定在二分搜索中向哪个方向移动。

【参考方案1】：

见下面的代码，上面的问题。我在考试中努力解决它。

程序的任务：

根据价格对价格和评级向量进行排序。 根据“sl, sr index 之间的最大评分”制作分段树 在 queryLowPrice 和 queryHighPrice 之间获取 MaxRating 时，只需检查当前节点是否包含该价格，并根据该价格返回答案。

#include <iostream>

#include<bits/stdc++.h>

using namespace std;

struct mydtype

    int price;
    int rating;
;

bool comp( mydtype a, mydtype b )
    if( a.price != b.price ) return a.price<b.price;
    else return a.rating<b.rating;


int getMid( int a , int b )
    return a+(b-a)/2;


void build( int st[], vector<mydtype> v, int si, int sl, int sr )
    if(sl==sr) st[si]=v[sl].rating;
    else
        int mid=getMid(sl,sr);
        build(st,v,2*si+1,sl,mid);
        build(st,v,2*si+2,mid+1,sr);
        st[si]=max( st[2*si+1], st[2*si+2] );
    

int getMaxRating(int st[], vector<mydtype> v , int si, int sl, int sr, int queryLowPrice, int queryHighPrice )
     if( queryLowPrice > queryHighPrice ) return -1;
     int stLowPrice = v[sl].price;
     int stHighPrice = v[sr].price;
     if( queryLowPrice > stHighPrice || queryHighPrice < stLowPrice ) return INT_MIN;
     if( stLowPrice>= queryLowPrice && stHighPrice <= queryHighPrice ) return st[si];
     else
         int mid = getMid(sl,sr);
         return max( getMaxRating( st, v, 2*si+1, sl, mid, queryLowPrice, queryHighPrice ),
                    getMaxRating( st, v, 2*si+2, mid+1, sr, queryLowPrice, queryHighPrice ) );
    


int main ()

    int n = 5;
    vector < mydtype > v(n);
    v=10,2, 20,3, 20,4, 30,4, 40,2;
    sort(v.begin(),v.end(), comp);
    int max_size = 15;
    int st[max_size];
    build (st, v, 0, 0, n-1 ); 
    cout<< getMaxRating(st, v, 0, 0, n-1, 19, 21);
    return 0;

【讨论】：

在此处发布您的代码，作为正确格式化的代码块。

【参考方案2】：

查看Segment tree。

这个想法是首先构建一个分段树，其中每个节点代表一个价格范围并存储该范围的最高评级。

例如，如果您的数据有 7 个价格，10, 20, 30, 40, 50, 60, 70，您将创建一个包含这些节点的树：

                 [10-70]
                /        \
           [10-30]        [40-70]
          /      \         /      \
       [10-20]   [30]  [40-50]    [60-70]
       /   \            /   \      /   \
     [10]  [20]      [40]  [50]  [60]  [70]

叶子是只有一个价格的“范围”。您可以在这棵树上提高最高评分，这样每个节点都会在该特定范围内获得最高评分。

然后，对于实际查询，您可以沿着树向下走（深度优先搜索），并且：

排除经过其范围与查询范围不重叠的节点的路径 当存在部分重叠时，继续向下钻取（扩展路径） 在范围完全在查询范围内的节点处停止和回溯

最终，您将最终到达查询范围内的节点。在递归回溯时从这些节点获得最高评分。

这将使查询在 O(logn) 中运行。