二维数组中的查找

最新推荐文章于 2022-09-13 23:43:23 发布
最新推荐文章于 2022-09-13 23:43:23 发布
阅读量385 收藏 1
点赞数
分类专栏： 算法题 文章标签： 二维数组 算法 c++ 二分查找
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gongchenic/article/details/24563317
版权

来源与剑指OFFER中的一道题目，收录在九度OJ上，地址：http://ac.jobdu.com/problem.php?pid=1384


设矩形左上角坐标为（sx,sy），右上角坐标为（ex,ey）


一、分治

很简单的题意，自然想到的是分治，我最先尝试的算法是。

1.如果矩形大小为0，退出子查询

2.查看矩形最小最大点，检测目标值是否在其区间内，若不在则退出

3.取屏幕最中心的点；

4.如果中心点比目标值大，则去掉中心点右下方矩形，剩下左上，左下，右上三块矩形；

5.如果中心点比目标点小，则去掉中心点左上方矩形，剩下右下，左下，右上三块举行；

6.对剩下矩形，进入子查询


代码如下：

#include<stdio.h>
int m, n, t;
bool flag;
int num[1001][1001];
int findx, findy;
void find(int sx, int sy, int ex, int ey){
	//printf("%d %d %d %d", sx, sy, ex, ey);
	if (sx > ex || sy > ey)	return;
	if (num[sx][sy] > t)	return;
	else if (num[sx][sy] == t){
		flag = 1;
		return;
	}
	if (num[ex][ey] < t)	return;
	else if (num[ex][ey] == t){
		flag = 1;
		return;
	}
	int mx = sx + (ex - sx) / 2;
	int my = sy + (ey - sy) / 2;
	if (num[mx][my] < t){
		find(mx, sy, ex, my - 1);
		find(sx, my, mx - 1, ey);
		find(mx + 1, my + 1, ex, ey);
	}
	else if (num[mx][my]>t){
		find(mx + 1, sy, ex, my);
		find(sx, my + 1, mx, ey);
		find(mx - 1, my - 1, ex, ey);
	}
	else{
		flag = true;
		return;
	}
}
int main(){
	while (true){
		scanf("%d%d", &m, &n);
		if (m < 1 || n < 1) break;
		flag = false;
		scanf("%d", &t);
		for (int i = 0; i < m; i++)
		for (int j = 0; j < n; j++){
			scanf("%d", &num[i][j]);
		}
		find(0, 0, m - 1, n - 1);
		if (flag)	printf("Yes\n");
		else printf("No\n");
	}
	return 0;
}

遗憾的是，TlE了。个人事后推倒了一下，认为这样分治的时间复杂度应该是O(根3^(log(mn)))，并不是一个好的算法。


二、二分查询

每次剔除1/4显然不能满足我们，于是我想使用二分查询的思想来解决：

1.取当前矩阵最中间一行，二分查询找到最大的比目标值小的点

2.这个点（mx，my），将当前矩阵分为两块，左下方和右上方

3.在左下方和右上方的矩阵中继续步骤1


代码如下：

#include<stdio.h>
int m, n, t;
bool flag;
int num[1001][1001];
int binfind(int mx, int sy, int ey){
	int findy;
	if (num[mx][sy] == t){
		flag = true;
		return -1;
	}
	else if (num[mx][sy] > t){
		return sy;
	}
	if (num[mx][ey] == t){
		flag = true;
		return -1;
	}
	else if (num[mx][ey] < t){
		return ey;
	}
	while (sy <= ey){
		findy = sy + (ey - sy) / 2;
		if (num[mx][findy] > t)	 ey = findy - 1;
		else if (num[mx][findy] < t)	sy = findy + 1;
		else{
			flag = true;
			return -1;
		}
	}
	return sy;
}
void find(int sx, int ex, int sy, int ey){
	if (flag == 1) return;
	if (sx > ex || sy > ey) return;
	int mx = sx + (ex - sx) / 2;
	int my = binfind(mx, sy, ey);
	if (my == -1)
		return;
	else if (num[mx][my] > t){
		find(sx, mx - 1, my, ey);
		find(mx + 1, ex, sy, my - 1);
	}
	else if (num[mx][my] < t){
		find(sx, mx - 1, my + 1, ey);
		find(mx + 1, ex, sy, my);
	}
}

