Определение максимального среди неповторяющихся элементов матрицы (C++)

Question

[NeoLogic]

Не могу понять, как найти уникальные элементы в матрице.

#include "stdafx.h"
#include <iostream>
using namespace std;
class Matrix {
public:
int m,n;
int a[100][100];
Matrix ( );// конструктор
~Matrix ( );// деструктор
void Max();
};

Matrix:: Matrix ( ) // Вводим размерность матрицы
{
cout << "Vvod v matrix \n";
cout << "Vvedite kolvo strok: ";
cin >> m;
cout << "Vvedite kolvo stolbcov: ";
cin >> n;
}

Matrix:: ~Matrix()
{

cout << "Deleted...\n";
}
void Matrix :: Enter ( ) //ввод чисел в матрицу
{
  int i;
  int j;
  for (i=0; i<m; i++) 
  {
    for (j=0; j<n;j++) 
	{
	   cout << "Vvod chisel v matricu: " << "a["<<i<<"]["<<j<<"]:" ;
	   cin >> a[i][j];
	}
  }
   cout <<"\n";
};

void Matrix :: Max() // нахождение максимального числа
{
int i,j,p,q;
int x=0,k=0;
int b[100];
int l,c = 0;
int max=0;
	for (i=0;i<m;i++)
	{
		for (j=0;j<n;j++)
		{
			x=a[i][j];
			k=0;
			 for (p=0;p<m;p++)
			 {
				 for (q=0;q<n;q++)
				 {
					 if (i!=p && j!=q && a[p][q]==x)
					 {
						 k=1;
					 }
				 }
			 }
		if (k==0)
		{
			b[c]=a[i][j];
			c+=1;
		}
		}
	}
	max = b[0];
	for (l=0;l<c;l++)
		{
			{
				cout<<b[l];
				if (b[l]>max)
				{
					max=b[l];
				}
			}
			cout << "\n";
		}
	cout << "maximum=" << max;
	cout << "\n";
}
main()
{
Matrix ob;
ob.Enter;
ob.Max();
system("pause");
return 0;
}

Этот код не правильно работает

Answer 1

[ManWithBear]

Давайте вы сначала дадите нормальные, отображающие их назначение, имена переменным. Обновите вопрос. И тогда мы уже посмотрим где у вас ошибка.
А разбираться что такое l,c,m вообще нет желания.

ЗЫ и переменные можно объявлять через запятую, вот так:
int i,b,c,d;
и даже так:
int i=0, b=4, c=42;

UPD замените условие:
if (i!=p && j!=q && a[p][q]==x)
на следующее:
if ((i!=p || j!=q) && a[p][q]==x)
У вас из-за неправильной логики при проверке одинаковые элементы стоящие на одной строке или в одном столбце, считались разными.

Comments

[NeoLogic]

исправил, l - переменная для цикла массива b[], с - размер массива b[], m,n - размер массива a[][];

[ManWithBear]

@NeoLogic согласитесь, что tmp[] и tmpSize, явно понятнее, чем b и с. (tmp от слова temporary-временный).
Почему не используете vector ? Думаю с ним было бы гораздо удобнее.

[NeoLogic]

Спасибо большое) названия изменю)

[ManWithBear]

@NeoLogic к слову, объявлять итераторы вне цикла, плохой тон.
Для чего плодить лишние переменные в основной области видимости функции.
for (int i=0; i < n; i++) ...

Answer 2

[EXL]

#include <iostream>
#include <vector>
#include <cstdlib>
#include <climits>

void fill_vector(size_t x,
                 size_t y,
                 int range,
                 std::vector< std::vector <int> > &aVector)
{
    for (size_t i = 0; i < x; ++i) {
        std::vector <int> temp_vector;
        for (size_t j = 0; j < y; ++j) {
            temp_vector.push_back(rand() % range);
        }
        aVector.push_back(temp_vector);
    }
}

void print_vector(const std::vector< std::vector <int> > &aVector)
{
    for (size_t i = 0; i < aVector.size(); ++i) {
        for (size_t j = 0; j < aVector.at(0).size(); j++) {
            std::cout << aVector.at(i).at(j) << "\t";
        }
        std::cout << std::endl;
    }
}

