给定一个 n x n 的矩阵 matrix ，矩阵的每一行和每一列都按升序排列。函数 countLE 返回矩阵中第 k 小的元素，则两处横线上应分别填写（ ）。
// 统计矩阵中 <= x 的元素个数：从左下角开始
int countLE(const vector<vector<int>>& matrix, int x) {
int n = (int)matrix.size();
int i = n - 1, j = 0, cnt = 0;
while (i >= 0 && j < n) {
if (matrix[i][j] <= x) {
cnt += i + 1;
++j;
} else {
--i;
}
}
return cnt;
}
int kthSmallest(vector<vector<int>>& matrix, int k) {
int n = (int)matrix.size();
int lo = matrix[0][0];
int hi = matrix[n - 1][n - 1];
while (lo < hi) {
int mid = lo + (hi - lo) / 2;
if (countLE(matrix, mid) >= k) {
________________ // 在此处填入代码
} else {
________________ // 在此处填入代码
}
}
return lo;
}
2分
登录后查看选项
11
下述C++代码实现了快速排序算法，下面说法错误的是（ ）。
int partition(vector<int>& arr, int low, int high) {
int i = low, j = high;
int pivot = arr[low]; // 以首元素为基准
while (i < j) {
while (i < j && arr[j] >= pivot) j--; //从右往左查找
while (i < j && arr[i] <= pivot) i++; //从左往右查找
if (i < j) swap(arr[i], arr[j]);
}
swap(arr[i], arr[low]);
return i;
}
void quickSort(vector<int>& arr, int low, int high) {
if (low >= high) return;
int p = partition(arr, low, high);
quickSort(arr, low, p - 1);
quickSort(arr, p + 1, high);
}
2分
登录后查看选项
12
下述C++代码实现了归并排序算法，则横线上应填写（ ）。
void merge(vector<int> &nums, int left, int mid, int right) {
// 左子数组区间为 [left, mid], 右子数组区间为 [mid+1, right]
vector<int> tmp(right - left + 1);
int i = left, j = mid + 1, k = 0;
while (i <= mid && j <= right) {
if (nums[i] <= nums[j])
tmp[k++] = nums[i++];
else
tmp[k++] = nums[j++];
}
while (i <= mid) {
tmp[k++] = nums[i++];
}
while (________) { // 在此处填入代码
tmp[k++] = nums[j++];
}
for (k = 0; k < tmp.size(); k++) {
nums[left + k] = tmp[k];
}
}
void mergeSort(vector<int> &nums, int left, int right) {
if (left >= right)
return;
int mid = (left + right) / 2;
mergeSort(nums, left, mid);
mergeSort(nums, mid + 1, right);
merge(nums, left, mid, right);
}
2分
登录后查看选项
13
假设你是一家电影院的排片经理，只有一个放映厅。你有一个电影列表 movies ，其中 movies[i] = [start_i, end_i] 表示第 i 部电影的开始和结束时间。请你找出最多能安排多少部不重叠的电影，则横线上应分别填写的代码为（ ）。
int maxMovies(vector<vector<int>>& movies) {
if (movies.empty()) return 0;
sort(movies.begin(), movies.end(), [](const vector<int>& a, const vector<int>& b) {
return ______; // 在此处填入代码
});
int count = 1;
int lastEnd = movies[0][1];
for (int i = 1; i < movies.size(); i++) {
if (movies[i][0] >= lastEnd) {
count++;
______ = movies[i][1]; // 在此处填入代码
}
}
return count;
}
int crossSum(vector<int>& nums, int left, int mid, int right) {
int leftSum = INT_MIN, rightSum = INT_MIN;
int sum = 0;
for (int i = mid; i >= left; i--) {
sum += nums[i];
leftSum = max(leftSum, sum);
}
sum = 0;
for (int i = mid + 1; i <= right; i++) {
sum += nums[i];
rightSum = max(rightSum, sum);
}
return leftSum + rightSum;
}
int helper(vector<int>& nums, int left, int right) {
if (left == right)
return nums[left];
int mid = left + (right - left) / 2;
int leftMax = helper(nums, left, mid);
int rightMax = helper(nums, mid + 1, right);
int crossMax = crossSum(nums, left, mid, right);
return max({leftMax, rightMax, crossMax});
}
int maxSubArray(vector<int>& nums) {
return helper(nums, 0, nums.size() - 1);
}
void findMusicalPattern(int rhythm1, int rhythm2) {
int commonDivisor = gcd(rhythm1, rhythm2);
int patternLength = (rhythm1 * rhythm2) / commonDivisor;
return patternLength；
}
2分
登录后查看选项
18
下面递归实现的斐波那契数列的时间复杂度为 O(2n)。
long long fib_memo(int n, long long memo[]) {
if (n <= 1) return n;
if (memo[n] != -1) return memo[n];
memo[n] = fib_memo(n - 1, memo) + fib_memo(n - 2, memo);
return memo[n];
}
int main() {
int n = 40;
long long memo[100];
fill_n(memo, 100, -1);
long long result2 = fib_memo(n, memo);
return 0;
}