leetcode 1235

leetcode 1235

代码

class Solution {
public:
    int jobScheduling(vector<int>& startTime, vector<int>& endTime, vector<int>& profit) {
        int n = startTime.size();
        vector<vector<int>> jobs(n);

        for(int i=0; i<n; i++){
            jobs[i] = {startTime[i], endTime[i], profit[i]};
        }

        sort(jobs.begin(), jobs.end(), [](const vector<int>&job1, const vector<int>&job2){return job1[1] < job2[1]; });

        vector<int> dp(n+1);

        for(int i=1; i<=n; i++){
            //找到结束时间大于i-th job的开始时间的job id, 因为是有序的，所以id 可以转为对应的job数量, dp[2th job] 表示前两个job的最优解答，局部最优成为全局最优解答
            int k = upper_bound(jobs.begin(), jobs.begin()+i-1, jobs[i-1][0], [](int st, vector<int>& job){
                return st < job[1];
            }) - jobs.begin();
            
            dp[i] = max(dp[i-1], dp[k] + jobs[i-1][2]);
        }

        return dp[n];
    }
};

例子

遍历已经排序过的jobs, dp[0] =0;
1,3,20, -> dp[1] = 20
2,3,50 -> dp[2] = 50
4,6,70 -> dp[3] = dp[2] + 70 = 120
6,9,60 -> dp[4] = dp[3] + 60 = 180
3,10,100 -> dp[5] = max (dp[4], dp[2] +100) =180

upper_bound

std::upper_bound 函数在 C++ 标准库 <algorithm> 头文件中定义。以下是一个可能的实现：

template<class ForwardIt, class T, class Compare>
ForwardIt upper_bound(ForwardIt first, ForwardIt last, const T& value, Compare comp)
{
    ForwardIt it;
    typename std::iterator_traits<ForwardIt>::difference_type count, step;
    count = std::distance(first, last);

    while (count > 0) {
        it = first;
        step = count / 2;
        std::advance(it, step);
        if (!comp(value, *it)) {
            first = ++it;
            count -= step + 1;
        } else {
            count = step;
        }
    }
    return first;
}

这段代码展示了 std::upper_bound 的基本工作原理。它采用了二分查找的方法，在已排序的范围 [first, last) 中查找第一个大于 value 的元素。

参数解释：

• first：范围的起始迭代器
• last：范围的终止迭代器
• value：要查找的值
• comp：比较函数对象，用于定义元素的比较方式

该实现假设了输入的迭代器是随机访问迭代器，因此可以使用 std::advance 和 std::distance 来计算迭代器之间的距离和移动迭代器。实际的标准库实现可能会更加复杂，并且会根据不同的情况进行优化。

upper_bound(jobs.begin(), jobs.begin()+i-1, jobs[i-1][0], [](int st, vector<int>& job){
                return st < job[1];
            })

和

upper_bound(jobs.begin(), jobs.begin()+i-1, jobs[i-1][0], [](int st, vector<int>& job){
                return st > job[1];
            })

的区别：
这两个 upper_bound 函数调用的区别在于它们所使用的比较函数对象的不同。这些函数都是用来在已排序的序列中查找某个值的上界的。让我们分析一下这两个调用：

1. 第一个调用使用的比较函数是 [](int st, vector<int>& job){ return st < job[1]; }，它的作用是比较给定的时间 st 和任务的结束时间 job[1]。这个比较函数适用于在结束时间升序排序的情况下查找 st 的上界，即在 jobs 中找到第一个结束时间大于 st 的任务的位置。

2. 第二个调用使用的比较函数是 [](int st, vector<int>& job){ return st > job[1]; }，它的作用是比较给定的时间 st 和任务的结束时间 job[1]。这个比较函数适用于在结束时间降序排序的情况下查找 st 的上界，即在 jobs 中找到第一个结束时间小于 st 的任务的位置。

所以，这两个调用的区别在于它们所使用的比较函数导致了不同的排序顺序和查找逻辑。

函数对象介绍

函数对象是指可以像函数一样被调用的对象。在C++中，函数对象可以是函数指针、函数、Lambda 表达式或重载了函数调用运算符 operator() 的类对象。

函数对象可以作为参数传递给标准库中的算法，如 std::sort、std::find_if 等，用于指定算法的行为。这种方式使得算法更加灵活，可以根据不同的需求使用不同的比较方式或操作方式。

以下是一些关于函数对象的重要概念和用法：

1. 函数调用运算符 operator()：重载了这个运算符的类对象可以像函数一样被调用。当对象被调用时，operator() 会被执行。