bool unique(int aElem,
            const std::vector <int> &aVector)
{
    int j = 0;
    for (size_t i = 0; i < aVector.size(); ++i) {
        if (aElem == aVector.at(i)) {
            ++j;
        }
    }

    return (j > 1) ? false : true;
}

int determine_max_elem(const std::vector< std::vector <int> > &aVector)
{
    int max_elem = INT_MIN;

    std::vector <int> temp_vector;
    for (size_t i = 0; i < aVector.size(); ++i) {
        for (size_t j = 0; j < aVector.at(0).size(); j++) {
            temp_vector.push_back(aVector.at(i).at(j));
        }
    }

    for (size_t i = 0; i < temp_vector.size(); i++) {
        if (max_elem < temp_vector.at(i) &&
                unique(temp_vector.at(i), temp_vector)) {
            max_elem = temp_vector.at(i);
        }
    }

    return max_elem;
}

int main()
{
    std::vector< std::vector <int> > vector;

    fill_vector(5, 5, 10, vector); // Fill 2D 5x5 Matrix
    print_vector(vector);

    int max = determine_max_elem(vector);
    if (max != INT_MIN) {
        std::cout << "\nMax element is: " << max << std::endl;
    } else {
        std::cout << "\nMax element in matrix isn't found!" << std::endl;
    }

    return 0;
}

Решение на C++ в лоб, без применения умных алгоритмов.

Comments

[ManWithBear]

Тогда легче было отсортировать temp_vector, и начиная с конца, искать уникальный элемент (элемент будет уникальным, если слева и справа стоят отличные от него числа)

[EXL]

@ManWithBear Вы несомненно правы! Я думал об этом когда писал функцию determine_max_elem(), но совсем запамятовал, как там пишется quick sort, а писать сортировку пузырьком мне не хотелось. Оставим оптимизацию автору вопроса в качестве домашнего задания :)

[ManWithBear]

@EXL я имел ввиду библиотечную сортировку. А вообще я вам поражаюсь, не лень же было всё почти с нуля переписывать :)

[EXL]

@ManWithBear Спасибо! Освежить свои знания было весьма полезно! Тем более, я очень сильно боюсь четверных вложенных циклов :D

Answer 3

[drozdVadym]

За основу взят листинг @EXL
но я переписал с помощью std::map

#include <iostream>
#include <vector>
#include <climits>
#include <map>
#include <ctime>

class MyMatrixInt {
public:
    MyMatrixInt(size_t rows = 1, size_t cols = 1, int range = 1)
    {
        reFill(rows, cols, range);
    }

    void reFill(size_t rows = 1, size_t cols = 1, int range = 1)
    {
        data_.clear();
        for (size_t i = 0; i < rows; ++i) {
            std::vector<int> row;
            for (size_t j = 0; j < cols; ++j) {
                row.push_back(rand() % range);
            }
            data_.push_back(row);
        }
    }

    int maxUniqueElem() const
    {
        int max_elem = INT_MIN;

        std::map<int, int> elem_map;

        for (size_t i = 0; i < data_.size(); i++) {
            for (size_t j = 0; j < data_[i].size(); j++) {
                elem_map[data_[i][j]]++;
            }
        }

        std::map<int, int>::reverse_iterator rit;
        for (rit = elem_map.rbegin(); rit != elem_map.rend(); ++rit) {
            if (rit->second == 1) {
                max_elem = rit->first;
                break;
            }
        }

        return max_elem;
    }

    void print() const
    {
        for (size_t i = 0; i < data_.size(); ++i) {
            for (size_t j = 0; j < data_[0].size(); j++) {
                std::cout << data_[i][j] << "\t";
            }
            std::cout << std::endl;
        }
    }


private:
    std::vector<std::vector<int> > data_;
};


int main()
{
    MyMatrixInt my_mat;

    //srand(time(NULL));
    my_mat.reFill(5, 5, 10); // Fill 2D 5x5 Matrix
    my_mat.print();

    int max = my_mat.maxUniqueElem();

    if (max != INT_MIN) {
        std::cout << "\nMax element is: " << max << std::endl;
    }
    else {
        std::cout << "\nMax element in matrix isn't found!" << std::endl;
    }

    return 0;
}