int main(){
	while (true){
		scanf("%d%d", &m, &n);
		if (m < 1 || n < 1) break;
		flag = false;
		scanf("%d", &t);
		for (int i = 0; i < m; i++)
		for (int j = 0; j < n; j++){
			scanf("%d", &num[i][j]);
		}

		find(0, m - 1, 0, n - 1);
		if (flag)	printf("Yes\n");
		else printf("No\n");
	}
	return 0;
}


时间复杂度是近似于O(logmlogn)的，但考虑到矩阵破碎之后，每一行的数据变短，行二分查询效率可能接近O(n)，所以其查询速度应是O(mlogn)，但肯定会优于一行行二分查找的算法。


但是仍然TLE了。


三、尝试剪枝

于是我尝试了另外一个想法，对于矩阵的上下左右边，每一条未经过查询的边使用二分查询找到其最大的比目标值小的点，都能够剪枝掉一部分矩阵。所以流程如下：

1.对上下左右依次使用二分查询，找到其最大的比目标值小的点；

2.对于上下左右边，依次利用步骤1中找到的点进行剪枝，去掉无用的矩阵；

3.在新的矩阵中重复步骤1，直到找到目标值


代码如下：

#include<stdio.h>
#include<iostream>
using namespace std;
int m, n, t;
bool flag;
int num[1001][1001];
int findx, findy;
void find(int sx, int sy, int ex, int ey){
	//printf("%d %d %d %d", sx, sy, ex, ey);
	if (sx > ex || sy > ey)	return;
	if (num[sx][sy] > t)	return;
	else if (num[sx][sy] == t){
		flag = 1;
		return;
	}
	if (num[ex][ey] < t)	return;
	else if (num[ex][ey] == t){
		flag = 1;
		return;
	}
	int mx = sx + (ex - sx) / 2;
	int my = sy + (ey - sy) / 2;
	if (num[mx][my] < t){
		find(mx, sy, ex, my - 1);
		find(sx, my, mx - 1, ey);
		find(mx + 1, my + 1, ex, ey);
	}
	else if (num[mx][my]>t){
		find(mx + 1, sy, ex, my);
		find(sx, my + 1, mx, ey);
		find(mx - 1, my - 1, ex, ey);
	}
	else{
		flag = true;
		return;
	}
}
int main(){
	while (true){
		scanf("%d%d", &m, &n);
		if (m < 1 || n < 1) break;
		flag = false;
		scanf("%d", &t);
		for (int i = 0; i < m; i++)
		for (int j = 0; j < n; j++){
			scanf("%d", &num[i][j]);
		}
		find(0, 0, m - 1, n - 1);
		if (flag)	printf("Yes\n");
		else printf("No\n");
	}
	return 0;
}

遗憾的是，很容易制造出一个数据，让上述算法效率很低，每次只能去掉最外面的一圈，跟剥洋葱一样最终才能拨到中心点。最终仍然TLE


四、可耻百度

OK，我承认这题弄得我很是崩溃然后进行了百度，算法非常优雅：

1.对于算法左上方的点x,y（抑或是右下方，都可以）

2.若num[x][y]小于目标值，删掉所在行

3.若num[x][y]大于目标值，删掉所在列

4.对新的矩形，继续步骤1，知道找到目标值或矩阵为空


代码如下：

// acm.cpp : 定义控制台应用程序的入口点。
//
#include<stdio.h>
int m, n, t;
bool flag;
int num[1001][1001];
int sx, sy, ex, ey;
int main(){
	while (true){
		scanf("%d %d", &m, &n);
		flag = false;
		scanf("%d", &t);
		for (int i = 0; i < m; i++)
		for (int j = 0; j < n; j++){
			scanf("%d", &num[i][j]);
		}
		sx = 0;
		sy = 0;
		ex = m - 1;
		ey = n - 1;
		if (num[sx][sy] > t)	flag = 0;
		else if (num[ex][ey] < t)	flag = 0;
		else if (num[sx][sy] == t)	flag = 1;
		else if (num[ex][ey] == t)	flag = 1;
		else{
			while (sx <= ex && sy <= ey){
				if (num[sx][ey] > t)	 ey--;
				else if (num[sx][ey] < t)	sx++;
				else{
					flag = true;
					break;
				}
			}
		}
		if (flag)	printf("Yes\n");
		else printf("No\n");
	}
	return 0;
}

代码简单美观，时间复杂度O（m+n）我实在想不到这样的算法再一次TLE，但现实往往如此无情。上述所有的尝试全部TLE

