Java实现格子匹配算法

最新推荐文章于 2024-09-12 23:58:52 发布
最新推荐文章于 2024-09-12 23:58:52 发布
阅读量226 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/propagator/blog/1845924
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

前不久帮朋友做一个东西，里面涉及到一个核心算法。在一个AxB的大棋盘上，每个格子里有一个整数，现在有一个CxD的小棋盘，里面每个格子里也有一个整数。现在要求在大棋盘上找是否有和小棋盘匹配的区域，要求可以对称匹配（即小棋盘是大棋盘上相关区域的镜像也可以）。因为棋盘都不大，大的可能最多16x16，小的可能最多5x5，所以随手写了一个，现在把核心代码记录下来，以后有机会再改改。

Direction.java

package matchCore;

public enum Direction{
	East,
	West,
	South,
	North,
	EastMirror,
	WestMirror,
	SouthMirror,
	NorthMirror
}

 

PosAndDir.java

package matchCore;

public class PosAndDir {
	public Position pos;
	public Direction dir;
	
	public PosAndDir() {
		pos = new Position(0, 0);
		dir = Direction.South;
	}
	
	public PosAndDir(int x, int y, Direction d) {
		pos.x = x;
		pos.y = y;
		dir = d;
	}
}

 

Position.java

package matchCore;

public class Position {
	public int x;
	public int y;
	
	public Position(int a, int b) {
		x = a;
		y = b;
	}
	
	public boolean equal(Position pos) {
		if (x == pos.x && y == pos.y) return true;
		return false;
	}
}

以上三个类都是辅助定义类，用来定义位置和方向。

 

IntArrayMatch.java

package matchCore;

import java.util.ArrayList;
import java.util.List;

public class IntArrayMatch {
	// 找出所有匹配的位置和方向
	public List<PosAndDir> matchAll(int[][] base, int[][] conf) {
		if (base == null || conf == null) return null;
		if (base.length < 1 || conf.length < 1) return null;
		
		int xdim = conf.length;
		int ydim = conf[0].length;
		List<PosAndDir> list = new ArrayList<PosAndDir>();
		for (int i = 0; i < base.length; i++) {
			for (int j = 0; j < base[i].length; j++) {
				for (Direction dir : Direction.values()) {
					PosAndDir pd = new PosAndDir(i, j, dir);
					int[][] subarray = getSubArray(base, pd, xdim, ydim);
					if (subarray == null) continue;
					else if (subMatch(subarray, conf)) list.add(pd);
				}
			}
		}
		return list;
	}
	
	// 找出一个匹配的位置和方向
	public PosAndDir matchOne(int[][] base, int[][] conf) {
		if (base == null || conf == null) return null;
		if (base.length < 1 || conf.length < 1) return null;
		
		int xdim = conf.length;
		int ydim = conf[0].length;
		PosAndDir pd = new PosAndDir();
		for (int i = 0; i < base.length; i++) {
			for (int j = 0; j < base[i].length; j++) {
				pd.pos = new Position(i,j);
				for (Direction dir : Direction.values()) {
					pd.dir = dir;
					int[][] subarray = getSubArray(base, pd, xdim, ydim);
					if (subarray == null) continue;
					else if (subMatch(subarray, conf)) return pd;
				}
			}
		}
		return null;
	}
	
