Matrix with changing data and time steps

  

To calculate the temperature of the cell (1,6), use the adjacent cells, but previously you calculated the cell (1,5), and instead of using the temperature of (1,5) before the calculation, the sum after said calculation giving the wrong result.

Normal, in each pass you are writing the values, you can not use the values previous to the calculation if you calculate the value when you update it. You need a copy of the values before calculation. My advice is to use a multiple buffer .

To implement a double buffer I would use an update function that received two matrices: the reference (data that will not be changed) and the calculation (data that will be written):

constexpr int N = 20;   
constexpr int M = 10;
constexpr int A = 2 * N + 1;
constexpr int B = 2 * M + 1;
using Matriz = int[A][B];

void actualiza(const Matriz &origen, Matriz &destino)
{
  for( int i = 1; i < ( A - 1 ); i++ ) {
    for( int j = 1; j < ( B - 1 ); j++ ) {
      int n = i - 1;
      int e = j + 1;
      int s = i + 1;
      int o = j - 1;
      int T = ( 4 * ( origen[n][j] + origen[s][j] + origen[i][o] + origen[i][e] ) +
                    ( origen[n][e] + origen[n][o] + origen[s][e] + origen[s][o] ) ) / 10;

      destino[i][j] += T;
    }
  } 
}

I've made some changes to your code to make it work; firstly I have changed your values N , M , A and B to constant expressions to ensure that they are available at compile time and thus be able to define the type Matriz , which will be a training 1 of two dimensions AxB , this is the type that will be passed to the function actualiza that your algorithm follows.

In the second place I changed the update instruction you were using, since you used the operator += using the same data along with another value on your left and right, you probably did not want this, because if (for example) in the cell (j,i) you had the value 7 and in T the value 10 the result would be:

matriz(j,i) += 7 + 10; // matriz(j,i) es 7
matriz(j,i) += 17;     // matriz(j,i) es 7
// matriz(j,i) obtiene el valor 24

In order for the multiple buffer to work you have to exchange each matrix in each call to actualiza .

Other things to consider.

You are using variables to define the size of formations 1 , it is required that the size of the formations be a constant value. If you use a variable and compile it means you are using a compiler extension known as VLA ( Variable Lenght Array ), being a compiler extension means that if you change the compiler it is likely that the code stops compiling, read this thread to have more details about it.

With that in mind, your code could look like this:

#include <iostream>

constexpr int N = 20;   
constexpr int M = 10;
constexpr int A = 2 * N + 1;
constexpr int B = 2 * M + 1;
using Matriz = int[A][B];

void actualiza(const Matriz &origen, Matriz &destino)
{
  for( int i = 1; i < ( A - 1 ); i++ ) {
    for( int j = 1; j < ( B - 1 ); j++ ) {
      int n = i - 1;
      int e = j + 1;
      int s = i + 1;
      int o = j - 1;
      int Temperatura = ( 4 * ( origen[n][j] + origen[s][j] + origen[i][o] + origen[i][e] ) +
                              ( origen[n][e] + origen[n][o] + origen[s][e] + origen[s][o] ) ) / 10;
      destino[i][j] += Temperatura;
    }
  } 
}

int main()
{
    Matriz matriz1{}, matriz2{};

    for( int j = 0; j < B; j++ ) {      
        matriz1[0][j] = 20;
        matriz2[0][j] = 20;
    }

    constexpr int pasos = 10;
    for (int paso = 0; paso != pasos; ++paso)
    {
        if (paso % 2)
            actualiza(matriz1, matriz2);
        else
            actualiza(matriz2, matriz1);
    }

    std::cout << matriz1[N + 1][M + 1] << '\n'
              << matriz2[N + 1][M + 1];

    return 0;
}

Notice that to initialize the matrices we have used keys ( {} ), this causes all its elements to be initialized to zero ( 0 ), so that when assigning the initial values a single loop is necessary for the cells higher.

The buffers exchange loop has made it as simple as possible, but you can choose any other implementation.