918607 gongchenic 1384 Time Limit Exceed 4936KB 872B >1000MS C++ / 代码 / 编辑 00:51:42
918606 gongchenic 1384 Time Limit Exceed 4936KB 683B >1000MS C++ / 代码 / 编辑 00:49:07
918603 gongchenic 1384 Time Limit Exceed 5432KB 1500B >1000MS C++ / 代码 / 编辑 00:34:25
917592 gongchenic 1384 Time Limit Exceed 5432KB 2643B >1000MS C++ / 代码 / 编辑 17:58:32
917538 gongchenic 1384 Time Limit Exceed 5432KB 1918B >1000MS C++ / 代码 / 编辑 17:08:49
917464 gongchenic 1384 Time Limit Exceed 5432KB 2236B >1000MS C++ / 代码 / 编辑 16:30:11
917390 gongchenic 1384 Time Limit Exceed 5432KB 1382B >1000MS C++ / 代码 / 编辑 15:34:44


五、TRUE END

无奈之下点开了下面的讨论版，里面有人提示了一个Tips，需要在循环中加入

while (scanf("%d %d", &m, &n) != EOF)
来检测输入流文件的结尾， 哭，然后瞬间我彻悟了（因为这种问题在POJ上一般是RUNTIME ERROR，所以一时没想到。。）。修改了之前的四份代码然后依次提交：

918616 gongchenic 1384 Time Limit Exceed 5432KB 1171B >1000MS C++ / 代码 / 编辑 01:02:52
918615 gongchenic 1384 Accepted 5432KB 1863B 680MS C++ / 代码 / 编辑 01:01:44
918614 gongchenic 1384 Accepted 5432KB 1461B 670MS C++ / 代码 / 编辑 01:00:09
918613 gongchenic 1384 Accepted 4936KB 873B 670MS C++ / 代码 / 编辑 00:57:50
除了三那份明显可以构造出TLE的数据的代码，其他全部AC 尴尬，膝盖跪烂


但是无论如何，可以明显地看出最优的算法应该是四，每一次稳定剪枝掉一行或者一列的算法。


五、MY TIPS

1.c++中如何检测输入流的结尾？

答：实际上这一题我之前完全是用c++的cin、cout来进行输入输出的，写法是while(cin>>m>>n)。

但是频频导致TLE，查阅了一些资料之后看到scanf以及printf效率会优于cin和cout，于是全部换成了c风格的输入输出。

while(cin>>m>>n)是否可以检测流文件的结尾有待测试。


2.一个异常的中断。

最后一段代码我使用了全局变量，但事实上只有一个main()函数，完全没有使用全局变量的意义。其实一开始我是没有把他们声明为全局变量的，但是放入main()函数中会产生莫名其妙的异常中断：

0x00901A37 处的第一机会异常(在 acm.exe 中):  0xC00000FD: Stack overflow (参数:  0x00000000, 0x00462000)。

这个异常中断是编译期间造成的，困惑了我很久找不到问题所在，只知道是num[1001][1001]不能声明在main()中，具体情况有待后期测试。