	// 获取sub中值为tag的格子所在的所有坐标，base为盘面，pd为sub的起始坐标和方向
	public List<Position> getPos(int[][] base, PosAndDir pd, int[][] sub, int tag) {
		int xdim = sub.length;
		int ydim = sub[0].length;
		List<Position> m_pos = new ArrayList<Position>();
		if (pd.dir == Direction.South) {
			if (pd.pos.x + xdim > base.length) return null;
			if (pd.pos.y + ydim > base[0].length) return null;
			int x0 = pd.pos.x;
			int y0 = pd.pos.y;

			for (int i = 0; i < xdim; i++) {
				for (int j = 0; j < ydim; j++) {
					if (sub[i][j] == tag) {
						Position pos = new Position(x0+i, y0+j);
						m_pos.add(pos);
					}
				}
			}
			return m_pos;
		} else if (pd.dir == Direction.SouthMirror) {
			if (pd.pos.x + xdim > base.length) return null;
			if (pd.pos.y + ydim > base[0].length) return null;
			int x0 = pd.pos.x + xdim - 1;
			int y0 = pd.pos.y;
			for (int i = 0; i < xdim; i++) {
				for (int j = 0; j < ydim; j++) {
					if (sub[i][j] == tag) {
						Position pos = new Position(x0-i, y0+j);
						m_pos.add(pos);
					}
				}
			}
			return m_pos;
		} else if (pd.dir == Direction.East) {
			if (pd.pos.x - ydim < -1) return null;
			if (pd.pos.y + xdim > base[0].length) return null;
			int x0 = pd.pos.x;
			int y0 = pd.pos.y;
			for (int i = 0; i < xdim; i++) {
				for (int j = 0; j < ydim; j++) {
					if (sub[i][j] == tag) { 
						Position pos = new Position(x0-j, y0+i);
						m_pos.add(pos);
					}
				}
			}
			return m_pos;
		} else if (pd.dir == Direction.EastMirror) {
			if (pd.pos.x - ydim < -1) return null;
			if (pd.pos.y + xdim > base[0].length) return null;
			int x0 = pd.pos.x;
			int y0 = pd.pos.y + xdim - 1;
			for (int i = 0; i < xdim; i++) {
				for (int j = 0; j < ydim; j++) {
					if (sub[i][j] == tag) {
						Position pos = new Position(x0-j, y0-i);
						m_pos.add(pos);
					}
				}
			}
			return m_pos;
		} else if (pd.dir == Direction.North) {
			if (pd.pos.x - xdim < -1) return null;
			if (pd.pos.y - ydim < -1) return null;
			int x0 = pd.pos.x;
			int y0 = pd.pos.y;
			for (int i = 0; i < xdim; i++) {
				for (int j = 0; j < ydim; j++) {
					if (sub[i][j] == tag) {
						Position pos = new Position(x0-i, y0-j);
						m_pos.add(pos);
					}
				}
			}
			return m_pos;
		} else if (pd.dir == Direction.NorthMirror) {
			if (pd.pos.x - xdim < -1) return null;
			if (pd.pos.y - ydim < -1) return null;
			int x0 = pd.pos.x - xdim + 1;
			int y0 = pd.pos.y;
			for (int i = 0; i < xdim; i++) {
				for (int j = 0; j < ydim; j++) {
					if (sub[i][j] == tag) {
						Position pos = new Position(x0+i, y0-j);
						m_pos.add(pos);
					}
				}
			}
			return m_pos;
		} else if (pd.dir == Direction.West) {
			if (pd.pos.x + ydim > base.length) return null;
			if (pd.pos.y - xdim < -1) return null;
			int x0 = pd.pos.x;
			int y0 = pd.pos.y;
			for (int i = 0; i < xdim; i++) {
				for (int j = 0; j < ydim; j++) {
					if (sub[i][j] == tag) {
						Position pos = new Position(x0+j, y0-i);
						m_pos.add(pos);
					}
				}
			}
			return m_pos;
		} else if (pd.dir == Direction.WestMirror) {
			if (pd.pos.x + ydim > base.length) return null;
			if (pd.pos.y - xdim < -1) return null;
			int x0 = pd.pos.x;
			int y0 = pd.pos.y - xdim + 1;
			for (int i = 0; i < xdim; i++) {
				for (int j = 0; j < ydim; j++) {
					if (sub[i][j] == tag) {
						Position pos = new Position(x0+j, y0+i);
						m_pos.add(pos);
					}
				}
			}
			return m_pos;
		} else {
			
		}
		return null;
	}
	
