第六十六天 --- 力扣-240+CCF两题
题目一
思路
这个题目看起来很简单，最暴力的解法无非就是访问矩阵的每一个点即可，但这效率不高，所以在提及检索的时候，我们第一个想到的就是二分检索(一维),所以我们从这里出发，一起看本题要用什么方法。
方法一：一个维度的二分检索，另一个维度顺序
1、这个是我自己想的思路，很简单，二维矩阵的每一行都是一个一维数组，那么我们可不可以简化每一行的检索过程，即每一行上进行快速的二分检索，这一行没有就进入下一行，这样就可以找到答案。
2、值得注意的是，当进入新的一行的时候，发现行首的值大于目标值，根据题意可知，从该行起，他的下面所有元素都大于目标，就没必要找了，减少搜索过程。
方法二：二维二分查找
二维最大的特点就是，有两个维度，所以二分找的时候不能只找一个维度，必须找一次，搜索两个维度，为了做到这点，其实也很简单，只需要沿着对角线搜索就行。
过程如上图所示，按照对角线搜索即可，但也如图所示，会产生很多冗余查找，所以时间复杂度较高。
方法三：线性复杂度查找
以上方法其实都没充分用到本体的关键性条件，即每行从左到右递增，每列从上到下递减。
1、首先要明白这个矩阵里的每个元素其实都是有序的
2、第二，我们要找到边界关键点，即他在边界且可进可退，如果目标大于或者小于这个节点，那么都得能找出相应的移动方向，所以关键点初始点只能是左下角，右上角
3、从关键点走，以左下角为例，小于关键点，则关键点就往上走，反之向右走，直到找到目标或者向上向右越界
代码
方法一代码：
注：在使用vector或者数组的时候，一定注意，他的有效范围在0~n-1，千万别越界。
class Solution {
public:
bool binaryFind(int target, vector<int>& item) {
//二分查找，不做赘述
int i = 0, j = item.size() - 1;
while (i <= j) {
int mid = (i + j) / 2;
if (item[mid] == target) {
return true;
}
else if(item[mid] > target){
j = mid - 1;
}
else if (item[mid] < target) {
i = mid + 1;
}
}
return false;
}
bool searchMatrix(vector<vector<int>>& matrix, int target) {
int m = matrix.size();
int n = matrix[0].size();
if (target<matrix[0][0] || target>matrix[m - 1][n - 1]) {
//把很明显不对的数据排除
return false;
}
if (target == matrix[0][0] || target == matrix[m - 1][n - 1]) {
return true;
}
for (int i = 0; i < matrix.size(); i++) {
//枚举行
if (matrix[i][0] > target) {
break;
}
if (binaryFind(target, matrix[i])) {
return true;
}
}
return false;
}
};
（所有代码均已在力扣上运行无误）
经测试，该代码运行情况是(经过多次测试所得最短时间)：
时间复杂度：O(nlgn)
空间复杂度：O(1)
方法二代码：
class Solution {
public:
int m, n;
bool binaryFind(vector<vector<int>>& matrix, int target, int p, bool col_or_row) {
//二维二分查找
int i = 0;
int j = col_or_row ? m - 1 : n - 1;//为真查列，为假查行
if (col_or_row) {
//col_or_row决定查列还是行
while (i <= j) {
//二分查列
int mid = (i + j) / 2;
if (matrix[mid][p] == target) {
return true;
}
else if (matrix[mid][p] > target) {
j = mid - 1;
}
else if (matrix[mid][p] < target) {
i = mid + 1;
}
}
}
else {
while (i <= j) {
//二分查行
int mid = (i + j) / 2;
if (matrix[p][mid] == target) {
return true;
}
else if (matrix[p][mid] > target) {
j = mid - 1;
}
else if (matrix[p][mid] < target) {
i = mid + 1;
}
}
}
return false;
}
bool searchMatrix(vector<vector<int>>& matrix, int target) {
m = matrix.size();
n = matrix[0].size();
if (matrix.empty() || matrix[0].empty()) {
//处理特殊情况，为空，两种空的情况
return false;
}
if (target<matrix[0][0] || target>matrix[m - 1][n - 1]) {
//排除肯定错的
return false;
}
if (target == matrix[0][0] || target == matrix[m - 1][n - 1]) {
return true;
}
int shorterDim = min(matrix.size(), matrix[0].size());//找对角线
for (int i = 0; i < shorterDim; i++) {
//按照对角线找点
bool find1 = binaryFind(matrix, target, i, true);//扫列
bool find2 = binaryFind(matrix, target, i, false);//扫行
if (find1 || find2) {
return true;
}
}
return false;
}
};
（所有代码均已在力扣上运行无误）
经测试，该代码运行情况是(经过多次测试所得最短时间)：
方法三代码：
1、左下角
class Solution {
public:
bool searchMatrix(vector<vector<int>>& matrix, int target) {
int m = matrix.size() - 1, n = 0;//初始值
while (m >= 0 && n < matrix[0].size()) {
//越界条件
if (matrix[m][n] > target) {
m--;
}
else if (matrix[m][n] < target) {
n++;
}
else {
return true;
}
}
return false;
}
};
2、右上角
class Solution {
public:
bool searchMatrix(vector<vector<int>>& matrix, int target) {
int m = 0, n = matrix[0].size() - 1;
while (m < matrix.size() && n >= 0) {
if (matrix[m][n] > target) {
n--;
}
else if (matrix[m][n] < target) {
m++;
}
else {
return true;
}
}
return false;
}
};
（所有代码均已在力扣上运行无误）
经测试，该代码运行情况是(经过多次测试所得最短时间)：
题目二：
思路
直接模拟题目要求，注意输出的时候一定要换行
代码
///202006-1 线性分类器
#include <iostream>
#include <algorithm>
#include <unordered_set>
using namespace std;
int n, m;
int t0, t1, t2;
struct point {
//点
int x;
int y;
};
point p_A[1005], p_B[1005];//AB类型的点
int main()
{
cin >> n >> m;
int cnt_A = 0, cnt_B = 0;//AB类点的个数
for (int i = 0; i < n; i++) {
int tmp_x, tmp_y;
char tmp_c;
scanf("%d %d %c", &tmp_x, &tmp_y, &tmp_c);//输入
if (tmp_c == 'A') {
//输入
p_A[cnt_A].x = tmp_x;
p_A[cnt_A].y = tmp_y;
cnt_A++;
}
else {
p_B[cnt_B].x = tmp_x;
p_B[cnt_B].y = tmp_y;
cnt_B++;
}
}
for (int i = 0; i < m; i++) {
//开始处理不同直线
cin >> t0 >> t1 >> t2;
int change = -1;
bool fal = false;
for (int j = 0; j < cnt_A; j++) {
//处理A类点
int tmp = p_A[j].x*t1 + p_A[j].y*t2;
if (j == 0) {
//第一个点决定所有的点与直线的相对位置
if (tmp + t0 < 0) {
change = -1;
}
else {
change = 1;
}
}
else {
if( (tmp + t0 < 0&&change==1) || (tmp + t0 > 0 && change == -1)){
fal = true;//因为出现了在直线不同位置的点，代表A类点出现在直线两侧
break;
}
}
}
if (!fal) {
//处理B类点
for (int j = 0; j < cnt_B; j++) {
//含义同上
int tmp = p_B[j].x*t1 + p_B[j].y*t2;
if (j == 0) {
if (tmp + t0 < 0) {
change = -1;
}
else {
change = 1;
}
}
else {
if ((tmp + t0 < 0 && change == 1) || (tmp + t0 > 0 && change == -1)) {
fal = true;
break;
}
}
}
}
if (fal) {
printf("%s\n", "No");
}
else {
printf("%s\n", "Yes");
}
}
}
（所有代码均已在力扣上运行无误）
经测试，该代码运行情况是(经过多次测试所得最短时间)：
时间复杂度：O(N^2)
题目三
思路：
这个题其实思路很简单，但是需要处理好大数据的问题，所以基础思路就是哈希。思路就是以一个向量作为主体，第二个向量边读取，边查找第一个向量想同纬度的值。
代码：
注意：为了防止越界，一定要用long long，做题之前看好数据规模约定！！！！！！
//202006-2 稀疏向量
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
long long n, a, b;
int main()
{
cin >> n >> a >> b;
long long ans = 0;
unordered_map<long long, long long> item;//哈希实现的map
for (long long i = 0; i < a; i++) {
long long x, y;
scanf("%lld%lld", &x, &y);
item.insert(pair<long long, long long>(x, y));//添加map
}
for (long long i = 0; i < b; i++) {
long long x, y;
scanf("%lld%lld", &x, &y);
if (item.count(x) == 0) {
//同纬度没查到，则意味着同纬度下第一个向量的值为0
continue;
}
else {
ans += item.at(x)*y;
}
}
cout << ans;
}
（所有代码均已在力扣上运行无误）
经测试，该代码运行情况是(经过多次测试所得最短时间)：
时间复杂度：O(N)