Присутствуют ли элементы матрицы А в матрице В

int **F(int **A, int**B, int na, int ma, int nb, mb)
{ 
   int **C = new *int[ma];
   for(int j=0; j<na; j++)
      C[j] = new int (ma);
   for(int ia=0; ia < ma< ia++)
      for(int ja=0; ja<ma; ja++) {
         int e = A[ia][ja];
         int ib, jb;
         for(ib=0; ib< nb; ib++) {
             for(jb=0; jb< mb; jb++)
                 if (e==B[ib][jb]) break;
             if (jb< mb) break;
         }
         C[ia][ja] = (ib < nb) ? 1 : 0;
      }
   return C;
}

#include <iostream>
#include <random>
//
// Создание матрицы
//
int ** Create( size_t n, size_t m ) {
    int ** M = new int * [n];
    for ( size_t i = 0; i < n; ++i ) {
        M[i] = new int [m];
    }
    return M;
}
//
// Удаление матрицы
//
void Free( int ** M, size_t n ) {
    for ( size_t i = 0; i < n; ++i ) {
        delete [] M[i];
    }
    delete [] M;
}
//
// заполнение матрицы случайными числами из диапазона [10, 50] -----------
//
void FillRandomNumbers(int **matrix, const size_t rows, const size_t columns)
{
    std::random_device rd;
    std::uniform_int_distribution<> dist(10, 50);
    for (size_t row=0; row < rows; row++)
        for (size_t column=0; column < columns; column++)
            matrix[row][column] = dist(rd); // присваиваем СЧ
}
//
//-------- Печать матрицы ------------------------------------------------
//
void Print( int ** M, size_t n, size_t m ) {
    for ( size_t i = 0; i < n; ++i ) {
        for ( size_t j = 0; j < m; ++j ) {
            std::cout<<M[i][j]<<' ';
        }
        std::cout<<std::endl;
    }
}
 
int ** Process(int ** A, int ** B, int arows, int acols, int brows, int bcols) {
    auto C = Create(arows, acols);
 
    for (int ia = 0; ia < arows; ia++)
        for (int ja = 0; ja < acols; ja++) {
            int e = A[ia][ja];
            int ib, jb;
            for (ib = 0; ib < brows; ib++) {
                for (jb = 0; jb < bcols; jb++)
                    if (e == B[ib][jb]) break;
                if (jb < bcols) break;
            }
            C[ia][ja] = (ib < brows) ? 1 : 0;
        }
    return C;
}
int main(){
    using namespace std;
    random_device rd;
    uniform_int_distribution<> dist_m_size(5, 10);
    
    int arows = dist_m_size(rd);
    int acols = dist_m_size(rd);
    auto a = Create(arows, acols);
    FillRandomNumbers(a, arows, acols);
    Print(a, arows, acols);
    cout << endl;
    
    int brows = dist_m_size(rd);
    int bcols = dist_m_size(rd);
    auto b = Create(brows, bcols);
    FillRandomNumbers(b, brows, bcols);
    Print(b, brows, bcols);
    cout << endl;
    
    auto c = Process(a, b, arows, acols, brows, bcols);
    Print(c, arows, acols);
    cout << endl;
    
    Free(c, arows); 
    Free(b, brows);
    Free(a, arows);
}

#include <iostream>
#include <random>
#include <algorithm>
 
template<typename T>
class Matrix {
public:
    Matrix() : height(0), width(0), data(nullptr) {}
    Matrix(std::size_t height, std::size_t width) : height(height), width(width), data(new T[height * width]{}) {}
    Matrix(const Matrix<T> &other) : height(other.height), width(other.width), data(new T[height * width]{}) {
        for (std::size_t i = 0, end = height * width; i != end; ++i) {
            data[i] = other.data[i];
        }
    }
    Matrix(Matrix<T> &&other) noexcept : Matrix() {
        swap(*this, other);
    }
    Matrix<T> &operator=(Matrix<T> other) noexcept {
        swap(*this, other);
        return *this;
    }
    ~Matrix() {
        delete [] data;
    }
    friend void swap(Matrix<T> &a, Matrix<T> &b) noexcept {
        using std::swap;
        swap(a.height, b.height);
        swap(a.width, b.width);
        swap(a.data, b.data);
    }
    T &operator()(std::size_t row, std::size_t column) {
        return data[row * width + column];
    }
    const T &operator()(std::size_t row, std::size_t column) const {
        return data[row * width + column];
    }
    std::size_t getHeight() const {
        return height;
    }
    std::size_t getWidth() const {
        return width;
    }
private:
    std::size_t height;
    std::size_t width;
    T *data;
};
 
template<typename T>
std::ostream &operator<<(std::ostream &out, const Matrix<T> &m) {
    for (std::size_t i = 0, height = m.getHeight(); i != height; ++i) {
        for (std::size_t j = 0, width = m.getWidth(); j != width; ++j) {
            out.width(7);
            out << m(i, j);
        }
        out << '\n';
    }
    return out;
}
 
template<typename T, typename Generator>
Matrix<T> generate(std::size_t height, std::size_t width, Generator generator) {
    Matrix<T> result(height, width);
    for (std::size_t i = 0; i != height; ++i) {
        for (std::size_t j = 0; j != width; ++j) {
            result(i, j) = generator();
        }
    }
    return result;
}
 
template<typename T, typename Iterator>
Iterator insertSet(Iterator begin, Iterator end, const T &value) {
    auto position = std::lower_bound(begin, end, value);
    if (position != end && *position == value) {
        return end;
    }
    for (auto i = end; i != position; --i) {
        *i = *(i - 1);
    }
    *position = value;
    return ++end;
}
 
template<typename T, typename OutputIterator>
OutputIterator toFlattenSet(const Matrix<T> &m, OutputIterator destination) {
    OutputIterator begin = destination;
    OutputIterator end = begin;
    for (std::size_t i = 0, height = m.getHeight(); i != height; ++i) {
        for (std::size_t j = 0, width = m.getWidth(); j != width; ++j) {
            end = insertSet(begin, end, m(i, j));
        }
    }
    return end;
}
 
template<typename T, typename Iterator>
bool contains(Iterator begin, Iterator end, const T &value) {
    auto lowerBound = std::lower_bound(begin, end, value);
    return lowerBound != end && *lowerBound == value;
}
 
template<typename T>
Matrix<T> containsElements(const Matrix<T> &a, const Matrix<T> &b) {
    Matrix<T> result(a.getHeight(), b.getWidth());
    T *begin = new T[a.getHeight() * b.getHeight()];
    T *end = toFlattenSet(b, begin);
    
    for (std::size_t i = 0, height = a.getHeight(); i != height; ++i) {
        for (std::size_t j = 0, width = a.getWidth(); j != width; ++j) {
            result(i, j) = contains(begin, end, a(i, j));
        }
    }
 
    delete[] begin;
    return result;
}
 
int main() {
    std::random_device randomDevice;
    std::mt19937 randomGenerator(randomDevice());
    std::uniform_int_distribution<std::mt19937::result_type> distribution(1, 9);
    auto generator = [&]()->int{ return distribution(randomGenerator); };
 
    Matrix<int> a = generate<int>(3, 2, generator);
    Matrix<int> b = generate<int>(2, 3, generator);
 
    std::cout
            << "a:\n" << a << '\n'
            << "a:\n" << b << '\n'
            << "containsElements:\n" << containsElements(a, b) << '\n';
 
    return 0;
}