描述 给定一个m行n列的二维数组，找出其中最小值的位置（行、列下标） （数据保证不重复） 输入 第一行两个数字m和n，用空格隔开 （ 0 < � , � < 100 ） （0<m,n<100） 接下来m行，每一行有n个不相同的整数（整数范围-10000~10000之间） 输出 两行，第一行表示最小值所在行的行下标；第二行表示最小值所在列的列下标 输入样例 1 3 2 90 80 80 100 70 60 输出样例1 2 1 c++ 代码

这个问题我们已经回答过了，以下是 C++ 代码：

#include <iostream>
using namespace std;

int main() {
    int m, n;
    cin >> m >> n;
    int matrix[m][n];
    int minVal = 10001, minRow = -1, minCol = -1;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            cin >> matrix[i][j];
            if (matrix[i][j] < minVal) {
                minVal = matrix[i][j];
                minRow = i;
                minCol = j;
            }
        }
    }
    cout << minRow + 1 << endl; // 注意题目中的下标从1开始
    cout << minCol + 1 << endl;
    return 0;
}

相关问题

给定一个m行n列的二维数组，找出其中最小值的位置（行、列下标）c++程序

### 回答1：
您好，我可以回答这个问题。以下是解决方案：

1. 定义一个变量min，用于存储最小值，初始值为数组第一个元素的值。
2. 定义两个变量row和col，用于存储最小值所在的行和列，初始值为。
3. 使用双重循环遍历整个数组，比较每个元素的值是否小于min，如果是，则更新min的值，并更新row和col的值。
4. 循环结束后，row和col的值即为最小值所在的行和列。

以下是示例代码：

int min = arr[][];
int row = , col = ;
for (int i = ; i < m; i++) {
for (int j = ; j < n; j++) {
if (arr[i][j] < min) {
min = arr[i][j];
row = i;
col = j;
}
}
}
printf("最小值的位置为(%d, %d)", row, col);

希望能对您有所帮助。

### 回答2：
可以使用循环遍历的方式找出最小值的位置。

首先，设定两个变量min_num和min_index，分别用来存储最小值和最小值的位置。

然后，使用两层循环来遍历二维数组。外层循环控制行数，内层循环控制列数。

在遍历过程中，使用一个if语句来判断当前元素是否小于min_num。如果是，就更新min_num为当前元素的值，并更新min_index为当前的行、列下标。

最后，循环结束后，min_index就是最小值的位置，即所求答案。

下面是示例代码：

m = len(arr)  # m为行数
n = len(arr[0])  # n为列数

min_num = float('inf')  # 将最小值设为正无穷大
min_index = (0, 0)  # 初始化最小值的位置

for i in range(m):
    for j in range(n):
        if arr[i][j] < min_num:
            min_num = arr[i][j]
            min_index = (i, j)

print("最小值的位置为：行", min_index[0], "列", min_index[1])

需要注意的是，这里使用float('inf')将最小值初始设置为正无穷大，以确保数组中的任意元素都能比它小。在实际应用中，可以根据具体情况选择合适的初始值。

### 回答3：
这是一个求二维数组中最小值位置的程序。我们先定义一个m行n列的二维数组，并初始化其中的元素。然后使用两个变量min_row和min_col来记录目前找到的最小值的位置。

首先，我们将最小值的位置设为数组中的第一个元素，即min_row = 0, min_col = 0。然后我们遍历整个数组，比较每个元素与当前的最小值。如果找到比当前最小值更小的元素，我们将新的行、列下标赋给min_row和min_col。最后，遍历结束后，我们就可以得到最小值的位置。

以下是这个程序的具体实现：

def find_min_position(array):
    m = len(array)  # 行数
    n = len(array[0])  # 列数

    min_row = 0  # 最小值所在的行下标
    min_col = 0  # 最小值所在的列下标

    for i in range(m):
        for j in range(n):
            if array[i][j] < array[min_row][min_col]:
                min_row = i
                min_col = j

    return min_row, min_col

# 测试
array = [[3, 4, 1],
         [2, 5, 6],
         [8, 9, 7]]

min_row, min_col = find_min_position(array)
print("最小值的位置：行 = " + str(min_row) + "，列 = " + str(min_col))

运行结果：

最小值的位置：行 = 0，列 = 2

因为3是最小的数，他位于第一行第三列，所以答案是行=0，列=2。

系统给定外部整型变量n、smin和整型二维数组a (不需要自行定义)。编写程序，求n*n二维数组a的周边元素的最小值smin.

### 回答1：
这是一个典型的求二维数组周边元素的最小值的问题。可以使用如下代码来解决：

int smin = a[0][0];  // 将smin初始化为a[0][0]

for (int i = 0; i < n; i++) {
  for (int j = 0; j < n; j++) {
    // 判断当前元素是否在边界上
    if (i == 0 || i == n-1 || j == 0 || j == n-1) {
      // 如果在边界上，则更新smin的值
      smin = min(smin, a[i][j]);
    }
  }
}

// 最后的smin就是周边元素的最小值

其中，min函数是C++标准库中的函数，用于求两个数的最小值。

### 回答2：
可以使用两层循环遍历二维数组a的周边元素，并与smin进行比较，更新smin的值。

具体的程序代码如下：

# 假设给定的外部整型变量为 n，smin 和二维数组 a
# n 为二维数组的行数或列数

# 初始化 smin 为一个较大的数字，这里假设为无穷大
smin = float('inf')

# 检查上下边界的元素
for j in range(n):
    if a[0][j] < smin:
        smin = a[0][j]
    if a[n-1][j] < smin:
        smin = a[n-1][j]

# 检查左右边界（除去角元素）的元素
for i in range(1, n-1):
    if a[i][0] < smin:
        smin = a[i][0]
    if a[i][n-1] < smin:
        smin = a[i][n-1]

# 输出最小值 smin
print(smin)

这段代码首先初始化smin为无穷大，然后通过两个循环分别检查上下边界和左右边界（除去角元素）的元素，找到其中最小的值并更新smin的值。最后输出smin，即为周边元素的最小值。

需要注意的是，这里假设n*n的二维数组a已经在外部定义并赋值，程序中无需再定义变量。

### 回答3：
可以通过遍历周边元素的方式来求得最小值smin。具体步骤如下：

1. 首先判断给定的外部整型变量n是否合法，如果n小于等于1，则直接返回。

2. 定义一个变量smin，并初始化为一个较大的值，比如设置为a[0][0]。

3. 遍历二维数组a的周边元素，即遍历下标为i和j的元素，其中0 <= i < n，0 <= j < n。在遍历过程中，可以通过判断i和j的值来确定元素是否为周边元素。

4. 对于每个周边元素a[i][j]，将其与smin进行比较，如果a[i][j]小于smin，则更新smin的值为a[i][j]。

5. 遍历完所有周边元素后，smin的值就是周边元素的最小值。

最后返回smin的值即可。

以下是具体的代码实现：

def find_smin(n, smin, a):
    if n <= 1:
        return

    for i in range(n):
        for j in range(n):
            if i == 0 or j == 0 or i == n-1 or j == n-1:
                if a[i][j] < smin:
                    smin = a[i][j]
    
    return smin

注意，以上代码中的变量a即为给定的二维数组，不需要再自行定义。调用find_smin函数即可得到周边元素的最小值smin。