Временной шаг заполнения матрицы

Доброго времени суток. У меня такого рода не задачка) Писал программку которая считает значения элементов матрицы, с граничными условиями, и заданной формулой (метод сеток). Так вот у меня возник такой вопрос, как можно этот самый временной шаг сделать для элементов i, например 1, а для элементов j = 2...Суть в том чтобы за 2 временных шага в элементе i рассчитывалось 2 точки(или два элемента) , а для j только один. Т.е. чтобы шло опережение расчётов по i в 2 раза) Если кто сталкивался, или есть предложения, подскажите пожалуйста, я что-то не могу сообразить.
Вот программка:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace lab1
{
class Program
{
static void Main()
{
int f0 = 1;// граничное условие
int N = 10, M = 10;
double[,] a = new double[N, M]; //массив 1
double[,] b = new double[N, M]; //массив 2


for (int i = 0; i < N; i++)
{
for (int j = 0; j < M; j++)
{
{//здесь записываются граничные условия в матрицу
a[i, 0] = f0;
a[i, M - 1] = f0;
a[0, j] = f0;
a[N - 1, j] = f0;
};
}
}
Console.WriteLine("Начальные условия:");
for (int i = 0; i < N; i++)
{
for (int j = 0; j < M; j++)
//ну тут понятно, пробежались ещё раз по матрице и вывели значения элементов матрицы в консоли.
Console.Write(a[i, j] + " ");
Console.WriteLine();

}
for (int s = 0; s <= 3; s++) // это цикл, которым собственно я описал временные шаги как для i, так и для j вместе. тут понятно.
{
for (int i = 1; i < M - 1; i++) // тут идёт заполнение внутренних элементов матрицы по нижней формуле.
{
for (int j = 1; j < N - 1; j++)
{
//формула, которая рассчитывает внутренние элементы матрицы
b[i, j] = (a[i, j + 1] + a[i, j - 1] + a[i + 1, j] + a[i - 1, j]) / (double)4;
}
}

//делается симметричный рассчёт и записывается значение в массив а.
for (int i = 1; i < M - 1; i++)
for (int j = 1; j < N - 1; j++)
a[i, j] = b[i, j];
//дальше вывод
Console.WriteLine("Ответ:");
for (int i = 0; i < N; i++)
{
for (int j = 0; j < M; j++)
{
Console.Write(String.Format("{0:f2}", a[i, j]));
Console.Write(" ");
}
Console.WriteLine();
}
}
Console.ReadLine();


}
}
}
хотелось бы вот такой алгоритм
1 1 1 1 1 1 1 1 1 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 1 1 1
Затем
1 1 1 1 1 1 1 1 1 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 1 1 1


Затем
1 1 1 1 1 1 1 1 1 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 1 1 1
Может поможет кто?)

0