Как найти наименьшее число в матрице - Исправление недочетов и поиск решений вместе с Examum.ru

Дана квадратная матрица, отсортированная по строкам и столбцам, и положительное целое число k, найдите k-е наименьшее число в матрице.

Например,

Input:
mat = [
    [-3, 1, 3],
    [-2, 2, 4],
    [1, 3, 5]
]
k = 6
Output: 3
Explanation: The elements of the matrix in increasing order, are [-3, -2, 1, 1, 2, 3, 3, 4, 5]. The sixth smallest element is 3.

Input:
mat = [
[1, 3],
[2, 4]
]
k = 5
Output: None
Explanation: k is more than the number of elements in the matrix.

1. Использование минимальной кучи

Идея состоит в том, чтобы построить мин-куча из всех элементов первой строки. Затем запустите цикл, в котором на каждой итерации мы удаляем корень из минимальной кучи и заменяем его следующим элементом из того же столбца матрицы. После k операции извлечения были выполнены в минимальной куче, последний извлеченный элемент содержит k-й наименьший элемент.

Алгоритм может быть реализован следующим образом на C++, Java и Python. Обратите внимание, что мы также можем построить мини-кучу из элементов первого столбца и заменить корень следующим элементом из той же строки матрицы. Остальная логика остается прежней.

C++

#include <iostream>

#include <vector>

#include <queue>

#include <climits>

using namespace std;

// Структура данных для хранения узла кучи

struct Tuple

{

int i, j, value;

};

// Объект сравнения, который будет использоваться для упорядочивания минимальной кучи

struct comp

{

bool operator()(const Tuple &lhs, const Tuple &rhs) const {

return lhs.value > rhs.value;

}

};

// Функция для возврата k-го наименьшего значения в отсортированной матрице

int findkthSmallestElement(vector<vector<int>> const &mat, int k)

