Дана квадратная матрица, отсортированная по строкам и столбцам, и положительное целое число 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++
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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 |
#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
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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 |
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
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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
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(N2) для N × N
матрица и требует O(k) дополнительное пространство для структуры данных кучи.
2. Использование бинарного поиска
Мы можем избежать использования дополнительного пространства, используя алгоритм бинарного поиска. Бинарный поиск обычно работает с линейной структурой данных, которая отсортирована, мы можем изменить ее для работы с матрицей, которая отсортирована как по строкам, так и по столбцам. Начнем с поискового пространства [low, high]
куда low
а также high
изначально указывают на верхний левый и нижний правый углы матрицы соответственно. Затем на каждой итерации цикла бинарного поиска мы определяем среднее значение и подсчитываем элементы в матрице, которые меньше или равны среднему элементу. Мы сужаем поле поиска до [mid+1…high]
если счет меньше k
; в противном случае мы сужаем его до [low…mid-1]
. Цикл завершается, как только low
превосходит high
, а также low
хранит k-е наименьшее значение в матрице.
Ниже приведена реализация C++, Java и Python, основанная на идее:
C++
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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 |
#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
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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 |
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
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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
# Функция для подсчета элементов в матрице, которые меньше или равны заданному значению 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(N2)) для 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 |
|
1 |
|
В матрице найти наименьшее число08.04.2020, 17:23. Показов 2464. Ответов 1
Дана таблица чисел, состоящая из N строк по M чисел в каждой. Все числа в таблице — натуральные, не превышающие 1000. Выходные данные Пример входного файла Пример выходного файла
0 |
zss Модератор 13104 / 10376 / 6207 Регистрация: 18.12.2011 Сообщений: 27,755 |
||||||||
08.04.2020, 18:13 |
2 |
|||||||
Берем образец
И небольшая правка в main
0 |
IT_Exp Эксперт 87844 / 49110 / 22898 Регистрация: 17.06.2006 Сообщений: 92,604 |
08.04.2020, 18:13 |
Помогаю со студенческими работами здесь
Найти наименьшее число, делящееся на заданное число, и оканчивающееся на заданную цифру Найти в первом стеке максимальное число, а во втором — наименьшее число
Андрей готовился к ЕГЭ по информатике и встретил в демо-версии ЕГЭ 2015 года такую… Искать еще темы с ответами Или воспользуйтесь поиском по форуму: 2 |
Перейти к содержанию
Индексы минимальных элементов матрицы
Просмотров 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
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
.
Код писался на коленке, без тестирования, возможны опечатки.