	// 根据位置和方向pd给出base中大小为x,y的子矩阵
	private int[][] getSubArray(int[][] base, PosAndDir pd, int xdim, int ydim) {
		if (base == null || pd == null) {
			
		}
		if (xdim < 1 || ydim < 1) {
			
		}
		
		int[][] sub = new int[xdim][ydim];
		if (pd.dir == Direction.South) {
			if (pd.pos.x + xdim > base.length) return null;
			if (pd.pos.y + ydim > base[0].length) return null;
			int x0 = pd.pos.x;
			int y0 = pd.pos.y;
			for (int i = 0; i < xdim; i++) {
				for (int j = 0; j < ydim; j++) {
					sub[i][j] = base[x0+i][y0+j];
				}
			}
			return sub;
		} else if (pd.dir == Direction.SouthMirror) {
			if (pd.pos.x + xdim > base.length) return null;
			if (pd.pos.y + ydim > base[0].length) return null;
			int x0 = pd.pos.x + xdim - 1;
			int y0 = pd.pos.y;
			for (int i = 0; i < xdim; i++) {
				for (int j = 0; j < ydim; j++) {
					sub[i][j] = base[x0-i][y0+j];
				}
			}
			return sub;
		} else if (pd.dir == Direction.East) {
			if (pd.pos.x - ydim < -1) return null;
			if (pd.pos.y + xdim > base[0].length) return null;
			int x0 = pd.pos.x;
			int y0 = pd.pos.y;
			for (int i = 0; i < xdim; i++) {
				for (int j = 0; j < ydim; j++) {
					sub[i][j] = base[x0-j][y0+i];
				}
			}
			return sub;
		} else if (pd.dir == Direction.EastMirror) {
			if (pd.pos.x - ydim < -1) return null;
			if (pd.pos.y + xdim > base[0].length) return null;
			int x0 = pd.pos.x;
			int y0 = pd.pos.y + xdim - 1;
			for (int i = 0; i < xdim; i++) {
				for (int j = 0; j < ydim; j++) {
					sub[i][j] = base[x0-j][y0-i];
				}
			}
			return sub;
		} else if (pd.dir == Direction.North) {
			if (pd.pos.x - xdim < -1) return null;
			if (pd.pos.y - ydim < -1) return null;
			int x0 = pd.pos.x;
			int y0 = pd.pos.y;
			for (int i = 0; i < xdim; i++) {
				for (int j = 0; j < ydim; j++) {
					sub[i][j] = base[x0-i][y0-j];
				}
			}
			return sub;
		} else if (pd.dir == Direction.NorthMirror) {
			if (pd.pos.x - xdim < -1) return null;
			if (pd.pos.y - ydim < -1) return null;
			int x0 = pd.pos.x - xdim + 1;
			int y0 = pd.pos.y;
			for (int i = 0; i < xdim; i++) {
				for (int j = 0; j < ydim; j++) {
					sub[i][j] = base[x0+i][y0-j];
				}
			}
			return sub;
		} else if (pd.dir == Direction.West) {
			if (pd.pos.x + ydim > base.length) return null;
			if (pd.pos.y - xdim < -1) return null;
			int x0 = pd.pos.x;
			int y0 = pd.pos.y;
			for (int i = 0; i < xdim; i++) {
				for (int j = 0; j < ydim; j++) {
					sub[i][j] = base[x0+j][y0-i];
				}
			}
			return sub;
		} else if (pd.dir == Direction.WestMirror) {
			if (pd.pos.x + ydim > base.length) return null;
			if (pd.pos.y - xdim < -1) return null;
			int x0 = pd.pos.x;
			int y0 = pd.pos.y - xdim + 1;
			for (int i = 0; i < xdim; i++) {
				for (int j = 0; j < ydim; j++) {
					sub[i][j] = base[x0+j][y0+i];
				}
			}
			return sub;
		} else {
			
		}
		
		
		return null;
	}
	
	// 判断两个矩阵是否全同，全同返回true，否则返回false
	private boolean subMatch(int[][] src, int[][] des) {
		if (src == null || des == null) return false;
		if (src.length != des.length) return false;
		if (src.length < 1) return false;
		if (src[0].length != des[0].length) return false;
		
		for (int i = 0; i < src.length; i++) {
			for (int j = 0; j < src[i].length; j++) {
				if (src[i][j] != des[i][j]) return false;
			}
		}
			
		return true;
	}
}

上面这个类实现了匹配的主要功能。只需要在外面调用其public方法即可判断是否匹配，并且给出第一个匹配的区域的位置和方向。下面给出测试文件：

IntArrayMatchTest.java

package matchCore;

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;

public class IntArrayMatchTest {
	private IntArrayMatch m_match;
	private int[][] m_base;
	private int[][] m_conf;
	
