二维坐标,x从小到大排列,y从大到小排列

本文介绍了一种针对二维数组的特殊排序算法,通过将x轴和y轴的数据进行捆绑并转换,实现了x升序y升序的排序效果。该算法首先计算y轴的最大值,并将其余值取补,然后与x轴数据合并成新的数值进行排序。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

目前能想到的最完美的方案,还没得到扩展,仅仅可用于二维数组

重点思路:将xy捆绑到一块排序,因为y是倒叙需要计算下对应正序时的值,也就是拿y组最大值减去当前值,得到x升序y升序组合数组xy,需要考虑到y组位数问题

import java.util.Arrays;


public class Test {
	public static void main(String[] args) {
		Test test = new Test();
		int[][] param = new int[][] { { 3, 20 }, { 1, 9 }, { 5, 8 }, { 2, 1 }, { 3, 6 }, { 2, 1 } };
		int[][] result = test.sortArrayTwoDimension(param);
		for (int i = 0; i < result.length; i++) {
			System.out.println(result[i][0] + "  " + result[i][1]);
		}
	}


	public int[][] sortArrayTwoDimension(int[][] param) {
		int[] x = new int[param.length];
		int[] y = new int[param.length];
		for (int i = 0; i < param.length; i++) {
			int[] temp = param[i];
			x[i] = temp[0];
			y[i] = temp[1];
		}
		
		int maxy = 0;
		for (int i = 0; i < y.length; i++) {
			if (y[i] > maxy) {
				maxy = y[i];
			}
		}
		// 将y数组用最大值-原有值获取倒叙值数组
		int[] sortp = new int[param.length];
		for (int i = 0; i < y.length; i++) {
			sortp[i] = maxy - y[i];
		}
		
		// y数组最大长度
		int ylmax = String.valueOf(maxy).length();
		long[] xy = new long[param.length];
		for (int i = 0;i<x.length;i++) {
			xy[i] = Long.valueOf(String.valueOf(x[i]) + Test.addZeroForNum(String.valueOf(sortp[i]), ylmax));
		}
		
		Arrays.sort(xy);


		int index = 0;
		int[][] result = new int[x.length][2];
		for (int j = 0; j < xy.length; j++) {
			for (int i = 0; i < x.length; i++) {
				if (xy[j] == Long.valueOf(String.valueOf(x[i]) + Test.addZeroForNum(String.valueOf(sortp[i]), ylmax))) {
					result[index] = new int[]{x[i],y[i]};
					index++;
					break;
				}
			}
		}
		return result;
	}
	
	public static String addZeroForNum(String str, int strLength) {
		int strLen = str.length();
		if (strLen < strLength) {
			while (strLen < strLength) {
				StringBuffer sb = new StringBuffer();
				sb.append("0").append(str);
				str = sb.toString();
				strLen = str.length();
			}
		}
		return str;
	}
}

以下是一个Python程序,可以实现这个功能: ```python matrix = [[1, 3, 5], [2, 4, 7], [6, 8, 9]] # 3阶矩阵,可以根据需要修改 def find_longest_sequence(matrix): longest_sequence = [] # 最长的序列 for i in range(len(matrix)): for j in range(len(matrix[0])): sequence = [] # 当前位置开始的序列 visited = [[False] * len(matrix[0]) for _ in range(len(matrix))] # 是否访问过 _dfs(matrix, i, j, sequence, visited) # 深度优先搜索 if len(sequence) > len(longest_sequence): longest_sequence = sequence return longest_sequence def _dfs(matrix, i, j, sequence, visited): visited[i][j] = True sequence.append(matrix[i][j]) if len(sequence) == len(matrix) * len(matrix[0]): # 找到了一个完整的序列 return for x, y in _get_neighbors(matrix, i, j): if not visited[x][y] and matrix[x][y] > matrix[i][j]: _dfs(matrix, x, y, sequence, visited) sequence.pop() # 回溯 def _get_neighbors(matrix, i, j): neighbors = [] if i > 0: neighbors.append((i - 1, j)) if i < len(matrix) - 1: neighbors.append((i + 1, j)) if j > 0: neighbors.append((i, j - 1)) if j < len(matrix[0]) - 1: neighbors.append((i, j + 1)) return neighbors longest_sequence = find_longest_sequence(matrix) print(longest_sequence) ``` 程序首先定义了一个3阶矩阵,可以根据需要修改。然后定义了一个`find_longest_sequence`函数,它使用两层循环遍历矩阵的每一个位置,并调用`_dfs`函数进行深度优先搜索。`_dfs`函数将当前位置加入序列,并继续向相邻的未访问过的元素搜索。如果找到了一个完整的序列,就返回。最后,程序输出最长的序列。 在这个程序中,我们使用了一个二维布尔数组`visited`来记录每个位置是否访问过,避免重复搜索。我们还使用了一个`_get_neighbors`函数来获取一个位置的相邻元素。这个函数返回一个列表,包含了四个相邻位置的坐标
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值