Сортировка динамической матрицы по первой строке используя лямбда-выражение

stable_sort(a, a + n, [&](int &i, int &j) { return a[0][i] < a[0][j]; });

#include <iostream>
#include <algorithm>
 
    using namespace std;
 
int main() {
    int n;
    cin >> n;
    int** a = new int*[2];
    for (int i = 0; i < 2; i++) {
        a[i] = new int[n];
    }
    cout << "Enter a matrix:\n";
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < n; j++) {
            cin >> a[i][j];
        }
    }
    stable_sort(a, a + n, [&](int &i, int &j) { //Здесь выдает ошибку
        return a[0][i] < a[0][j];
    });
    cout << "Output of the program:\n";
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < n; j++) {
            cout << a[i][j] << " ";
        }
        cout << "\n";
    }
    for (int i = 0; i < 2; i++) {
        delete[] a[i];
    }
    delete[] a;
    return 0;
}

#include <iostream>
#include <algorithm>
 
int main()
{
    std::cout << "Set Rows and Cols:\n";
    size_t rows, cols;
    std::cin >> rows >> cols;
    int* arr = new int[rows * cols];
 
    std::cout << "Enter a matrix:\n";
    for (size_t i(0); i < rows; ++i)
        for (size_t j(0); j < cols; ++j)
            std::cin >> arr[i * cols + j];
 
    std::stable_sort(arr, arr + rows * cols, [&](int i, int j) {
        return i < j;
    });
 
    std::cout << "Output of the program:\n";
    for (size_t i(0); i < rows; ++i) {
        for (size_t j(0); j < cols; ++j) {
            std::cout << arr[i * cols + j] << ' ';
        }
        std::cout << '\n';
    }
 
    delete[] arr;
    return 0;
}

    stable_sort(a, a + n, [](int* i, int* j) { 
        return i[0] < j[0];
    });

#include <iostream>
#include <algorithm>
 
using namespace std;
 
int main()
{
    int n=5;
 
    std::vector<std::vector<int>> a(n,std::vector<int>(n,0));
 
    for (int y = 0; y < a.size(); y++)
    {
        for (int x = 0; x < a[y].size(); x++)
        {
            a[y][x]=rand()%100;
        }
    }
 
    //вывод до сортировки
    for (int y = 0; y < a.size(); y++)
    {
        for (int x = 0; x < a[y].size(); x++)
        {
            cout << a[y][x] << "   ";
        }
        cout << "\n";
    }
 
    std::stable_sort(a.begin(), a.end(), [](auto& yl, auto& yr)
    {
        return yl[0] < yr[0];
    });
 
    //вывод после сортировки
    cout << "\n";
    for (int y = 0; y < a.size(); y++)
    {
        for (int x = 0; x < a[y].size(); x++)
        {
            cout << a[y][x] << "   ";
        }
        cout << "\n";
    }
 
    return 0;
}

41   67   34    0   69
24   78   58   62   64
 5   45   81   27   61
91   95   42   27   36
91    4    2   53   92
 
 5   45   81   27   61
24   78   58   62   64
41   67   34    0   69
91   95   42   27   36
91    4    2   53   92

int n=5;
std::vector<std::vector<int>> a(n,std::vector<int>(n,0));
std::stable_sort(a[1].begin(), a[1].end());

    int k{ 1 };// индекс строки
    stable_sort(a[k], a[k] + n, [](int i, int j) {
        return i < j;
    });

for (int i = 0; i < n; i++) {
    for (int j = n - 1; j > i; j--) {
        if (a[0][j] < a[0][j-1]) {
            swap(a[0][j], a[0][j-1]);
            swap(a[1][j], a[1][j-1]);
        }
    }
}

#include <iostream>
#include <algorithm>
 
using namespace std;
 
int main()
{
    size_t x_max=5;//столбцы
    size_t y_max=3;//строки
 
    using T=int;
    std::vector<std::vector<T>> matrix(y_max,std::vector<T>(x_max,T(0)));
 
    //заполняем рандомно
    for(auto& line:matrix)
    {
        for(auto& val:line)
        {
            val=rand()%10;
        }
    }
 
    //вывод до сортировки
    for(const auto& line:matrix)
    {
        for(auto& val:line)
        {
            cout << val << "  ";
        }
        cout << "\n";
    }
 
    //хотим сортировать по строке с индексом 1
    const size_t sort_line_index=1;
 
    if(sort_line_index<y_max)
    {
        //связь индекс-значение
        struct s_index_keeper
        {
            size_t index=0;
            T value=0;
        };
 
        //массив, который запомнит после сортировки, где были индексы
        std::vector<s_index_keeper> order;
 
        //заполняем order
        order.resize(x_max);
        for(size_t x = 0; x < order.size(); x++)
        {
            order[x].index=x;
            order[x].value=matrix[sort_line_index][x];
        }
 
        //сортируем order
        std::stable_sort(order.begin(), order.end(), [](auto& l, auto& r)
        {
            return l.value < r.value;
        });
 
        //теперь каждую строку матрицы нужно расставить
        //в соответствии с порядком индексов в order
        for(auto& line:matrix)
        {
            //делаем копию строки
            const auto line_copy=line;
 
            //расставляем значения в текущей строке из копии
            for (size_t x = 0; x < order.size(); x++)
            {
                line[x]=line_copy[order[x].index];
            }
        }
 
        //вывод после сортировки
        cout << "\n";
        for(const auto& line:matrix)
        {
            for(auto& val:line)
            {
                cout << val << "  ";
            }
            cout << "\n";
        }
    }
 
    system("pause");
    return 0;
}

stable_sort(a, a + n, [](int* i, int* j) {
        return *i < *j;
    });

    std::stable_sort(a.begin(), a.end(), [](auto& yl, auto& yr)
    {
        return yl[0] < yr[0];
    });