	@Before
	public void setUp() throws Exception {
		m_match = new IntArrayMatch();
		m_base = new int[9][9];
		m_conf = new int[2][3];
		int c = 0;
		for (int j = 8; j >= 0; j--) {
			for (int i = 0; i < 9; i++) {
				c++;
				m_base[i][j] = c;
				System.out.print(m_base[i][j] + " ");
			}
			System.out.println();
		}
		
		m_conf[0][0] = 32;
		m_conf[0][1] = 33;
		m_conf[0][2] = 34;
		m_conf[1][0] = 41;
		m_conf[1][1] = 42;
		m_conf[1][2] = 43;
	}

	@Test
	public void testMatch() {
		PosAndDir pd = m_match.matchOne(m_base, m_conf);
		System.out.println("pos = (" + pd.pos.x + ", " + pd.pos.y + 
				"), dir = " + pd.dir.toString());
		assertEquals(5, 5);
	}

}

上面的单测结果为：

1 2 3 4 5 6 7 8 9 
10 11 12 13 14 15 16 17 18 
19 20 21 22 23 24 25 26 27 
28 29 30 31 32 33 34 35 36 
37 38 39 40 41 42 43 44 45 
46 47 48 49 50 51 52 53 54 
55 56 57 58 59 60 61 62 63 
64 65 66 67 68 69 70 71 72 
73 74 75 76 77 78 79 80 81 
pos = (4, 5), dir = West

 

转载于:https://my.oschina.net/propagator/blog/1845924