{

// неправильный ввод

if (mat.size() == 0 || k <= 0 ) {

return INT_MIN;

}

// создаем пустую мини-кучу

priority_queue<Tuple, vector<Tuple>, comp> minHeap;

// вставляем все элементы первой строки в min-кучу

for (int j = 0; j < mat.size(); j++) {

minHeap.push({ 0, j, mat[0][j] });

}

// цикл k раз или до тех пор, пока куча не станет пустой

while (k— && !minHeap.empty())

{

// удалить корень из минимальной кучи

Tuple minvalue = minHeap.top();

minHeap.pop();

// если в минимальной куче было выполнено k операций извлечения,

// последний извлеченный элемент содержит k-й наименьший элемент

if (k == 0) {

return minvalue.value;

}

// заменить корень следующим элементом из того же столбца матрицы

if (minvalue.i != mat.size() — 1) {

minHeap.push({ minvalue.i + 1, minvalue.j, mat[minvalue.i + 1][minvalue.j] });

}

// мы достигнем этого места, если k больше, чем количество элементов в матрице

return INT_MIN;

}

int main()

{

vector<vector<int>> mat =

{

{—3, 1, 3},

{—2, 2, 4},

{1, 3, 5}

};

int k = 6;

cout << findkthSmallestElement(mat, k) << endl;

return 0;

}

Скачать Выполнить код

результат:

3

Java

import java.util.PriorityQueue;

// Класс для хранения узла кучи

class Tuple implements Comparable<Tuple>

{

int i, j, value;

public Tuple(int i, int j, int value) {

this.i = i;

this.j = j;

this.value = value;

}

@Override

public int compareTo(Tuple tuple) {

return this.value — tuple.value;

}

class Main

{

// Функция для возврата k-го наименьшего значения в отсортированной матрице

public static int findkthSmallestElement(int[][] mat, int k)

{

// неправильный ввод

if (mat.length == 0 || k <= 0 ) {

return Integer.MIN_VALUE;

}

// создаем пустую мини-кучу

PriorityQueue<Tuple> minHeap = new PriorityQueue<>();

// вставляем все элементы первой строки в min-кучу

for (int j = 0; j < mat.length; j++) {

minHeap.add(new Tuple(0, j, mat[0][j]));

}

// цикл k раз или до тех пор, пока куча не станет пустой

while (k— > 0 && !minHeap.isEmpty())

{

// удалить корень из минимальной кучи

Tuple minvalue = minHeap.poll();

// если в минимальной куче было выполнено k операций извлечения,

// последний извлеченный элемент содержит k-й наименьший элемент

if (k == 0) {

return minvalue.value;

}

// заменить корень следующим элементом из того же столбца матрицы

if (minvalue.i != mat.length — 1) {

minHeap.add(new Tuple(minvalue.i + 1, minvalue.j,

mat[minvalue.i + 1][minvalue.j]));

}

// мы достигнем этого места, если k больше, чем количество элементов в матрице

return Integer.MIN_VALUE;

}

public static void main(String[] args)

{

int[][] mat =

{

{—3, 1, 3},

{—2, 2, 4},

{1, 3, 5}

};

int k = 6;

System.out.println(findkthSmallestElement(mat, k));

}

Скачать Выполнить код

результат:

3

Python

from heapq import heappop, heappush

# Класс для хранения узла кучи

class Tuple:

def __init__(self, i, j, value):

self.i = i

self.j = j

self.value = value

# Переопределить функцию `__lt__()`, чтобы она работала с минимальной кучей.

def __lt__(self, other):

return self.value < other.value

# Функция для возврата k-го наименьшего значения в отсортированной матрице

def findkthSmallestElement(mat, k):

# неверный ввод

if len(mat) == 0 or k <= 0:

return

# создает пустую мини-кучу

minHeap = []

# вставить все элементы первой строки в мини-кучу

for j in range(0, len(mat)):

heappush(minHeap, Tuple(0, j, mat[0][j]))

# цикл k раз или до тех пор, пока куча не станет пустой

while k and minHeap:

k = k — 1

# удалить root из мин-кучи

minvalue = heappop(minHeap)

#, если в минимальной куче было выполнено k операций извлечения,

# последний извлеченный элемент содержит k-й наименьший элемент

if k == 0:

return minvalue.value

# заменить корень следующим элементом из того же столбца матрицы

if minvalue.i != len(mat) — 1:

heappush(minHeap, Tuple(minvalue.i + 1, minvalue.j, mat[minvalue.i + 1][minvalue.j]))

if __name__ == ‘__main__’:

mat = [

[—3, 1, 3],

[—2, 2, 4],

[1, 3, 5]

]

k = 6

print(findkthSmallestElement(mat, k))

Скачать Выполнить код

результат:

3

Временная сложность приведенного выше решения равна O(N²) для N × N матрица и требует O(k) дополнительное пространство для структуры данных кучи.

2. Использование бинарного поиска

Мы можем избежать использования дополнительного пространства, используя алгоритм бинарного поиска. Бинарный поиск обычно работает с линейной структурой данных, которая отсортирована, мы можем изменить ее для работы с матрицей, которая отсортирована как по строкам, так и по столбцам. Начнем с поискового пространства [low, high] куда low а также high изначально указывают на верхний левый и нижний правый углы матрицы соответственно. Затем на каждой итерации цикла бинарного поиска мы определяем среднее значение и подсчитываем элементы в матрице, которые меньше или равны среднему элементу. Мы сужаем поле поиска до [mid+1…high] если счет меньше k; в противном случае мы сужаем его до [low…mid-1]. Цикл завершается, как только low превосходит high, а также low хранит k-е наименьшее значение в матрице.

Ниже приведена реализация C++, Java и Python, основанная на идее:

C++

#include <iostream>

#include <vector>

using namespace std;

// Функция для подсчета элементов в матрице, которые меньше или равны заданному значению

int findLessOrEqual(vector<vector<int>> const &mat, int val)

{

int n = mat.size();

// начинаем с нижнего левого угла матрицы

int i = n—1, j = 0;

int count = 0;

// цикл до тех пор, пока (i, j) не пересечет границу матрицы

while (i >= 0 && j < n)

{

// если текущий элемент больше заданного значения

if (mat[i][j] > val) {

i—; // двигаться вверх (в сторону меньших значений)

}

else {

// если текущий элемент меньше указанного значения,

// тогда все значения над текущим элементом также должны быть меньше

count += (i + 1);

j++; // двигаться вправо (к большим значениям)

}

return count;

}

// Функция для возврата k-го наименьшего значения в отсортированной матрице

int findkthSmallestElement(vector<vector<int>> const &mat, int k)

{

int n = mat.size();

// неправильный ввод

if (n == 0 || k <= 0 ) {

return INT_MIN;

}

// инициализируем low левым верхним элементом матрицы

int low = mat[0][0];

// инициализируем high правым нижним элементом матрицы

int high = mat[n—1][n—1];

// цикл до тех пор, пока пространство поиска не будет исчерпано

while (low <= high)

{

// найти среднее значение в пространстве поиска

int mid = low + ((high — low) >> 1);

// найти количество элементов, которое меньше или равно среднему элементу

int count = findLessOrEqual(mat, mid);

// если count меньше k, k-й наименьший элемент существует в диапазоне [mid+1…high]

if (count < k) {

low = mid + 1;

}

// в противном случае k-й наименьший элемент существует в диапазоне [low…mid-1]

else {

high = mid — 1;

}

return low;

}

int main()

{

vector<vector<int>> mat =

{

{—3, 1, 3},

{—2, 2, 4},

{1, 3, 5}

};

int k = 6;

cout << findkthSmallestElement(mat, k) << endl;

return 0;

}

Скачать Выполнить код

результат:

3

Java

class Main

{

// Функция для подсчета элементов в матрице, которые меньше или равны val

public static int findLessOrEqual(int[][] mat, int val)

{

// начинаем с нижнего левого угла матрицы

int i = mat.length — 1, j = 0;

int count = 0;

// цикл до тех пор, пока (i, j) не пересечет границу матрицы

while (i >= 0 && j < mat.length)

{

// если текущий элемент больше заданного значения

if (mat[i][j] > val) {

i—; // двигаться вверх (в сторону меньших значений)

}

else

{

// если текущий элемент меньше указанного значения,

// тогда все значения над текущим элементом также должны быть меньше

count += (i + 1);

j++; // двигаться вправо (к большим значениям)

}

return count;

}

// Функция для возврата k-го наименьшего значения в отсортированной матрице

public static int findkthSmallestElement(int[][] mat, int k)

{

int n = mat.length;

// неправильный ввод

if (n == 0 || k <= 0 ) {

return Integer.MIN_VALUE;

}

// инициализируем low левым верхним элементом матрицы

int low = mat[0][0];

// инициализируем high правым нижним элементом матрицы

int high = mat[n—1][n—1];

// цикл до тех пор, пока пространство поиска не будет исчерпано

while (low <= high)

{

// найти среднее значение в пространстве поиска

int mid = low + ((high — low) >> 1);

// найти количество элементов, которое меньше или равно среднему элементу

int count = findLessOrEqual(mat, mid);

// если count меньше k, в массиве существует k-й наименьший элемент

// диапазон [средний+1…высокий]

if (count < k) {

low = mid + 1;

}

// в противном случае k-й наименьший элемент существует в диапазоне [low…mid-1]

else {

high = mid — 1;

}

return low;

}

public static void main(String[] args)

{

{—3, 1, 3},

{—2, 2, 4},

{1, 3, 5}

};

int k = 6;

System.out.println(findkthSmallestElement(mat, k));

}

Скачать Выполнить код

результат:

3

Python

# Функция для подсчета элементов в матрице, которые меньше или равны заданному значению

def findLessOrEqual(mat, val):

# начинается в нижнем левом углу матрицы

i, j = len(mat)—1, 0

count = 0

Цикл # до тех пор, пока (i, j) не пересечет границу матрицы

while i >= 0 and j < len(mat):

#, если текущий элемент больше заданного значения

if mat[i][j] > val:

i = i — 1 # двигаться вверх (в сторону меньших значений)

else:

#, если текущий элемент меньше указанного значения,

#, то все значения над текущим элементом также должны быть меньше

count += (i + 1)

j = j + 1 # двигаться вправо (к большим значениям)

return count

# Функция для возврата k-го наименьшего значения в отсортированной матрице

def findkthSmallestElement(mat, k):

n = len(mat)

# неверный ввод

if n == 0 or k <= 0:

return

# инициализирует low и high с верхним левым и нижним правым элементами матрицы

low, high = mat[0][0], mat[n—1][n—1]

# Цикл # до тех пор, пока пространство поиска не будет исчерпано

while low <= high:

# найти среднее значение в пространстве поиска

mid = low + ((high — low) >> 1)

# найти количество элементов, которое меньше или равно среднему элементу

count = findLessOrEqual(mat, mid)

#, если count меньше k, k-й наименьший элемент существует в диапазоне [mid+1…high]

if count < k:

low = mid + 1

# в противном случае k-й наименьший элемент существует в диапазоне [low…mid-1]

else:

high = mid — 1

return low

if __name__ == ‘__main__’:

mat = [

[—3, 1, 3],

[—2, 2, 4],

[1, 3, 5]

]

k = 6

print(findkthSmallestElement(mat, k))

Скачать Выполнить код

результат:

3

Временная сложность приведенного выше решения равна O(N.log(N²)) для N × N матрица и не требует дополнительного места.

Спасибо за чтение.

Пожалуйста, используйте наш онлайн-компилятор размещать код в комментариях, используя C, C++, Java, Python, JavaScript, C#, PHP и многие другие популярные языки программирования.

Как мы? Порекомендуйте нас своим друзьям и помогите нам расти. Удачного кодирования

Источник

Given a matrix, the task is to find the minimum element of each row and each column.

Examples:

Input: [1, 2, 3]
        [1, 4, 9]
        [76, 34, 21]
Output: Minimum element of each row is {1, 1, 21}
Minimum element of each column is {1, 2, 3}

Input: [1, 2, 3, 21]
       [12, 1, 65, 9]
       [11, 56, 34, 2]
Output: Minimum element of each row is {1, 1, 2}
Minimum element of each column is {1, 2, 3 , 2}

Approach: The idea is to run the loop for no_of_rows. Check each element inside the row and find for the minimum element. Finally, print the element. Similarly, check each element inside the column and find for the minimum element. Finally, print the element.

Below is the implementation of the above approach:

C++

#include<bits/stdc++.h>

using namespace std;

const int MAX = 100;

void smallestInRow(int mat[][MAX], int n, int m)

{

cout << " { ";

for (int i = 0; i < n; i++) {

int minm = mat[i][0];

for (int j = 1; j < m; j++) {

if (mat[i][j] < minm)

minm = mat[i][j];

}

cout << minm << ", ";

}

cout << "}";

}

void smallestInCol(int mat[][MAX], int n, int m)

{

cout << " { ";

for (int i = 0; i < m; i++) {

int minm = mat[0][i];

for (int j = 1; j < n; j++) {

if (mat[j][i] < minm)

minm = mat[j][i];

}

cout << minm << ", ";

}

cout << "}";

}

int main()

{

int n = 3, m = 3;

int mat[][MAX] = { { 2, 1, 7 },

{ 3, 7, 2 },

{ 5, 4, 9 } };

cout << "Minimum element of each row is ";

smallestInRow(mat, n, m);

cout << "nMinimum element of each column is ";

smallestInCol(mat, n, m);

return 0;

}

C

#include <stdio.h>

#define MAX 100

void smallestInRow(int mat[][MAX], int n, int m)

{

printf(" { ");

for (int i = 0; i < n; i++) {

int minm = mat[i][0];

for (int j = 1; j < m; j++) {

if (mat[i][j] < minm)

minm = mat[i][j];

}

printf("%d, ",minm);

}

printf("}");

}

void smallestInCol(int mat[][MAX], int n, int m)

{

printf(" { ");

for (int i = 0; i < m; i++) {

int minm = mat[0][i];

for (int j = 1; j < n; j++) {

if (mat[j][i] < minm)

minm = mat[j][i];

}

printf("%d, ",minm);

}

printf("}");

}

int main()

{

int n = 3, m = 3;

int mat[][MAX] = { { 2, 1, 7 },

{ 3, 7, 2 },

{ 5, 4, 9 } };

printf("Minimum element of each row is ");

smallestInRow(mat, n, m);

printf("nMinimum element of each column is ");

smallestInCol(mat, n, m);

return 0;

}

Java

public class GFG {

final static int MAX = 100;

static void smallestInRow(int mat[][], int n, int m) {

System.out.print(" { ");

for (int i = 0; i < n; i++) {

int minm = mat[i][0];

for (int j = 1; j < m; j++) {

if (mat[i][j] < minm) {

minm = mat[i][j];

}

System.out.print(minm + ", ");

}

System.out.println("}");

}

static void smallestInCol(int mat[][], int n, int m) {

System.out.print(" { ");

for (int i = 0; i < m; i++) {

int minm = mat[0][i];

for (int j = 1; j < n; j++) {

if (mat[j][i] < minm) {

minm = mat[j][i];

}

System.out.print(minm + ", ");

}

System.out.print("}");

}

public static void main(String args[]) {

int n = 3, m = 3;

int mat[][] = {{2, 1, 7},

{3, 7, 2},

{5, 4, 9}};

System.out.print("Minimum element of each row is ");

smallestInRow(mat, n, m);

System.out.print("nMinimum element of each column is ");

smallestInCol(mat, n, m);

}

Python3

MAX = 100

def smallestInRow(mat, n, m):

print("{", end = "")

for i in range(n):

minm = mat[i][0]

for j in range(1, m, 1):

if (mat[i][j] < minm):

minm = mat[i][j]

print(minm, end = ",")

print("}")

def smallestInCol(mat, n, m):

print("{", end = "")

for i in range(m):

minm = mat[0][i]

for j in range(1, n, 1):

if (mat[j][i] < minm):

minm = mat[j][i]

print(minm, end = ",")

print("}")

if __name__ == '__main__':

n = 3

m = 3

mat = [[2, 1, 7],

[3, 7, 2 ],

[ 5, 4, 9 ]];

print("Minimum element of each row is",

end = " ")

smallestInRow(mat, n, m)

print("Minimum element of each column is",

end = " ")

smallestInCol(mat, n, m)

C#

using System;

class GFG

{

readonly static int MAX = 100;

static void smallestInRow(int [,]mat,

int n, int m)

{

Console.Write(" { ");

for (int i = 0; i < n; i++)

{

int minm = mat[i, 0];

for (int j = 1; j < m; j++)

{

if (mat[i, j] < minm)

{

minm = mat[i, j];

}

Console.Write(minm + ", ");

}

Console.WriteLine("}");

}

static void smallestInCol(int [,]mat,

int n, int m)

{

Console.Write(" { ");

for (int i = 0; i < m; i++)

{

int minm = mat[0, i];

for (int j = 1; j < n; j++)

{

if (mat[j, i] < minm)

{

minm = mat[j, i];

}

Console.Write(minm + ", ");

}

Console.Write("}");

}

public static void Main()

{

int n = 3, m = 3;

int [,]mat = {{2, 1, 7},

{3, 7, 2},

{5, 4, 9}};

Console.Write("Minimum element of " +

"each row is ");

smallestInRow(mat, n, m);

Console.Write("nMinimum element of " +

"each column is ");

smallestInCol(mat, n, m);

}

PHP

<?php

$MAX = 100;

function smallestInRow(&$mat, $n, $m)

{

echo " { ";

for ($i = 0; $i < $n; $i++)

{

$minm = $mat[$i][0];

for ($j = 1; $j < $m; $j++)

{

if ($mat[$i][$j] < $minm)

$minm = $mat[$i][$j];

}

echo $minm . ", ";

}

echo "}";

}

function smallestInCol(&$mat, $n, $m)

{

echo " { ";

for ($i = 0; $i < $m; $i++)

{

$minm = $mat[0][$i];

for ($j = 1; $j < $n; $j++)

{

if ($mat[$j][$i] < $minm)

$minm = $mat[$j][$i];

}

echo $minm . ", ";

}

echo "}";

}

$n = 3;

$m = 3;

$mat = array(array( 2, 1, 7 ),

array( 3, 7, 2 ),

array( 5, 4, 9 ));

echo "Minimum element of each row is ";

smallestInRow($mat, $n, $m);

echo "nMinimum element of each column is ";

smallestInCol($mat, $n, $m);

?>

Javascript

<script>

let MAX = 100;

function smallestInRow(mat,n,m) {

document.write(" { ");

for (let i = 0; i < n; i++) {

let minm = mat[i][0];

for (let j = 1; j < m; j++) {

if (mat[i][j] < minm) {

minm = mat[i][j];

}

document.write(minm + ", ");

}

document.write("}"+"<br>");

}

function smallestInCol(mat,n,m) {

document.write(" { ");

for (let i = 0; i < m; i++) {

let minm = mat[0][i];

for (let j = 1; j < n; j++) {

if (mat[j][i] < minm) {

minm = mat[j][i];

}

document.write(minm + ", ");

}

document.write("}");

}

let n = 3, m = 3;

let mat = [[2, 1, 7],

[3, 7, 2],

[5, 4, 9]];

document.write("Minimum element of each row is ");

smallestInRow(mat, n, m);

document.write("nMinimum element of each column is ");

smallestInCol(mat, n, m);

</script>

Output

Minimum element of each row is  { 1, 2, 4, }
Minimum element of each column is  { 2, 1, 2, }

Complexity Analysis:

Time complexity: O(n*m), as we are using nested for loops to traverse the Matrix.
Auxiliary Space: O(1), as we are not using any extra space.

Last Updated :
09 Sep, 2022

Like Article

Save Article

Источник

0 / 0 / 0

Регистрация: 08.04.2020

Сообщений: 4

В матрице найти наименьшее число

08.04.2020, 17:23. Показов 2464. Ответов 1

Дана таблица чисел, состоящая из N строк по M чисел в каждой. Все числа в таблице — натуральные, не превышающие 1000.
Требуется найти наименьшее число в этой таблице.
Входные данные
Во входном файле записано сначала число N — количество строк,
а затем число M — количество столбцом таблицы (1<=N<=100, 1<=M<=100).
Далее идет сама таблица.

Выходные данные
В выходной файл выведите наименьшее число, которое встречается в таблице.

Пример входного файла
3 4
6 4 10 4
3 7 5 7
6 3 4 3

Пример выходного файла
3

zss

Модератор

13104 / 10376 / 6207

Регистрация: 18.12.2011

Сообщений: 27,755

08.04.2020, 18:13

Берем образец
Образцы (шаблоны) программ для типовых задач
Заменяем функцию

C++

//
// пример обработки матрицы -  наименьшее число, которое встречается в таблице
//
void Process( int ** M,int *Sum, size_t n, size_t m ) {
    int S=M[0][0];
    for ( size_t i = 0; i < n; ++i ) {
        for ( size_t j = 0; j < m; ++j ) {
            if(S > M[i][j];
                S = M[i][j];
        }
    }
    *Sum=S;
}

И небольшая правка в main

C++

int main()
{
    setlocale( LC_ALL, "Rus" ); // установление русской локали (windows)
 
    size_t n, m;
 
    // вводим размерность матрицы
    std::cout << "Введите количество строк матрицы: ";
    std::cin >> n;
    std::cout << "Введите количество столбцов матрицы: ";
    std::cin >> m;
 
    // выделяем память под матрицу
    int ** A = Create( n, m );
 
    // ввод матрицы
    Input( A, n, m );
    // заполнение случайными числами (вместо ввода)
    //FillRandomNumbers(A,n,m);
 
    // обработка матрицы
    int S;
    Process( A, &S, n, m );
 
    // вывод результата
    //for(size_t i=0;i<n;i++) 
    std::cout<<"Minimum=" << S;
    std::cout<<std::endl;
 
    // Вывод матрицы
    //Print(A,n,m);
 
    // освобождаем память, выделенную под матрицу и вектор
    //delete[] S;
    Free( A, n );
 
    // ждём нажатия клавиши перед выходом из приложения (windows)
    //system( "pause" );
 
    return 0;
}

IT_Exp

Эксперт

87844 / 49110 / 22898

Регистрация: 17.06.2006

Сообщений: 92,604

08.04.2020, 18:13

Помогаю со студенческими работами здесь

в матрице найти наименьшее число b, обладающее свойством
хотя бы в одной строке все элементы не превышают b
Пожалуйста, помогите написать программу

Найти наименьшее и наибольшее значение в матрице
найти наименьшее и наибольшее значение двумерного массива

Найти натуральное наименьшее число n, факториал которого превышает число 4000
Написать программу для решения следующей задачи,используя,по крайней мере, два вида циклов. Найти…

Найти наименьшее число, делящееся на заданное число, и оканчивающееся на заданную цифру
найти наименьшее число, которое делится на заданное пользователем число N, при этом оканчивается на…

Найти в первом стеке максимальное число, а во втором — наименьшее число
даны два стека, в каждом из которых находится по 10 различных чисел. Найти в первом стеке…

Найти наименьшее число, в результате обработки которого автомат выдаст заданное число
Задача такая

Андрей готовился к ЕГЭ по информатике и встретил в демо-версии ЕГЭ 2015 года такую…

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:

Источник

Перейти к содержанию

Индексы минимальных элементов матрицы

Просмотров 3.8к. Обновлено 15 октября 2021

Вывести на экран индексы всех минимальных элементов матрицы.

Эта задача отличается от поиска минимума тем, что нужно найти и вывести на экран не само минимальное значение, а его индексы (позицию, положение в матрице). Кроме того, минимальных (но равных между собой) значений в массиве может быть несколько. Следовательно, разумно вывести индексы всех минимальных элементов.

Задача складывается из двух подзадач, которые должны быть решены последовательно:

Поиск минимума в массиве (в данном случае двумерном).
Поиск элементов, равных ранее найденному минимуму.

Найденное минимальное значение должно быть сохранено в переменной (например, minimum). Однако можно было бы сохранять не само значение, а индекс элемента массива. Но поскольку мы имеем дело с матрицей, то пришлось бы сохранять два числа (номер строки и номер столбца).

Алгоритм поиска минимального значения:

Присвоить minimum максимально возможное (или больше) значение для исследуемого массива.
Перебрать элементы матрицы (используя конструкцию вложенного цикла). Каждый элемент сравнивать со значением minimum. Если очередной элемент меньше значения minimuma, то следует присвоить значение текущего элемента переменной minimum.

Алгоритм определения позиций всех минимальных элементов матрицы:

Снова перебираем элементы матрицы.
Сравниваем каждый элемент со значением minimum.
Если они равны между собой, то выводим индексы текущего элемента на экран. (Индексы текущего элемента — это значения счетчиков первого и второго циклов.)

Примечания:

Ниже в решениях задачи поиска индексов минимальных элементов на языках программирования поиск минимального значения выполняется в том же цикле, что и заполнение матрицы.
Если индексация массива начинается с нуля, то лучше при выводе индексов увеличивать их на единицу. Так будет более ясно, где находится элемент.

Pascal



const N = 5; M = 7;

var

    mx: array[1..N,1..M] of integer;

    min: integer;

    i, j: byte;

begin

    min := MAXINT;

    randomize;

    for i:=1 to N do begin

        for j:=1 to M do begin

            mx[i,j] := random(50) - 25;

            write(mx[i,j]:4);

            if mx[i,j] < min then min:=mx[i,j];

        end;

        writeln;

    end;

    writeln('Минимальное значение: ', min);

    for i:=1 to N do 

        for j:=1 to M do

            if mx[i,j] = min then

                writeln('строка: ', i, '; столбец: ', j);

end.





 -19   6   3  18 -12  -3  24

  -4  15  -6  19 -15  -1   4

   6  -9 -12  23  -3   3 -11

   5   0 -11  -4 -19  -6   1

  17  20  -1   6  17  -1  15

Минимальное значение: -19

строка: 1; столбец: 1

строка: 4; столбец: 5

Язык Си



#include < stdio.h>

#define M 7

#define N 5

main() {

    int a[N][M];

    int min, i, j;

    srand(time(NULL));

    min = 25;

    for (i=0; i< N; i++) {

        for (j=0; j< M; j++) {

            a[i][j] = rand() % 50 - 25;

            printf("%5d", a[i][j]);

            if (min > a[i][j]) min = a[i][j];

        }

        printf("n");

    }

    printf("%dn", min);

    for (i=0; i< N; i++) {

        for (j=0; j< M; j++) {

            if (min == a[i][j]) 

                printf("row: %d, col: %dn", i+1, j+1);

        }

    }

}

Python

индекс минимального элемента массива python



from random import random

M = 7

N = 5

a = []

for i in range(N):

    b = []

    for j in range(M):

        b.append(int(random()*50) - 25)

        print("%4d" % b[j], end='')

    a.append(b)

    print()

min_mx = 25

for i in range(N):

    min_i = min(a[i])

    if min_i < min_mx:

        min_mx = min_i

print(min_mx)

for i in range(N):

    for j in range(M):

        if min_mx == a[i][j]:

            print('Row: %d, col: %d' % (i+1,j+1))





Пример выполнения:

 -18 -23  -8  17  12   4 -22

  16 -10 -18   6  -9  19  23

   8  -1  -7   0  -9  24 -12

  -5  16  14  -2   1   7 -16

  -7   5   1 -23  -4  -4  17

-23

Row: 1, col: 2

Row: 5, col: 4

В языке Python есть встроенная функция min, которая возвращает минимальный элемент одномерного списка. Если же ее применить к двумерному списку, то она возвращает вложенный список, первый элемент которого оказывается минимальным.

Поэтому в коде поиска минимального элемента матрицы эта функция используется к каждой строке (вложенному списку) отдельно.

Использование функции min позволяет не перебирать отдельные элементы каждой строки, а ограничиться только перебором самих строк.

Классический вариант поиска минимального значения матрицы выглядел бы так:

… min_mx = 25 for i in range(N): for j in range(M): if a[i][j] < min_mx: min_mx = a[i][j] …

КуМир



алг индексы минимумов

нач

    цел M = 7, N = 5

    цел таб a[1:N,1:M]

    цел i, j, minimum

    minimum := 25

    нц для i от 1 до N

         нц для j от 1 до M

              a[i,j] := int(rand(0,50)) - 25

              вывод a[i,j]:4, "  "

              если minimum > a[i,j] то

                  minimum := a[i,j]

              все

         кц

         вывод нс

    кц

    вывод minimum, нс

    нц для i от 1 до N

         нц для j от 1 до M

             если minimum = a[i,j] то

                  вывод "строка: ",i, ", столбец: ",j, нс

             все

         кц

    кц

кон

Basic-256



M = 7

N = 5

dim a(N,M)

min = 25

for i = 0 to N-1

        for j=0 to M-1

                a[i,j] = int(rand*50)-25

                print a[i,j] + "   ";

                if min > a[i,j] then min = a[i,j]

        next j

        print 

next i

print min

for i = 0 to N-1

        for j=0 to M-1

                if min = a[i,j] then print (i+1) + "   " + ( j+1)

        next j 

next i

Источник

А нечто в таком духе не подойдет? Банально наплевать на многомерность массива и идти по нему линейно.

m1 := 0; m2 := 0; { 0 — специальное значение, означающее «еще не нашли» }
for i := 1 to 3 do
  for j := 1 to 3 do
    if m[i, j] > 0 then
      { Или если мы еще не нашли ни одного положительного числа (m1 <= 0),
        или если текущее значение меньше самого малого (m1) }
      if m1 <= 0 or m[i, j] < m1 then
        m1 := m[i, j]
      { Если мы не нашли второго положительного числа (m2 <= 0),
        или если текущее значение больше либо равно m1, но меньше второго
        по порядку наименьшего (m2) }
      else if m2 <= 0 or m[i, j] < m2 then
        m2 := m[i, j];

Для простоты индексы я не запоминаю. Если не будет достаточного числа положительных чисел — m2 (и, возможно, и m1) будут равны нулю. Если будет два одинаковых наименьших — на одном отработает ветка m1, на другом m1 уже будет не меньше, и отработает m2.

Код писался на коленке, без тестирования, возможны опечатки.

Источник