Найти количество уникальных чисел в матрице

#include <iostream>
#include <set>
 
 
int main()
{
    int const row = 3, col = 2;
    int mtx[row][col] = { {1, 2}, {3, 4}, {2, 5} };
    std::set<int> st(*mtx, *mtx + row * col);
    std::cout << st.size() << std::endl;
}

int **mtx = new (int *)[row];
for(i=0; i<col; i++) *mtx = new (int) [col];

#include <iostream>
#include <set>
using namespace std;
int const row = 3, col = 3;
    
double array[row][col] = { {1.1, 2.1}, {3.1, 4.1}, {5.1, 6.1} };
set<int> st(*array, * array + row * col);
cout << st.size() << endl; // это размер? Нужно количество уникальных не повторяющихся чисел. 
                                   //Вида: cout << "Uniuqae numbers=" <<…  << '\n';

#include <iostream>
#include <algorithm>
#include <map>
 
 
int main()
{
    int const row = 3, col = 2;
    double arr[row][col] = { { 1.1, 2.1 }, { 3.1, 4.1 }, { 1.1, 6.1 } };
    std::map<double, int> mp;
    std::for_each(*arr, *arr + row * col, [&](auto val) {++mp[val]; });
    int cnt = std::count_if(mp.begin(), mp.end(), [](auto const& pr) {return pr.second == 1; });
    std::cout << cnt << std::endl;
 
}

double data2[3][3]={{1.,2.,2.},{3.,4.,5.},{5.,5.,6.}}; 
double data2Copy[3][3];

//=======находим количество различных чисел в data2
//---копируем data2 в data2Copy
for( int x = 0; x < 3; x++ )
{
    for( int y = 0; y < 3; y++ )
    {
        data2Copy[x][y]=data2[x][y];
        //cout << "data2Copy[x][y]=" << data2Copy[x][y]<<'\n';
    }
}
//---копируем data2 в data2Copy
 
 
//---
int UniqueNumberCounter=0; //Счетик для кол-ва уникальных чисел
double UniqueNumber=0;  //хранит текущее число 
for( int x = 0; x < 3; x++ )
{
    int y=0;    
    while(y < 3)
    {
Metka1:
//-------------------       
        UniqueNumber=data2[x][y]; // читаем  UniqueNumber из data2
        if(data2Copy[x][y]==0) //было в анализе?
        {
            //да
            y++;
            goto Metka1;// берем следующее число из data2
        }
//нет,пробегаем весь data2Copy и записываем нули если попались равные UniqueNumber
            for( int x1 = 0; x1 < 3; x1++ )
            {
                for( int y1 = 0; y1 < 3; y1++ )
                {
            //-------------------
                    if(data2Copy[x1][y1]==UniqueNumber)
                    {
                        UniqueNumberCounter++;
                        data2Copy[x1][y1]=0;
                    }
            //-------------------   
                }
            }
//-------------------   
y++;
    }
}
//---
//=======находим количество различных чисел в data2
cout << "UniqueNumberCounter=" << UniqueNumberCounter<<'\n';

#include <iostream>
#include <algorithm>
#include <iterator>
#include <set>
 
// возвращает количество различных элементов в матрице
template<typename T, int row, int col>
auto dn(T(&mtx)[row][col])
{
    std::set<T> st(*mtx, *mtx + row * col);
    return st.size();
}
 
// печать матрицы
template<typename T, int row, int col>
void print(T(&mtx)[row][col])
{
    for (int i = 0; i < row; ++i)
    {
        std::copy(*mtx + i * col, *mtx + (i + 1) * col, std::ostream_iterator<T>(std::cout, "  "));
        std::cout << '\n';
    }
    std::cout << '\n';
}
 
 
int main()
{
    int const row = 3, col = 2;
    int mtx[row][col] = { { 1, 2 }, { 3, 4 }, { 2, 5 } }; // матрица может быть любого типа: int, double и т.д.
    print(mtx); // чтобы не перепутать размерность
    std::cout << dn(mtx) << std::endl;
}

#include <iostream>
 
 
int main()
{
    int const row = 3, col = 3;
    double mtx[row][col] = { { 1., 2., 2. },{ 3., 4., 5. },{ 5., 5., 6. } };
    int cnt = 0;
    for (int i = 0; i < row * col; ++i)
    {
        int j = i - 1;
        for ( ; j >= 0; --j)
        {
            if ((*mtx)[i] == (*mtx)[j])
            {
                break;
            }
        }
        if (-1 == j)
        {
            ++cnt;
        }
    }
 
    std::cout << cnt << std::endl;
}

const int Size=3;
double data2[Size][Size]={{ 1., 2., 2. },{ 3., 4., 5. },{ 5., 5., 6.}};
double data2Copy[Size][Size];

//=======находим количество различных чисел в data2
//---копируем data2 в data2Copy
for(int x=0;x<Size;x++)
{
    for(int y=0;y<Size;y++)
    {
        data2Copy[x][y]=data2[x][y];
    }
}
 
int UniqueNumberCounter=0;  //Счетик для кол-ва уникальных чисел
double UniqueNumber=0;      //хранит текущее число 
for( int x = 0; x < Size; x++ )
{
    int y=0;    
        while(y < Size)
        {
            if(data2Copy[x][y]!=0) // по такому адресу во втором массиве не ноль?
            {
            bool BlokRazsres=0; //блокирует разрешение на запись уник числа
                for(int x1=0;x1<Size;x1++)
                {
                    for(int y1=0;y1<Size;y1++)
                    {                   
                        if(data2Copy[x1][y1]==data2[x][y]) // по такому адресу во втором массиве это число?  
                        {
                            data2Copy[x1][y1]=0;//да,записать туда ноль                       
                                if(!BlokRazsres)
                                {
                                    UniqueNumberCounter++;//увеличить счетчик уникальных чисел на 1.
                                    BlokRazsres=1; // заблокировать счетчик
                                }
                        }
                    }
                 }
             }
        y++;
        }
}
//=======находим количество различных чисел в data2

int j;
for(j=i-1; j>=0; j--) ...

#include <time.h> 
#include <stdio.h> 
 
clock_t start, end;
start = clock();
...
end = clock();
printf("time %.4f second(s)\n", ((double) end - start) / ((double) CLOCKS_PER_SEC));