gongchenic
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java二维数组查找功能代码实现
08-19
Java二维数组查找功能代码实现是Java编程语言中的一种常见功能，主要用于在二维数组中查找指定的整数。这种功能的实现可以通过对二维数组的遍历和比较来实现。 首先，我们需要了解二维数组的特点。在Java中，二维...
二维数组的查找
jane_bingo的博客
01-19 255
在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。     简言之，从二维数组的右上角开始，将数组元素和target值进行比较，有三种情况：①若数组元素>taget值，把数组的最右边一列去掉，因为由于所给数组的特性target不可能出现在右列；②若数
LeetCode：240. Search a 2D Matrix II搜索二维矩阵 II（C语言）
C/C++攻城狮
09-11 361
题目描述： 编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性： 每行的元素从左到右升序排列。 每列的元素从上到下升序排列。 示例: 现有矩阵 matrix 如下： [ [1, 4, 7, 11, 15], [2, 5, 8, 12, 19], [3, 6, 9, 16, 22], [10, 13, 14, 17, 24], [18, 21, 23, 26, 30] ] 给定 target = 5，返回 tru
二维数组中的查找（数组中大小有规律）
kinoyoung的博客
12-17 264
题目 https://www.nowcoder.com/practice/abc3fe2ce8e146608e868a70efebf62e?tpId=13&&tqId=11154&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking 思路心得 如图所示，可以从二维数组的右上角第一个元素开始，与目标值进行比较判断，如果目标值小于当前值（即图中蓝圈的值），就说明我们接下来只需查找
Python 二维数组中的查找
12-21
总结来说，这两种方法都是解决在特定排序的二维数组中查找整数问题的有效策略。方法二的效率更高，因为它利用了有序性质进行二分查找，减少了平均查找次数。在实际应用中，我们应该优先考虑时间复杂度更低的方法，以...
js代码-二维数组中的查找
07-16
总结一下，JavaScript中的二维数组查找涉及到基础的线性查找以及在特定情况下适用的二分查找。理解并熟练运用这些查找方法对于编写高效的数据处理程序至关重要。同时，阅读和分析`main.js`和`README.txt`文件将有助...
C++二维数组中的查找算法示例
01-01
本文实例讲述了C++二维数组中的查找算法。分享给大家供大家参考，具体如下： 一、问题： 在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的...
分治算法---二分搜索算法
qdliwen的博客
04-13 1152
1..二分搜索的前提条件 使用二分搜索进行查找的数组必须有序，假如数组无序，则二分搜索的输出结果是不正确的。本次叙述中，假设数组元素顺序为非递减的(a0 2.用分而治之的术语描述二分搜索算法如下: (1)  由于数组中元素按一定顺序排列，则可先确定数组中间位置的元素，并根据中间位置的元素将数组划分为两个元素个数差不多相当的两个子数组 。 (2) 由于数组元素有序，则需先将数组中间位置的元素
04 二维有序数组的查找
weixin_30588729的博客
11-14 130
题目：在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 解题思路： #第一步：要判断数组是否非空，空数组 return false，不用进行其他操作。 1）从数组的左下角或右上角遍历。时间：11ms，占用内存：1512k。复杂度：。 2）对每一行进...
【剑指offerC++版】1.二维数组中的查找
jyn997558085的博客
12-07 154
时间限制：1秒空间限制：32768K 题目描述：在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 思路： 可以利用二分查找的思想，每一行，设置最左端位置low，和最右端位置hight，计算中间位置，mid=（low+hight）/2，找出中间数字，与...
经典算法之二维数组中的查找问题
探索者李小白的博客
10-04 1578
前言 数组可以说是是最简单的一种数据结构，它占据一块连续的内存并按照顺序存储数据结构。创建数组时，我们需要首先指定数组的容量大小，然后根据大小分配内存。即使我们只在数组中存储一个数字，也需要为所有的数据预先分配内存。因此数组的空间效率不是很好，经常会有空闲的区域没有得到充分利用。 由于数组中的内存是连续的，于是可以根据下标在O(1)时间读/写任何元素，因此时间效率是很高的。我们可以根据
二分查找\排序——分而治之☞二维数组中的查找
最新发布
weixin_53919192的博客
09-13 271
本文为大家介绍了二分查找\排序——分而治之☞二维数组中的查找，希望对你有帮助~~
剑指Offer---JZ1 二维数组中的查找
weixin_45976622的博客
09-09 397
描述 在一个二维数组array中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 [ [1,2,8,9], [2,4,9,12], [4,7,10,13], [6,8,11,15] ] 给定 target = 7，返回 true。 给定 target = 3，返回 false。 0 <= array.length <= 500 0 <= array[0].leng
查找有序二维数组的中位数
大雄没有叮当猫的博客
07-02 1989
题目：给定 n×n 的实数矩阵，每行和每列都是递增的，求这 n^2 个数的中位数代码如下：package com.cb.java.algorithms.programmingmethod.search; /** * 给定 n×n 的实数矩阵，每行和每列都是递增的，求这 n^2 个数的中位数 * * @author 36184 * */ public class SearchMedia...
剑指Offer(一) 数组中重复的数字,二维数组中的查找
尔等同学的博客
09-02 410
2019年9月2日 愿你我有得有失,能哭能笑能尽欢 数组中重复的数字 题目一：在一个长度为n的数组里的所有数字都在0~n-1的范围内。数组中某些数字是重复的，但是不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。例如，如果输入长度为7,的数组{2,3,1,0,2,5,3}，那么对应的输出是重复的数组2或者3。（n个元素，n种可能的取值） 思路: ...
浅谈 搜索二维矩阵 问题
嘟嘟的博客
03-30 335
搜索二维矩阵 问题： 编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性： 每行中的整数从左到右按升序排列。 每行的第一个整数大于前一行的最后一个整数。 思路： 先进行搜索，再进行列搜索。 由于二维数组元素升序排列，所以都采用从后往前搜索，比较方便确定 target 所在行 可以采用二分查找的方法使时间复杂度从 mn 降到 log(mn) 。 class Solution { public: bool searchMatrix(vector&lt

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值