Wataru

Алгоритм тривиальный - перебрать все клетки матрицы двумя вложенными циклами. Проверить, что текущая клетка - локальный минимум (сравнить со всеми соседями). Если да, то надо сравнить ее с текущим кандидатом на максимум.

Фактически, тут 2 вложенные задачи: 1) Проверить, является ли значение локальным минимумом 2) Найти максимум в матрице (возможно игнорируя какие-то клетки).

Советую решить задачи раздельно с помощью функций.

Для первой задачи напишите функцию.

bool IsLocalMinumum(int a[][m], int n, int m, int i, int j);

Функция должна перебрать 4 варианта (прибавить/вычесть 1 из первого или второго индекса) и для каждого проверить: 1) сосед есть, т.е. не вышел за границу, 2) значение соседа меньше текущего. Если оба условия выполнились для какого-то направления - вы нашли "плохого" соседа. Текущая клетка не может быть минимумом. Сразу же возвращайте false. В конце функции всегда возвращайте true.

Вторая задача - тривиальна совсем. Можете выбрать максимум из просто одномерного массива? Теперь вместо одного цикла по массиву делайте 2 вложенных по матрице. Потом допишите туда условие, вызывающее вашу IsLocalMinimum. Если вершине не минимум - просто делайте пропускайте клетку. Буквально if (!IsLocalMinimum(a, n, m, i, j)) continue;

Вам надо построить хитрый граф.

Во-первых, все расстояния в графе будут не одно число, а пара - собственно, длина пути и количество поворотов. При суммировании двух длин складывайте их покомпонентно, при сравнении сравнивайте сначала длины, а потом количество поворотов. Теоретически, можно схлопнуть все назад в одно число, если считать 100000*<длина> + <количество поворотов>. Но могут быть спецэффекты, если пути очень сложные и имеюют более 100000 поворотов. Еще, опасайтесь переполнения.

Для каждой клетки сделайте 4 вершины, которые будут означать, что вы находитесь в этой клетке и "смотрите" в одну из 4-х сторон.

Создайте 4 ребера между соседними направлениями с длиной {0, 1} (длина 0, но 1 поворот). От каждой вершины создайте также ребро длинной {1, 0} (длина - 1, 0 поворотов) в вершину в соседней клетке с тем же направлением (от "верхней" из 4-х вершин сделайте ребро в "верхнюю" же вершину в клетке сверху. Аналогично по трем остальным направлениям).

Теперь кратчайший путь в этом графе будет то - что вам надо. Есть еще вопрос с начальными конечным направлением. Можно добавить в начальную и конечную клетки "центральную" вершину, в которая связанна ребрами длины {0, 1} (Важно сделать 1 поворот, иначе можно будет крутиться на месте через эту центральную вершину). Считайте, что эта вершина - "смотреть в пол". Вы начинаете в какой-то клетке, смотря в пол, и вам надо оказаться в другой клетке, опять же смотря в пол. Вы можете в клетке повернуться, или перейти в клетку впереди вас.

Поскольку тут уже разные длины ребер, обход в ширину уже не будет искать кратчайшее расстояние. Но можно использовать дейкстру/A*.

При реализации не надо даже хранить все вершины и ребра. Просто у вас теперь вершина вместо {x, y} будет описываться {x, y, d}. Вместо перебора 4-х направлений [-1,0],[0,-1],[0,1],[1,0] - вы делаете переход {x+dx[d],y+dy[d],d} или меняете d на (d+1)%d и (d+3)%4. И в очередях вы сохраняете не одно число, а пару {length, turns}. Для A* нужно еще прикидывать оставшуюся длину - ну вы по длине берите, что у вас уже есть, а по количеству поворотов берите 1, если у начала и конца разные направления.

Играясь с длинами ребер и их сравнениями вы можете, например, разрешать чуть более длинные пути, если в них сильно меньше поворотов. (например, можно обойти лабиринт по периметру, чем чуть короче но зиг-загами ходить внутри). Для этого длина ребра может быть length*K+turns.

