在螺旋矩阵中找到指定索引处的元素

给定两个整数i和j ，任务是打印第i * j^个矩阵元素，该矩阵元素可以通过以下螺旋方式填充矩阵而获得：

螺旋网格表示图1

例子：

Input: i = 3, j = 4
Output: 12
Explanation:
i = 3, j = 4 and grid[3][4] = 12

Input: i = 5, j = 5
Output: 21
Explanation:
i = 5, j = 5 grid[5][5] = 21

方法：在问题中，可以观察到，当i为偶数时，网格中的第一个数字是i ² (第二行中2 ² = 4)，而当i是奇数时，网格中的第一个数字是(i-1) ) ² +1 ((第3行中的(3-1) ² +1 = 5))。同样，当j为奇数时，网格中的第一个数字为j ² (第3列中的3 ² = 9)，当j为偶数时，网格中的第一个数字为(j-1) ² +1 ((4-1) ² +1 = 10(在第4列中)。因此，每一行都以i ²或(i-1) ² +1开头，每列以j ²或(j-1) ² +1开头。

该问题可以分为以下几种情况：

• 情况1：i = j
  注意，网格的对角元素可以用公式i ² –(i-1)或j ² –(j – 1)表示。
• 情况2：i> j
  • 情况1：我什至
    在这种情况下，行i的第一个数将是i ² 。现在，通过从行的第一个数字中减去(j – 1) ，计算出给定索引处的值。因此公式将为i ² –(j-1) 。
  • 情况2：我很奇怪
    在这种情况下，第i行的第一个数将是(i – 1) ² +1 。现在，通过在行的第一个数字上加上(j – 1)，可以计算给定索引处的值。因此公式为(i – 1) ² +1 +(j – 1) 。
• 情况3：i
  • 情况1：j是偶数
    在这种情况下，列j的第一个数字将为(j – 1) ² +1 。现在，通过在列的第一个数字上加上(i – 1) ，计算给定索引处的值。因此公式将为(j – 1) ² +1 +(i – 1) 。
  • 情况2：j为奇数
    在这种情况下，列j的第一个数字将为j ² 。现在，通过从列的第一个数字中减去(i – 1) ，计算出给定索引处的值。因此公式将为j ² +1-(i-1) 。

请按照以下步骤解决问题：

1. 检查i是否等于j并打印i * i –(i – 1) 。
2. 如果i大于j ：
   1. 如果我什至打印i * i –(j – 1) 。
   2. 否则，打印( i – 1)*(i – 1)+ 1 +(j – 1) 。
3. 如果j大于i ：
   1. 如果j偶数打印(j – 1)*(j – 1)+ 1 +(i – 1) 。
   2. 否则，打印j * j –(i – 1) 。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to the find
// element at (i, j) index
int findInGrid(int i, int j)
{
    if (i == j)
        return (i * i - (i - 1));
 
    else if (i > j) {
        if (i % 2 == 0)
            return i * i - (j - 1);
        else
            return (i - 1) * (i - 1) + 1 + (j - 1);
    }
 
    else {
        if (j % 2 == 0)
            return (j - 1) * (j - 1) + 1 + (i - 1);
        else
            return j * j - (i - 1);
    }
}
 
// Driver Code
int main()
{
 
    int i = 3, j = 4;
 
    // Function Call
    cout << findInGrid(i, j);
 
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
 
class GFG{
 
// Function to the find
// element at (i, j) index
static int findInGrid(int i, int j)
{
    if (i == j)
        return (i * i - (i - 1));
 
    else if (i > j)
    {
        if (i % 2 == 0)
            return i * i - (j - 1);
        else
            return (i - 1) * (i - 1) +
                         1 + (j - 1);
    }
 
    else
    {
        if (j % 2 == 0)
            return (j - 1) * (j - 1) +
                         1 + (i - 1);
        else
            return j * j - (i - 1);
    }
}
 
// Driver Code
public static void main(String[] args)
{
    int i = 3, j = 4;
 
    // Function Call
    System.out.println(findInGrid(i, j));
}
}
 
// This code is contributed by Dharanendra L V

Python3

# Python3 program for the above approach
 
# Function to the find
# element at(i, j) index
def findInGrid(i, j):
     
    if (i == j):
        return (i * i - (i - 1))
 
    elif (i > j):
        if (i % 2 == 0):
            return i * i - (j - 1)
        else :
            return ((i - 1) * (i - 1) +
                          1 + (j - 1))
 
    else:
        if (j % 2 == 0):
            return ((j - 1) * (j - 1) +
                          1 + (i - 1))
        else:
            return j * j - (i - 1)
 
# Driver Code
i = 3
j = 4
 
# Function Call
print(findInGrid(i, j))
 
# This code is contributed by Dharanendra L V

C#

// C# program for the above approach
using System;
 
class GFG{
 
// Function to the find
// element at (i, j) index
static int findInGrid(int i, int j)
{
    if (i == j)
        return (i * i - (i - 1));
 
    else if (i > j)
    {
        if (i % 2 == 0)
            return i * i - (j - 1);
        else
            return (i - 1) * (i - 1) +
                         1 + (j - 1);
    }
 
    else
    {
        if (j % 2 == 0)
            return (j - 1) * (j - 1) +
                         1 + (i - 1);
        else
            return j * j - (i - 1);
    }
}
 
// Driver Code
static public void Main()
{
    int i = 3, j = 4;
     
    // Function Call
    Console.WriteLine(findInGrid(i, j));
}
}
 
// This code is contributed by Dharanendra L V

输出

12

时间复杂度： O(1)
辅助空间： O(1)