weixin_34212762
关注
Java:实现朴素模式匹配算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
01-28 237
Java:实现朴素模式匹配算法（附完整源码）
尚硅谷Java数据结构与java算法 全194章笔记整理
Foools的博客
08-11 2168
前言 视频地址：https://www.bilibili.com/video/BV1E4411H73v?from=search&seid=13120683720695451628 评价：整个教程的数据结构部分讲的挺好的，知识点全都覆盖了，而且每个数据结构都有代码解释，但是最后20节算法部分讲的有点乱，算法部分我决定直接刷leetcode了 数组 稀疏数组： 二维数组的省内存的保存方法，一般是n行3列，三列分别为行，列，值。 二维数组转稀疏数组： 遍历整个二维数组，查看有多少个有效数字 根据有效数字
算法笔记_064:蓝桥杯练习 操作格子（Java）
weixin_34234823的博客
03-05 238
目录 1 问题描述 2 解决方案   1 问题描述 问题描述 有n个格子，从左到右放成一排，编号为1-n。 共有m次操作，有3种操作类型： 1.修改一个格子的权值， 2.求连续一段格子权值和， 3.求连续一段格子的最大值。 对于每个2、3操作输出你所求出的结果。 输入格式 第一行2个整数n，m。 接下来一行n个整数表示n个格子的初始权值。 接下...
java算法 方格填数
weixin_30338461的博客
01-24 106
方格填数 如下的10个格子 填入0~9的数字。要求：连续的两个数字不能相邻。（左右、上下、对角都算相邻） 一共有多少种可能的填数方案？ 请填写表示方案数目的整数。注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。 public class Main { static int count = 0; public static void main(Str...
java匹配算法_java实现多模匹配算法
weixin_32896083的博客
02-12 245
这个是好几年前写的了.都统一放到cnblogs上面.--------------------------------Node ----------------------------------package com;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util....
字符串匹配算法Java_Java实现字符串匹配算法KMP
weixin_39948439的博客
02-20 220
kmp算法的核心思想：先对搜索字串生成偏移对照表，匹配时从左向右依次比较(bm从右向左，号称比kmp更快)，相等则文档和搜索字串的下标+1迭代， 否则查表，定位最优的偏移位置(文档下标不变，搜索字串下标改变)。例外是，字符不匹配时，若搜索字串的下标为0，则文档的下标+1，继续迭代比较。importjava.util.Arrays;publicclassKMPSearch{publicst...
Java数据结构和算法.pptx
03-16
在这个Java数据结构和算法的课程中，我们将深入探讨这些概念，并通过实际的面试题来演示其重要性和应用。 首先，我们来看一个经典的字符串匹配问题。在面试中，可能会遇到这样的题目：给定一个主字符串str1和一个...
画家算法和直线反走样的QT,Web，VC,C#,OpenGL,Java的实现
05-29
《画家算法与直线反走样在QT、Web、VC、C#、OpenGL及Java中的实现》 画家算法，又称扫描线算法，是图形学中一种基础的渲染算法，主要用于解决多边形重叠时的绘制顺序问题。该算法按照图形的深度（或称Z轴值）从远到...
Java实现五子棋游戏.zip
09-10
在本项目中，"Java实现五子棋游戏.zip" 是一个使用Java编程语言开发的五子棋游戏。这个项目展示了如何利用Java进行图形用户界面(GUI)设计和游戏逻辑的实现，是学习Java基础、事件处理以及游戏编程的一个很好的实例。...
数据结构-串的模式匹配算法（Java实现）
11-27
编程实现如下功能： 1、在实验六的基础上，实现串的Brute-Force模式匹配算法。 2、尝试实现串的KMP模式匹配算法。
java图形填充算法
12-05
用java模拟画板，用鼠标监控，能描绘出任意多边形，然后用边填充算法，对多边形进行填充。
JAVA实现KMP模式匹配算法
星回昭以烂的博客
08-05 376
JAVA实现KMP字符串模式匹配算法
字符串匹配算法(C/Java实现)
qq_63983125的博客
11-04 1098
BF算法，KMP算法(C/Java实现)
蓝桥杯 算法训练 操作格子 java
我命由己不由天
07-29 284
Algo8 算法训练 操作格子 题目如下: 这题其实已经有提示用线段树了，如果纯暴力模拟的话是不可能，看看数据规模就知道了。 至于啥是线段树，建议看一下这个线段树入门的：https://blog.csdn.net/qq_39826163/article/details/81436440 非常好懂，建议先看完上述博客再写题。 知道什么是线段树就好办了，其实这道题就是一道线段树模板题，都是些区间求和，单点修改的基本操作，取最大值其实类似区间求和的 当然，这里要说一下蓝桥杯哦，你像hdu这种java都是给2s的
Java实现KMP字符串匹配算法
qq_52655865的博客
01-13 1050
了解kmp算法，先看以下几个概念 部分匹配表： 看着这肯定一脸懵逼，没办法，如果看不懂建议先找找资料 前缀和后缀的概念： 如果仔细阅读上面的图相信大家已经理解部分匹配表和搜索词的概念了 ...
算法笔记_226:填符号凑算式(Java)
weixin_33754913的博客
05-23 103
目录 1 问题描述 2 解决方案   1 问题描述 匪警请拨110,即使手机欠费也可拨通！ 为了保障社会秩序，保护人民群众生命财产安全，警察叔叔需要与罪犯斗智斗勇，因而需要经常性地进行体力训练和智力训练！ 某批警察叔叔正在进行智力训练： 1 2 3 4 5 6 7 8 9 = 110; 请看上边的算式，为了使等式成立，需要在数字间填入加号或者减号（可以不填，...
二分图匹配 POJ - 3020 1x2的方格匹配地图
H_ang的博客
05-19 207
给你一个地图，每个天线最多可以覆盖相邻的两个房子，问你最少用多少个天线可以覆盖全部房子。 思路：先对所有的房子编号，然后对一个房子x如果它正下方或者右方有房子y, 那么e[x][y]=e[y][x]=1; 那么最大匹配ans/2就是能够覆盖两个房子的天线数，那么剩下的房子，就每一个都必须用一个天线来匹配。 能够覆盖两个房子的天线数： ans/2 单独覆盖一个房子的天线数： 所有的点N-ans 所...
方格分割(DFS搜索算法)
sunlanchang的博客
04-18 1757
6x6的方格，沿着格子的边线剪开成两部分。 要求这两部分的形状完全相同。如图：p1.png, p2.png, p3.png 就是可行的分割法。试计算： 包括这3种分法在内，一共有多少种不同的分割方法。 注意：旋转对称的属于同一种分割法。请提交该整数，不要填写任何多余的内容或说明文字。 从图的中心点开始走一条路径，直至走到图的边界，再将这条边界中心对称到图的另一边，用剪刀沿着这两条边界剪则能够
【学习笔记】手写 Tomcat 三
最新发布
LearnTech_123的博客
09-12 1109
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Java实现随机生成迷宫算法
"Java编程实现迷宫生成游戏，利用深度优先遍历算法" 在Java编程中，创建一个迷宫小游戏可以是一项有趣的挑战。这个项目主要涉及到图的深度优先遍历算法，通过构建一种数据结构来表示迷宫，并设计有效的算法来生成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值