//---------------------------------------------------------------------------
#include <iostream>
# include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;

int i, j, k, n, is_null;
 float tmp;
 char c;
 FILE *fp;
 float **mas;

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormShow(TObject *Sender)
{
        is_null=1;

}
//---------------------------------------------------------------------------

void __fastcall TForm1::RazmerClick(TObject *Sender)
{
      for (i=0;i<SG1->ColCount;i++)
        for (j=0;j<SG1->RowCount;j++)
          {SG1->Cells[i][j]="";
           SG1->Cells[i][j].Delete(i,1);
          }
       SG1->ColCount = StrToInt(Edit1->Text);
     }
//---------------------------------------------------------------------------
void __fastcall TForm1::MaxClick(TObject *Sender)
{
    if (is_null!=1)  //î÷èñòèòü ïàìÿòü îò ñòàðîãî ìàññèâà
    {
     for(i=0; i<n; i++)  delete[] mas[i];
     delete[] mas;
    }

    //íîâîå êîëè÷åñòâî ýë-òîâ
   n = StrToInt(Edit1->Text);
   mas = new float *[n];
   for (i = 0; i < n; i++)
     mas[i] = new float [n];

   //ñ÷èòûâàíèå èç String Grid 1 â ìàññèâ
   for (i=0; i<n; i++)
   for (j=0; j<n; j++)
     { if (SG1->Cells[i][j]!="")
         mas[j][i]=StrToFloat(SG1->Cells[i][j]);
       else mas[j][i]=0;
     }

     //ïîèñê ìàêñèìàëüíîãî çíà÷åíèÿ

   i=0;
    for (j=0; j<n; j++)
     {
      if (mas[i][j]>tmp)
        tmp = mas[i][j];
     }
    //âûâîä â String Grid 2

   Edit2->Text = FloatToStr(tmp);

   //ðåçóëüòàò ïîèñêà â òåêñòîâûé ôàéë
   fp = fopen("max.txt", "w");
     {
      fprintf(fp," %.2f  ",tmp);
      fprintf(fp,"\n");
     }
   fclose(fp);

}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCloseQuery(TObject *Sender, bool &CanClose)
{
    if (is_null!=1)   //åñëè ïàìÿòü ïîä ìàññèâ âûäåëåíà, îñâîáîäèòü
  {
    for(i=0; i<StrToInt(Edit1->Text); i++)  delete[] mas[i];
    delete[] mas;
  }
}
//---------------------------------------------------------------------------


void __fastcall TForm1::MinClick(TObject *Sender)
{
    if (is_null!=1)  //î÷èñòèòü ïàìÿòü îò ñòàðîãî ìàññèâà
    {
     for(i=0; i<n; i++)  delete[] mas[i];
     delete[] mas;
    }

    //íîâîå êîëè÷åñòâî ýë-òîâ
   n = StrToInt(Edit1->Text);
   mas = new float *[n];
   for (i = 0; i < n; i++)
     mas[i] = new float [n];

   //ñ÷èòûâàíèå èç String Grid 1
   for (i=0; i<n; i++)
   for (j=0; j<n; j++)
     { if (SG1->Cells[i][j]!="")
         mas[j][i]=StrToFloat(SG1->Cells[i][j]);
       else mas[j][i]=0;
     }

     //ïîèñê ìèíèìàëüíîãî çíà÷åíèÿ

   i=0;
     for (j=0; j<n; j++)
     {
      if (mas[i][j]<tmp)
       tmp = mas[i][j];
     }

    //âûâîä â Edit3
    Edit3->Text = FloatToStr(tmp);

   //ðåçóëüòàò ïîèñêà â òåêñòîâûé ôàéë
   fp = fopen("min.txt", "w");
     {
      fprintf(fp," %.2f  ",tmp);
      fprintf(fp,"\n");
     }
   fclose(fp);
}
//---------------------------------------------------------------------------


void __fastcall TForm1::N2Click(TObject *Sender)
{
 Close();        
}
//---------------------------------------------------------------------------

unit unitd;
Interface
uses crt;
type massiv=array[1..100,1..100] of real;
     massiv1=array[1..100] of real;
Implementation
procedure matri(var a:massiv);
procedure Matr_Prakt(a:massiv; var koor:massiv1);
procedure Funkcia(koor:massiv1);

procedure matri;
var
i,j:byte;
function new:real;
begin
 new:=((2-sqr(i-3))/i)*(j-5.7);
 end;
begin
clrscr;
for i:=1 to 10 do
 for j:=1 to 10 do
 a[i,j]:=new;
for i:=1 to 10 do begin
 writeln;
 for j:=1 to 10 do
 write(a[i,j]:8:2);
 end;
 readkey;
end;


procedure Matr_Prakt;
type massiv=array[1..100,1..100] of integer;
     massiv1=array[1..500] of integer;