Поскольку тут в 4-5 раз больше вершин, это будет работать в 4-5 раз медленнее.

Я правильно понимаю, что пользователь вводит от 1 до 3 чисел в строке и ожидает, что программа эти числа обработает и выведет результат? Иными, словами, программа реагирует на клавишу enter?

Можно читать символы по одному через getch(), пока не прочитаете '\n'. По пути нужно парсить числа. Если символ цифра - то умножйте текущее число на 10 и прибавляйте цифру (помните, что (int)'0' != 0. Но символы цифры, слава богу, идут подряд в алфавите). Если прочитали пробел - переходите к следующему числу. Или, чтобы обрабатывать всякие много пробелов, лишние символы и другие проблемы ввода - лучше прочитать сразу же всю строку через fgets() и потом в ней уже парсить числа.

Вы используете тип int. Для дробей нужно вещественное число float или double.

Выводить и читать его надо не через "%i", а через "%f" или "%lf".

Похоже, можно воспользоваться методом Create(r: System.Drawing.Rectangle) - судя по описанию - это то, что вам нужно, но я не уверен. Picture же можно сохранять методом Save.

Если не работает, то можно воспользоваться этим примером. Создайте Picture и рисуйте туда параллельно с рисованием на экран.

OpenMP работает только со стандартными циклами. У вас же инициализация по i, условие по x, итерация i++. OpenMP просто не умеет понять, сколько там итераций и как их можно распаралелить вообще.

Вам надо сделать так:

const int num_iterations=1000000;
const double h = (b-a)/num_iterations/2.0
x = a;
#pragma  omp  parallel  for  reduction (+:S)
for (int i = 0; i < maxi; i++)
{
    S = S + 1*(x/(x+1));
    x = x + h;
    S = S + 4*(x/(x+1));
    x = x + h;
    S = S + 1*(x/(x+1));
}

Удобнее, если зафиксировать сначала количество итераций, а не шаг h (шаг отсюда вычисляется). Потому что если отрезок нацело не делиться на h, то надо как-то это обрабатывать и вообще, а можно ли так считать?

Я добавил reduction (+:S) в инструкцию openMP, потому что вам надо подсчитать общую сумму же. Без этого каждый поток что-то насуммирует отдельно. Шарить S между потоками сложно - может быть data race.

Если рекурсия валится, то делайте не обход в глубину, а обход в ширину (с очередью).

Как вам уже сказали, вы не выделяете массив нужного размера. Можно вместо int a[1][1] делать int a[100][100], например, если вам известно, что массив не будет больше 100 строк и столбцов. Но, по хорошему, это надо обработать и, если пользователь ввел row == 101, то надо завершиться, сообщив пользователю о слишком большой размерности.

Во-первых, массив надо отсортировать по датам, если он у вас уже не упорядочен. В любом языке программирования есть какая-то функция sort(), которой можно как-то задать, как сравнивать сортируемые объекты (тут вам надо сравнивать только даты).

Ваше условие не очень понятно, но вот, как сгрупировать массив по датам:

st = 0; 
end = 0;
while (st < a.length) {
  end = st + 1;
  while(end < a.length && a[end].date == a[end-1].date) end++;
  console.log(a[st].date);
  for (st = st; st < end; st++) {
    console.log(a[st].id);
  }
}

Тут мы просто откусываем от массива кусок с одинаковыми датами, пока массив не кончится. Если вам нужна только последняя группа, то можно откусить только один раз с конца:

end = a.length - 1;
st = end - 1;
while (st >= 0 && a[st].date == a[st+1].date) st--;
console.log(a[end].date);
for (st = st+1; st <= end; ++st) 
  console.log(a[st].id);

Только учтите, этот код не работает на пустом массиве. Надо отдельно проверить этот случай.

x лежит от -2 до 2. y лежит от -4 до кривой f(x). У вас там похоже парабола f(x)=-x^2.

Разверните цикл, в котором вы проходитесь (по j) по вхождениям ключевого слова. Если удалять с конца, то индексы не съедут.