Работа с файлами: матрица и ее определитель

Уровень сложности:

В файле test.in записана матрица размером N*N. Найти ее определитель. Результат записать в test.out. Для работы с файлами использовать функции из заголовочного файла cstdio.

 

К сожалению, решения данной задачи пока нет. Если Вы решили эту задачу, сообщите нам, и мы выложим её на сайте.

E-mail : admin@cppstudio.com

Следующие статьи помогут вам в решении данной задачи:
Автор: Marienko L.
Дата: 17.11.2012
Поделиться:

Комментарии

  1. Felix Net

    #include <vector>
    #include <algorithm>
    #include <fstream>
    #include <iterator>
    #include <iostream>
    #include <conio.h>
     
    using namespace std;
     
    class nulled : public unary_function<vector<double>, bool>
    {
    public:
            bool operator() (const vector<double>& Buffer)
            {
                    return !(*Buffer.begin());
            }
    };
     
    class chg : public binary_function<vector<double>, vector<double>, bool>
    {
    public:
            bool operator()(const vector<double>& Buffer1, const vector<double>& Buffer2)
            {
                    return *Buffer1.begin() > *Buffer2.begin();
            }
    };
     
    class chg2 : public binary_function<vector<double>, vector<double>, bool>
    {
    public:
            bool operator()(const vector<double>& Buffer1, const vector<double>& Buffer2)
            {
                    return *Buffer1.begin() < *Buffer2.begin();
            }
    };
     
    void out(vector<vector<double> >& Buffer)
    {
            cout << endl;
            for (vector<vector<double> >::iterator i = Buffer.begin(), end = Buffer.end(); i != end; ++i, cout << endl)
                    copy(i->begin(), i->end(), ostream_iterator<double>(cout, "  "));
    }
     
    double Determinant(vector<vector<double> >& Buffer)
    {
            sort(Buffer.begin(), Buffer.end(), chg2());     
            if (all_of(Buffer.begin(), Buffer.end(), nulled()))
                    return 0;
            vector<vector<double> >::iterator fisrt = Buffer.begin();
            if (Buffer.size() == 1)
                    return *fisrt->begin();
            for (vector<vector<double> >::iterator i = Buffer.begin() + 1, end = Buffer.end(); i != end; ++i)
            {
                    double T = *i->begin() / *fisrt->begin(); 
                    transform(fisrt->begin(), fisrt->end(), i->begin(), i->begin(),
                    [&T](const double& value1, const double& value2)->double
                    {
                            return value2 - value1 * T;
                    });
            }
            sort(Buffer.begin() + 1, Buffer.end(), chg());  
            vector<vector<double> > matrix(Buffer.size() - 1);
            for (vector<vector<double> >::iterator i = Buffer.begin() + 1, end = Buffer.end(), Tmp = matrix.begin(); i != end; ++i)
                    copy(i->begin() + 1, i->end(), back_inserter(*Tmp++));
            return *fisrt->begin() * Determinant(matrix);
    }
     
    int main()
    {
            fstream file("test.txt");
            size_t n; 
            file >> n;
            vector<vector<double> > matrix(n, vector<double>(n));
            for (vector<vector<double> >::iterator i = matrix.begin(), end = matrix.end(); i != end; ++i)
                    for (vector<double>::iterator j = i->begin(), end = i->end(); j != end; ++j)
                            file >> *j;
            cout << "Determinate \n" << static_cast<int>(Determinant(matrix));
            _getch();
            return EXIT_SUCCESS;
    }
  2. Fox122

    Реализация класса квадратных матриц с функцией определителя, обратной матрицы, умножение на матрицу

    #include <iostream>
    #include <cstdlib>
    #include <math.h>
    #include <iomanip>
    using namespace std;
    
    class Matrix
    {
    private:
    	double** matrix;
    	int size;
    public:
    	Matrix(int n)
    	{
    		size = n;
    
    		matrix = new double*[size];
    		for (int i = 0;i<size;i++)
    			matrix[i] = new double[size];
    
    		for (int i = 0;i<size;i++)
    			for (int j = 0;j < size;j++)
    			{
    				if (i == j) matrix[i][j] = 1;
    				else matrix[i][j] = 0;
    			}
    	}
    
    	Matrix(double** qq = NULL, int n = 0)
    	{
    		size = n;
    
    		matrix = new double*[size];
    		for (int i = 0;i<size;i++)
    			matrix[i] = new double[size];
    
    		for (int i = 0;i<size;i++)
    			for (int j = 0;j<size;j++)
    				matrix[i][j] = qq[i][j];
    	}
    
    	Matrix(const Matrix& cc)
    	{
    		size = cc.size;
    
    		matrix = new double*[size];
    		for (int i = 0;i<size;i++)
    			matrix[i] = new double[size];
    
    		for (int i = 0;i<size;i++)
    			for (int j = 0;j<size;j++)
    				matrix[i][j] = cc.matrix[i][j];
    	}
    
    	~Matrix()
    	{
    		for (int i = 0;i < size;i++)
    			delete[] matrix[i];
    		delete[]matrix;
    	}
    
    	int Size() { return size; }
    
    	friend ostream& operator <<(ostream& os, Matrix cc)
    	{
    		for (int i = 0;i < cc.size;i++)
    		{
    			for (int j = 0;j < cc.size;j++)
    				os << cc.matrix[i][j] << " ";
    			os << endl;
    		}
    		return os;
    	}
    
    	friend istream& operator >> (istream& is, Matrix& cc)
    	{
    		for (int i = 0;i < cc.size;i++)
    			delete[] cc.matrix[i];
    		delete[] cc.matrix;
    
    		cout << "введите размер матрицы!" << endl;
    		is >> cc.size;
    
    		cout << "введите элементы матрицы:" << endl;
    		cc.matrix = new double*[cc.size];
    		for (int i = 0;i < cc.size;i++)
    			cc.matrix[i] = new double[cc.size];
    		for (int i = 0;i<cc.size;i++)
    			for (int j = 0;j<cc.size;j++)
    				is >> cc.matrix[i][j];
    		return is;
    	}
    
    	double determinant()
    	{
    		Matrix A(*this);
    		double result = 1;
    		if (size == 1) return matrix[0][0];
    		if (size == 2) return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
    		else
    		{
    			int k = 0;
    			while (matrix[0][k] == 0) k++;
    			if (k == size) return 0;
    			else
    				return  pow(-1, k)*A.GausStep(0, k).matrix[0][k] * (A.GausStep(0, k).Minor(0, k)).determinant();
    		}
    	}
    
    	Matrix Minor(const int p, const  int q)
    	{
    		double **minor = new double*[size - 1];
    		for (int i = 0; i < size - 1; i++) minor[i] = new double[size - 1];
    
    		for (int i = 0; i < p; i++)
    		{
    			for (int j = 0; j < q; j++)
    				minor[i][j] = matrix[i][j];
    			for (int j = q;j < size - 1;j++)
    				minor[i][j] = matrix[i][j + 1];
    		}
    
    		for (int i = p; i < size - 1; i++)
    		{
    			for (int j = q; j < size - 1; j++)
    				minor[i][j] = matrix[i + 1][j + 1];
    			for (int j = 0;j < q;j++)
    				minor[i][j] = matrix[i + 1][j];
    		}
    
    		Matrix result(minor, size - 1);
    
    		for (int i = 0;i < size - 1;i++)
    			delete[] minor[i];
    		delete[] minor;
    
    		return result;
    	}
    
    	double* operator[](int j) { return matrix[j]; }
    
    	double* & operator[](int j) const { return matrix[j]; }
    
    	Matrix GausStep(int p, int q)
    	{
    		double **result = new double*[size];
    		for (int i = 0; i < size; i++) result[i] = new double[size];
    		for (int i = 0;i < size;i++)
    			for (int j = 0;j < size;j++)
    				result[i][j] = matrix[i][j];
    
    		for (int i = 0;i < size;i++)
    			for (int j = 0;j < size;j++)
    			{
    				if (i != p)
    					result[i][j] = matrix[i][j] - (matrix[p][j] * matrix[i][q] / matrix[p][q]);
    			}
    
    		Matrix A(result, size);
    
    		for (int i = 0;i < size;i++)
    			delete[] result[i];
    		delete[] result;
    
    		return A;
    	}
    
    	Matrix ReverseMatrix()
    	{
    		Matrix qq(size);
    		if (determinant() != 0)
    		{
    
    			double Det = determinant();
    			for (int i = 0;i < size;i++)
    				for (int j = 0;j < size;j++)
    					qq.matrix[i][j] = Minor(i, j).determinant()*pow(-1, i + j) / Det;
    		}
    		return qq.Tr();
    	}
    
    	Matrix Tr()
    	{
    		Matrix qq(size);
    		for (int i = 0;i < size;i++)
    			for (int j = 0;j < size;j++)
    				qq[i][j] = matrix[j][i];
    		return qq;
    	}
    
    	Matrix operator *(Matrix cc)//умножение на сс справа
    	{
    		if (cc.size == size)
    		{
    			Matrix qq(size);
    			double sum = 0;
    			for (int k = 0;k < size;k++)
    			{
    				for (int j = 0;j < size;j++)
    				{
    					for (int l = 0;l < size;l++)
    					{
    						sum += matrix[j][l] * cc.matrix[l][k];
    					}
    					if (sum>0.0000000001) qq.matrix[j][k] = sum;
    					sum = 0;
    				}
    			}
    			return qq;
    		}
    		cout << "размеры не совпадают!" << endl;
    		return *this;
    	}
    };
    
    void main()
    {
    	setlocale(0, "");
    
    	int size;
    	cout << "Введите размер матрицы" << endl;
    	cin >> size;
    
    	Matrix qq(size);
    	for (int i = 0;i < qq.Size();i++)
    		for (int j = 0;j < qq.Size();j++)
    			qq[i][j] = rand() % 10;
    
    	cout << qq << endl;
    	cout << qq.ReverseMatrix() << endl;
    	cout << endl << qq*qq.ReverseMatrix() << endl;
    }
  3. Arthur

    //с использованием шаблона next_permutation()
    #include<iostream>
    #include<cmath>
    #include <fstream>
    #include<iomanip>
    #include<algorithm>
    using namespace std;
    
    int  invers(int* , int  );
    
    int main()
    {
        setlocale(LC_ALL, "rus");
        int n, *a;
        cout<<"¬ведите пор€док матрицы: ";
        cin>>n;
    
        float** matrix = new float*[n];
        for(int i = 0; i<n; i++)
            matrix[i] = new float[n];
    
        ifstream inmatr("D:\\testIn.txt");
        for(int x = 0; x<n; x++)
        {
            for(int y = 0; y<n; y++)
              {
                inmatr>>matrix[x][y];
                cout<<setw(4)<<matrix[x][y];
              }
            cout<<"\n\n";
        }
    
        a = new int[n];
        for(int i = 0; i<n; i++)
            a[i] =   i ;
    
        int slag = n;
        for(int i = n-1; i>0; i--)
            slag *= i;
    
        float det  = 0;
        for(int x = 0; x<slag; x++)
           {
             float temp = 1;
             for(int y = 0; y<n; y++)
                temp *= matrix[y][a[y]];
    
             det += temp * pow(-1,invers(a,n)) ;
    
            next_permutation(a + 0, a + n);
           }
    
        cout<<det<<endl;
        ofstream outdet("D:\\testOut.txt");
        outdet<<det;
    
        for(int i = 0; i<n; i++)
            delete[]matrix[i];
        delete[]a;
        return 0;
    }
    /////////////////////////////////////////////////
    int invers(int* a, int n)
    {
        int i = 0;
        for(int x = 0; x<n; x++)
            for(int y = x+1; y<n; y++)
              if(a[x]>a[y])
                i++;
        return i;
    }
    
    
    
    
    
    
    
  4. Arthur

    #include<iostream>
    #include<cmath>
    #include <fstream>
    #include<iomanip>
    using namespace std;
    /*Определителем квадратной матрицы n-го порядка, называется число,
      равное алгебраической сумме n! членов, каждый из которых является произведением
      n элементов матрицы, взятых по одному из каждой строки и каждого столбца,
      причем  знак каждого члена определяется как pow( -1, r(J) ),
      где r(J) - число инверсий в перестановке J из номеров столбцов элементов матрицы,
      если при этом номера строк записаны в порядке возрастания
    
      Число инверсий в перестановке J, это количество пар чисел, в которых большое число предшествует меньшему*/
    
    void swap(int* , int , int );   //перестановка пары
    bool generation(int*  , int  ); //генератор перестановок
    int  invers(int* , int  );      //число инверсий
    
    int main()
    {
        setlocale(LC_ALL, "rus");
        int n, *a;
    
        cout<<"Введите порядок матрицы: ";
        cin>>n;
    
        float** matrix = new float*[n];
        for(int i = 0; i<n; i++)
            matrix[i] = new float[n];
    
        ifstream inmatr("D:\\testIn.txt");
        for(int x = 0; x<n; x++)
        {
            for(int y = 0; y<n; y++)
              {
                inmatr>>matrix[x][y];
                cout<<setw(4)<<matrix[x][y];
              }
            cout<<"\n\n";
        }
    
        a = new int[n];
    
        for(int i = 0; i<n; i++)
            a[i] =   i ;
    
         int slag = n;                  //число слагаемых, n!
         for(int i = n-1; i>0; i--)
            slag *= i;
    
          float det  = 0;
          for(int x = 0; x<slag; x++)
           {
             float temp = 1;
             for(int y = 0; y<n; y++)
                temp *= matrix[y][a[y]];
    
             det += temp * pow(-1,invers(a,n)) ;
    
             generation(a, n);
           }
        cout<<det<<endl;
        ofstream outdet("D:\\testOut.txt");
        outdet<<det;
    
        for(int i = 0; i<n; i++)
            delete[]matrix[i];
        delete[]a;
    
       return 0;
    }
    //////////////////////////////////////////////////////////////
    void swap(int* a, int i, int j)
    {
        int s = a[i];
        a[i] = a[j];
        a[j] = s;
    }
    //////////////////////////////////////////////////////////////
    bool generation(int* a, int n)
    {
        int j = n - 2;
    
        while(j != -1 && a[j] >= a[j + 1])
            j--;
    
        if( j == -1)
            return false;
    
        int k = n - 1;
        while(a[j] >= a[k])
            k--;
    
        swap(a, j, k);
    
        int l = j +  1, r = n - 1;
        while(l<r)
            swap(a, l++, r--);
    
        return true;
    }
    /////////////////////////////////////////////////
    int invers(int* a, int n)
    {
        int i = 0;
        for(int x = 0; x<n; x++)
            for(int y = x+1; y<n; y++)
              if(a[x]>a[y])
                i++;
        return i;
    }
    
    
    
    
    
    
    
  5. Gorhok

    токо функция нахождения определителя матрицы по правилу треугольника  на самом деле по методу разложения по сторокам

  6. Gorhok

    //решение задачи легкого уровня №36 	Работа с файлами: матрица и ее определитель
    #include <iostream>
    #include<cstdio>
    using std::cout;
    using std::cin;
    using std::endl;
    
    void qwadMatrixPrint(int* *pM, int n)
    {
    	for (int str=0;str<n;str++)
    	{
    		for (int col=0;col<n;col++)
    		{
    			std::cout<<pM[col][str]<<"\t";
    		}
    		std::cout<<"\n";
    	}
    }
    //функция вывода произвольной матрицы nxn в файл
    void MatrixMovF(int n)
    {
    	for (int str=0;str<n;str++)
    	{
    		for (int col=0;col<n;col++)
    		{
    			std::cout<<((rand() % 100)*((rand() % 3)-1))<<("\t");
    		}
    		std::cout<<"\n";
    	}
    }
    //функция нахождения определителя матрицы по правилу треугольника
    int determMatrix(int* *pM, int n,int deep=0)
    {	
    	if(n==2)
    		return pM[0][0+deep]*pM[1][1+deep]-pM[0][1+deep]*pM[1][0+deep];
    	
    	int znak= 1;//переменная определяющая знак алгебраического дополнения Aij 
    //	( Aij=(-1)^(i+j)*Mij где Mij-минор;минор произвольного элемента квадратной 
    //	матрицы Pij  равен определителю матрицы, полученной из исходной 
    //вычеркиванием i-ой строки и j-го столбца.)
    	int sum_det= 0;
    	
    	for(int i= 0; i< n; i++)
    	{	
    		int* *pI= new int* [n-1];//создание нового масива указатей
    		//указывающих только на столбцы минора(верхние ненужные строки(ка)
    		//отсекаються за щет переменной deep(глубина рекурсии))
    		
    		//создание очередного минора
    			int p=0;	
    		for(int ii= 0; ii< n; ii++ )
    		{
    			if(ii==i)continue;
    			
    			pI[p]=pM[ii];
    			p++;
    		}
    		
    		sum_det+= znak*pM[i][deep]*determMatrix(pI,(n-1),(deep+1));//переменная deep(глубина рекурсии) 
    		//указывает первую строку с которой начинаетья данный минор 
    		
    		delete [] pI;//освобождение памяти 
    		znak*= -1;
    		
    	}
    	return sum_det;
    }
    
    
    int main(int argc, char * argv[])
    {
    	setlocale(LC_ALL, "rus");
    	
    	int n=0;
    	cout<<"Введите порядок матрицы : "<<endl;
    	cin>>n;
    
    	freopen("test.in", "w", stdout);//открыть файл test.in для записи 
    									//связать с потоком stdout(вывода)
    	MatrixMovF(n);
    	freopen("test.in", "r", stdin);//открыть файл test.in для чтения
    									//связать с потоком stdin (ввода)
    	
    	int* *pMat=new int* [n];//pMat присваеваеться указатель на масив указателей на столбцы матрицы	
    	//Инициализация элементов матрицы 
    	for(int col=0; col<n; col++)	pMat[col]=new int[n];
    	
    
    		for (int str=0;str<n;str++)
    		{
    			for (int col=0;col<n;col++)
    			{
    				cin>>pMat[col][str];//инициализация элемента столбца матрицы
    									//прочитаным из файла test.in значением
    			}
    		}
    	freopen("test.out", "w", stdout);//открыть файл test.in для записи 
    									//связать с потоком stdout(вывода)
    	
    	qwadMatrixPrint(pMat, n);
    	int determ =determMatrix(pMat, n);
    	cout<<"Определитель матрицы "<<n<<"x"<<n<<endl;
    	cout<<"равен "<<determ<<endl;
    
    
    
    //освобождение памяти
    for (int i=0;i<n;i++)
    	{
    		delete [] pMat[i];
    	}
    	delete [] pMat;
    
    	return 0;
    }

Оставить комментарий

Вы должны войти, чтобы оставить комментарий.