如何恢复对角读取的 NxN 矩阵?

发布于 2024-10-17 18:09:44 字数 409 浏览 0 评论 0原文

假设如果我有一个二维数组

,我得到一个数组“char input[N][N]”,它被某人对角读取。

我的目标是从对角读取的“char input[N][N]”数组中重现原始数组“char input_original[N][N]”

对角读取后,我的输入是,

adb

ceg -------- ----------->矩阵 A

h fi

现在我想将其设为

abc

def ------------------->矩阵 B (input_original array)

ghi

其中矩阵 A 是矩阵 B 的对角读取输出( a db ceg hf i --> 将其作为矩阵)

欢迎所有建议。

Suppose if am having one 2D array

I got an array , 'char input[N][N]' which was read diagonally by someone.

My aim is reproduce the original array 'char input_original[N][N]' from the diagonally read 'char input[N][N]' array

After reading diagonally , my input is ,

a d b

c e g -------------------> matrix A

h f i

and now i want to make it as

a b c

d e f -------------------> matrix B (input_original array)

g h i

Where the matrix A is the diagonal read output( a db ceg hf i --> made this as a matrix) of matrix B

All suggestions are welcome.

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(1

烏雲後面有陽光 2024-10-24 18:09:44

如果矩阵是对角线的,我只会计算通过矩阵的“路径”,例如

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

,您按照读取索引的顺序存储索引。完成此操作后,您可以根据这些索引填充矩阵。

所以这种情况下最困难的就是如何计算路径。您可以按如下方式执行此操作: 首先,我们认识到该路径仅由四个方向组成:

  • 右 (R)
  • 右上 (UR)
  • 下 (D)
  • 左下 (DL)

此外,我们认识到只有某些方向顺序是允许:

  • R-DL
  • DL-DL
  • DL-D
  • DL-R
  • D-UR
  • UR-UR
  • UR-R

使用这些知识计算路径是没有问题的:我们只需要存储最后一个方向和当前位置。然后,我们必须按以下方式计算下一个方向:

  • 如果最后一个方向是 UR,我们尝试 UR,如果不可能,我们走 R。
  • 如果最后一个方向是 DL,我们尝试 DL,如果不可能,我们走D,如果这也不可能,我们走R。

我希望我没有搞砸任何事情,但我认为这是一个非常实用的方法。

I would just compute the "path" through your matrix if it's diagonal, e.g.

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

This is, you store the indices in the order you read them in. After you've done this, you can just fill your matrix according to these indices.

So the most difficult stuff in this case is how to compute the path. You can do this as follows: First of all, we recognize that the path conists exclusively of four directions:

  • right (R)
  • right up (UR)
  • down (D)
  • down left (DL)

Furthermore we recognize that only some orders of directions are allowed:

  • R-DL
  • DL-DL
  • DL-D
  • DL-R
  • D-UR
  • UR-UR
  • UR-R

Using this knowledge it is no problem to compute the path: We just have to store the last direction and the current position. Then, we have to compute the next direction the following way:

  • if the last direction was UR, we try UR, and if that's not possible, we walk R.
  • if the last direction was DL, we try DL, and if that's not possible, we walk D, if that's also not possible, we walk R.

I hope I didn't mess anything up, but I think that's quite a practical way to do it.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文