6. Обработка двухмерных массивов

1. Пример выполнения задания

Пример. В матрице A (размерности m  n) найти минимальное значение среди максимальных элементов строк. Исходные данные и результаты расположены в файлах.

{== Пример : нахождение "минимаксного" элемента матрицы ====== }

{ Дано: (1) Натуральные n и m : 1..10 }

{ (2) матрица A размера n*m с вещественными элементами }

{ Получить: индексы i и j элемента матрицы A, такого, что }

{ a[i,j]=(MIN k : 1..n: (MAX l : 1..m : a[k,l])), }

{ т.е. a[i,j] - минимальный из максимальных элементов строк матрицы}

{===================================================== }

const first = 1; nml = 10;

type index = first..nml; Row = array [index] of Real;

Matr = array [index] of Row;

var fin, fout : Text; a : Matr; { двухмерный массив 10 * 10 в памяти }

n, m, i, j : index; { реальное число: строк - n, столбцов - m }

{------------------------------------------------------------------}

procedure InMatrOut ( n, m : index; var a : Matr );

{ входные аргументы: n,m ; результат (выходной параметр): a }

{ ввод матрицы из файла fin, вывод в файл fout - глобальные: fin, fout }

var i, j : index; elem : Real;

{ внутренняя процедура с открытым параметром-массивом }

procedure InRowOut ( k : index; var str : array of Real );

{ ввод и вывод строки матрицы : str -строка, k - ее длина }

{ входной аргумент: k ; результат (выходной параметр): str }

{ ввод из fin, вывод в fout - глобальные: fin, fout }

var j : index; elem : Real;

begin

for j:=1 to k do

begin

Read( fin, elem ); Write( fout, elem : 6 : 2, ' ');

str[j-1] := elem { str - открытый массив (индексация с 0 ) }

end; {j}

ReadLn ( fin );

WriteLn( fout )

end; { конец внутренней процедуры InRowOut }

{...........................................................}

begin { InMatrOut }

for i := 1 to n do { обработка матрицы по строкам }

InRowOut( m, a[i] ); { ввод и вывод i-й строки }

ReadLn ( fin );

WriteLn( fout )

end; { InMatrOut }

{------------------------------------------------------------------}

function ArgMaxInRow( m: index; var str: array of Real ): index;

{ входные аргументы: m - индекс последнего элемента в A, }

{ str- открытый массив (индексация с 0 ), }

{ результат: значение функции ArgMaxInRow . }

{ Поиск argMax - индекса максимального элемента }

{ из str[0..m-first], т.е. str[argMax] = ( MAX k:0..m-first : str[k] ) }

{ Подробности см. в примере 7.2 }

type index0 = 0..nml-first; { новая индексация параметра-массива str }

var argMax, i : index0;

begin { ArgMaxInRow }

argMax := 0;

for i := 1 to m-first do

{ m-first - новая индексация последнего элемента A в str }

{ inv: str[argMax] = ( MAX k:0..i : str[k] ) }

if str[i] > str[argMax] then argMax := i;

{ необходимо вернуться к исходной индексации }

ArgMaxInRow := argMax+first { возврат к исходной индексации }

end; { ArgMaxInRow }

{------------------------------------------------------------------}

procedure MinMax( n, m : index; var a : Matr; var i, j : index);

{ входные аргументы: n, m, a; результат (выходной параметр): i,j }

{ a[i,j]=(MIN k:1..n: (MAX l:1..m : a[k,l])), }

{ т.е. a[i,j] - минимальный из максимальных элементов строк матрицы }

var i1, j1 : index;

begin { MinMax }

i := 1; j := ArgMaxInRow( m, a[i]); { a[i,j] - текущий "минимакс"}

for i1 := 2 to n do

begin

j1 := ArgMaxInRow( m, a[i1]);

if a[i1,j1] < a[i,j] then begin i := i1; j := j1 end

{ a[i,j]=(MIN k:1..i1: (MAX l:1..m : a[k,l]))}

end {for}

end; { MinMax }

{------------------------------------------------------------------}

begin { main }

Assign( fin, 'inmatr1.dat'); Reset( fin );

Assign(fout, 'outmatr1.dat'); ReWrite( fout );

ReadLn( fin, n, m ); ReadLn( fin );

WriteLn( fout, ' *** матрица A (', n:1, '*', m:1, ') ***');

InMatrOut( n, m, a );

MinMax( n, m, a, i, j );

WriteLn( fout, ' Р Е З У Л Ь Т А Т : ');

WriteLn( fout, '"минимакс" матрицы');

WriteLn( fout, 'a [',i:1,',',j:1,']=',a[i,j]:6:2);

Close(fin); Close(fout)

end.

Входные данные и результаты выполнения этой программы приведены в таблице.

Входной файл inmatr1.dat:													Выходной файл outmatr1.dat:
4	5		:	n,	M									*** матрица A (4*5)***
=======================строка															1.00		2.00		0.05		4.00		5.00
1.	2.	.5	4.	5.	6.	7.	8.	9.	10.	: 1				0.10		0.20		0.50		0.40		0.30
.1	.2	.5	.4	.3	.6	.7	.8	.9	1.	: 2				0.10		0.10		0.40		0.20		1.00
.1	.1	.4	.2	1.	1.	1.	1.	1.	1.	: 3				2.00		3.00		4.00		5.00		6.00
2.	3.	4.	5.	6.	7.	8.	9.	0.	2.	: 4
0.	0.	0.	0.	0.	0.	0.	0.	0.	0.	: 5				Р Е З У Л Ь Т А Т :
0.	0.	0.	0.	0.	0.	0.	0.	0.	0.	: 6				"минимакс" матрицы
0.	0.	0.	0.	0.	0.	0.	0.	0.	0.	: 7				a [2,3]= 0.50
0.	0.	0.	0.	0.	0.	0.	0.	0.	0.	: 8
0.	0.	0.	0.	0.	0.	0.	0.	0.	0.	: 9
1.	2.	3.	4.	5.	6.	7.	8.	9.	10.	: 10
============================

Примечание. Экономия памяти обеспечивается описанием параметров-массивов как параметров-переменных (var). При написании программ в Турбо Паскале версии 7.0 в случае использования элементов этих массивов без их изменения в процедуре или функции целесообразно описывать параметры-массивы как параметры-константы (const).