Wataru

У вас переменная s локальная в main(), а вы ее в A() используете.

Сделайте A() возвращающей среднее (и это должен быть не int а float). Заведите переменную для суммы внутри A. А функция PrintS() должна будет принимать это среднее для печати. А то и вообще удалите PrintS - функция для одной операции вывода несет мало смысла.

Не получается остановиться только на двух множителях.

Приведите ваш код, который не останавливается. По идее, достаточно в него вставить return после нахождения первой пары множителей.

for(d=0; d < n; d++)
  x[i] = rand();
 printf("%d", x[i]);

Цикл по d а присваивание в x[i]. Еще скобок нет, printf выполнится только один раз после цикла.

Еще вы не выводите массив после сортировки, как вы вообще собираетесь понимать, что ваша программа работает?

В самой сортировке (циклы по i и j), вроде, ошибок нет.

Не совсем понял вопрос, но, если вы имеете ввиду переписывания указателя на удаляемый элемент, то тут 2 подхода.

1) Если функция рекурсивная, то пусть она возвращает новую голову списка. Если текущий элемент удалять не надо, то перепишите next на результат вызова от этого next и возвращайте текущую запись. Если удалять надо, то отчистите память и возвращайте next.

2) Если функция работает циклом, что предпочтительнее, то вы можете просто помнить предыдущий элемент списка. Двигайте 2 указателя параллельно.

prev = cur;
cur = cur->next;

Надо проверять на выход за границы массива. В некоторых языках программа может крэшнутся, в других может работать неправильно, читая какой-то мусор.

Можно писать так:

if ((i > 0 && a[i-1][j] > a[i][j]) || (i < n-1 &&  a[i+1][j] > a[i][j])) {
  // текущий элемент меньше хотя бы одного соседа в том же столбце.
}

еще можно так:

if ((i == 0 || a[i-1][j] > a[i][j]) && (i == n-1 ||  a[i+1][j] > a[i][j])) {
  // текущий элемент меньше всех соседей в том же столбце.
}

Комбинируя условия на циклы через || и && можно составить любое нужное вам условие, которое смотрит только на существующих соседей. Но тут важен порядок операций. В C++ (да и почти везде, на самом деле) условия выполняются слева направо и прекращают выполнение, как только результат становится известен. Вот, в первом примере сначала идет проверка на i>0 а потом обращение к массиву через логическое И. Поэтому, если программа будет обрабатывать первый элемент в строке уже на первом условии она заметит, что все условие обязательно false, ведь там стоит &&. И условие с обращением к массиву не будет произведено никогда.

Алгоритм сортировочной станции. Можно переключиться на английскую версию вики, там есть детальный пример, и псевдокод.

Если же от вас требуется что-то более самостоятельное, то делайте так - найдите в строке операцию с наименьшим приоритетом (ту, которая будет выполнена последней). Рекурсивно выведите обратную польскую запись для левой и правой половины, потом выводите/выполняйте операцию.

Чтобы найти операцию - проходитесь по строке, считая сколько сейчас открыто скобок. Запомните позицию самого правого встреченного "+"/"-" и "*"/"/". Если ничего не нашли - значит можно откусить внешнюю пару скобок (если скобок нет, то вся строка - число). Иначе, если есть + или - - это та самая последняя операция. Если таковой нет - то будет * или / - берите ее.

Это работает за квадрат в отличии от алгоритма по ссылке, но зато пишется элементарно.

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

Фактически, тут 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;

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

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

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, то надо завершиться, сообщив пользователю о слишком большой размерности.