var   q,n,n1,max_stolb:integer;
i,j:byte;
       x:massiv1;



begin
i:=1;
max_stolb:=1;
for j:=2 to N do
if a[i,j]>a[i,j-1] then max_stolb:=j;

for i:=1 to N do
for j:=1 to N do
koor[i]:=koor[i]+a[i,j]*a[j,max_stolb];

write('a(',koor[1]);
for i:=2 to n do
write(',',koor[i]);
write(')');
writeln;
writeln;
readln;
end;


procedure Funkcia;
var U:real;
qwer,a,i,n,chisl,znam:integer;
q1,q2:real;

function F(b:real; var a:real):integer;

begin
a:=a+b;
end;

begin
for i:=1 to n do
if koor[i]<=1 then f(koor[i],q1);
for i:=1 to n do
if koor[i]>1 then f(koor[i],q2);

U:=(1+q1)/(2+q2);
writeln(u);
readln;
writeln;
writeln;
end;

begin
matri;
Matr_Prakt;
Funkcia;
end.

program Project2;

{$APPTYPE CONSOLE}

uses
  SysUtils;

type
  TMatrixInfo =
  record
    size: array [0..1] of integer;
    desc: string;
  end;

  TMatrixes =
    array [0..7] of TMatrixInfo;


var bestSolveMemoryVolume: integer;
    bestSolve: TMatrixes;
    matrixSizes: TMatrixes;


procedure GenerateSolves(solve: TMatrixes; count: integer; maxMemoryVolume: integer);
var memoryVolume:integer;
    i, j: integer;
    newSolve: TMatrixes;
begin
 
  if count=1 then
  begin
    //построение варианта решения - закончено
    //проверяем - лучшее ли оно ?
    if (maxMemoryVolume < bestSolveMemoryVolume) then
      begin
      bestSolveMemoryVolume :=  maxMemoryVolume;
      bestSolve := solve;
      end;
    exit;
  end;

  {строим варианты решения}
  for i:=0 to count-2 do
  begin
    for j:=0 to count-2 do
    if(j<i) then
      begin
        //копируем элементы
        newSolve[j].size[0] := solve[j].size[0];
        newSolve[j].size[1] := solve[j].size[1];
        newSolve[j].desc := solve[j].desc;
      end
    else
    if j=i then
      begin
        //имитируем произведение матриц i и i+1
        newSolve[j].size[0] := solve[j].size[0];
        newSolve[j].size[1] := solve[j+1].size[1];
        newSolve[j].desc := '('+solve[j].desc+'*'+solve[j+1].desc+')';
        //счтаем сколько памяти нужено под новую матрицу
        memoryVolume := newSolve[i].size[0]*newSolve[i].size[1];
        if(memoryVolume>maxMemoryVolume) then
            maxMemoryVolume :=memoryVolume;
      end
    else
      begin
        //копируем элементы
        newSolve[j].size[0] := solve[j+1].size[0];
        newSolve[j].size[1] := solve[j+1].size[1];
        newSolve[j].desc := solve[j+1].desc;
      end;
    //если текущее решение уже хуже лучшего, то не продолжаем дальше
    if maxMemoryVolume>bestSolveMemoryVolume then
      exit;
    //моделируем следующее перемножение
    GenerateSolves(newSolve, count-1, maxMemoryVolume);
  end;
 
end;


begin
matrixSizes[0].size[0] :=5;
matrixSizes[0].size[1] :=4;
matrixSizes[0].desc := 'M[5x4]';
matrixSizes[1].size[0] :=4;
matrixSizes[1].size[1] :=7;
matrixSizes[1].desc := 'M[4x7]';
matrixSizes[2].size[0] :=7;
matrixSizes[2].size[1] :=3;
matrixSizes[2].desc := 'M[7x3]';
matrixSizes[3].size[0] :=3;
matrixSizes[3].size[1] :=8;
matrixSizes[3].desc := 'M[3x8]';
matrixSizes[4].size[0] :=8;
matrixSizes[4].size[1] :=3;
matrixSizes[4].desc := 'M[8x3]';
matrixSizes[5].size[0] :=3;
matrixSizes[5].size[1] :=7;
matrixSizes[5].desc := 'M[3x7]';
matrixSizes[6].size[0] :=7;
matrixSizes[6].size[1] :=2;
matrixSizes[6].desc := 'M[7x2]';
matrixSizes[7].size[0] :=2;
matrixSizes[7].size[1] :=2;
matrixSizes[7].desc := 'M[2x2]';

bestSolveMemoryVolume := MaxInt;
//перебираем все возможные варианты, ищем лучший вариант
GenerateSolves(matrixSizes, 8, 0);

//рисуем решение
Writeln(bestSolve[0].desc);
Writeln('Max matrix: '+ intToStr(bestSolveMemoryVolume) + ' items');

Readln;

end.