2. Lambda 表达式：Lambda 表达式是一种轻量级的匿名函数，可以用于创建临时的函数对象。它可以在需要函数对象的地方直接定义，使代码更加简洁。

3. 标准库算法：标准库提供了许多算法，如排序、查找、变换等，这些算法通常都可以接受函数对象作为参数，用于指定算法的行为。

4. 适配器：函数对象可以通过适配器来改变其行为，如 std::bind 可以用于绑定参数，std::not1 可以用于对谓词取反等。

函数对象的灵活性和可重用性使得它们在C++中被广泛应用于各种场景，包括算法、事件处理、回调函数等。

可调用对象

可调用对象是指可以像函数一样被调用的对象。在 C++ 中，可调用对象可以是函数、函数指针、成员函数指针、函数对象（仿函数）、Lambda 表达式等。它们都可以在调用时像函数一样被执行。

不同类型的可调用对象：

1. 函数：最基本的可调用对象，就是传统的函数。

int add(int a, int b) {
    return a + b;
}

2. 函数指针：指向函数的指针，可以像函数一样被调用。

int (*funcPtr)(int, int) = add;
int result = funcPtr(3, 4); // 调用函数指针

3. 成员函数指针：指向类的成员函数的指针。

class MyClass {
public:
    int multiply(int a, int b) {
        return a * b;
    }
};

int (MyClass::*memFuncPtr)(int, int) = &MyClass::multiply;
MyClass obj;
int result = (obj.*memFuncPtr)(3, 4); // 调用成员函数指针

4. 函数对象（仿函数）：重载了函数调用运算符 operator() 的类对象，可以像函数一样被调用。

class Add {
public:
    int operator()(int a, int b) {
        return a + b;
    }
};

Add addObj;
int result = addObj(3, 4); // 调用函数对象

5. Lambda 表达式：匿名函数，可以直接在需要的地方定义和使用，也可以像函数一样被调用。

auto lambda = [](int a, int b) { return a + b; };
int result = lambda(3, 4); // 调用 Lambda 表达式

在 C++ 中，可调用对象的灵活性和多样性使得它们可以适用于各种不同的场景，例如作为算法的参数、事件处理、回调函数等。

lower_bound 和 upper_bound 的区别？

lower_bound 和 upper_bound 在功能上有所区别，尽管它们都是用于在有序序列中进行查找的算法：

1. lower_bound：

   • 返回的是第一个大于或等于给定值的元素的位置。
   • 如果在序列中找不到大于或等于给定值的元素，则返回指向序列末尾的迭代器。
   • 如果序列中存在多个等于给定值的元素，lower_bound 会返回它们中第一个元素的位置。

2. upper_bound：

   • 返回的是第一个大于给定值的元素的位置。
   • 如果在序列中找不到大于给定值的元素，则返回指向序列末尾的迭代器。
   • 如果序列中存在多个等于给定值的元素，upper_bound 会返回大于这些元素的第一个位置。

因此，lower_bound 返回的位置可能是等于给定值的元素的位置，而 upper_bound 则一定是大于给定值的元素的位置。这两个函数在处理有序序列时很有用，尤其是在需要进行范围查询或插入操作时。

sort 函数

std::sort 是 C++ 标准库中的一个算法，位于 <algorithm> 头文件中，用于对序列进行排序。它采用的是快速排序（Quicksort）或者堆排序（Heapsort）等效率较高的排序算法。

std::sort 函数的函数签名如下：

template< class RandomIt >
void sort( RandomIt first, RandomIt last );

其中：

• first 和 last 是表示要排序的序列的迭代器范围，即 [first, last)，它们定义了要排序的区间。

std::sort 函数会按照默认的升序规则对指定的序列进行排序。

要按照降序规则排序，可以通过传递一个自定义的比较函数作为第三个参数。比较函数应当返回一个布尔值，指示其第一个参数是否应该排在第二个参数之前。如果第一个参数应排在第二个参数之前，则返回 true；否则，返回 false。

以下是一个示例，展示如何使用 std::sort 对序列进行升序和降序排序：

#include <iostream>
#include <algorithm>
#include <vector>

// 自定义比较函数，用于降序排序
bool descending(int a, int b) {
    return a > b;
}

int main() {
    std::vector<int> vec = {5, 2, 9, 3, 7};

    // 升序排序
    std::sort(vec.begin(), vec.end());
    std::cout << "Ascending order: ";
    for (int num : vec) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 降序排序
    std::sort(vec.begin(), vec.end(), descending);
    std::cout << "Descending order: ";
    for (int num : vec) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个示例中，我们首先使用 std::sort 对序列进行升序排序，然后再次调用 std::sort，但这次传递了自定义的比较函数 descending，从而实现了降序排序。