Какой самый оптимальный алгоритм для решения следующей задачи? [закрыто] ⇐ C++

[Anonymous]

Мне нужно решить следующую задачу конкурентного программирования: < /p>

Пирамида состоит из n горизонтальных слоев блоков: первый слой содержит n блоков, второй слой содержит блоки N-1 и т. Д., До N-й-слоя, который содержит отдельный блок. Каждый блок обладает определенной силой, выраженной в виде положительного целого числа (определяется различными факторами, такими как тип материала, плотность и т. Д.). < /P>
Поскольку первый слой пирамиды уже построен, он остается неизменным. Каждый из следующих слоев N -1 имеет один из двух типов: min или max, а блоки на нем расположены следующим образом: < /p>

Для минимального слоя: сила каждого блока равна минимуму прочности двух блоков под его максимумом. Под ним. < /li>
< /ul>
Вы должны определить силу блока в верхней части пирамиды, учитывая структуру первого слоя и тип каждого из следующих слоев N - 1. < /p>
Входной формат < /p>
СОТВЕТСТВЕННЫЙ ЛИНИЯ В СЛАДНАЯ ЛИНИЯ В СЛАНГАЦИОНЕМ В СЛАНГИРЕМАМИ 1. Pyramid. < /p>
Вторая строка содержит n положительных целых чисел r1, r2,…, rn (1≤ri≤n) - сильные стороны блоков в первом слое. < /p>
Третья строка содержит символы N --1 из набора {m, m}, описывание слоев. Персонаж I-TH описывает (I+1)--th-слой: < /p>

m-максимальный слой < /li>
m-мин слоя < /li>
< /ul>
формат выхода < /p>
Уровень. < /p>
Ограничения:

ограничение срока составляет 4 секунды

ограничение пространства составляет 512MB < /p>
Примеры < /p>
test 1:

input < /p>
7 < /p>

4 4 4 4 4 4 4 4 3 4 4 4 4 4. /> mmmmmmm < /p>
output < /p>
5 < /p>
test 2:

input < /p>
2 < /p>
2 < /p>
m < /p>
< /p>
m < /p>
2 < /p>
m < /p>
2 < /p>
m < /p>
/> 1 < /p>
< /blockquote>
Я записал код C ++, который создает вектор с двойным списком (V) на основе рискованных шаблонов элементов (не декоративное снижение). Идея состоит в том, что для каждого связанного списка мы можем безопасно удалить его хвост или головки в зависимости от того, является ли текущая операция Min или Max. (getDir = 0). < /p>
Если следующий уровень создается как максимум в двух блоках от нижнего уровня:
-Удалите головы не декоративных связанных списков (getDir = 1)
-удалить хвосты уменьшенных связей (getDir = 0). Если: < /p>

Оба уменьшаются, а голова правого списка меньше или равна хвосту левого списка, или < /li>
Оба не имеют декорации, а голова правого списка больше или равна хвосту в левом списке. {{2,2,2}; ограничение по времени.
, не могли бы вы, чтобы вы могли бы выплести либо в подплоти, либо предложить лучше?#include
using namespace std;

struct Node {
int data;
Node* next;
Node* prev;
Node(int val) : data(val), next(nullptr), prev(nullptr) {}
};

class LinkedList {
private:
Node* head;
Node* tail;
int length;
bool dir;

public:
LinkedList() : head(nullptr), tail(nullptr), length(0), dir(true) {}

LinkedList(const LinkedList&) = delete;
LinkedList& operator=(const LinkedList&) = delete;

LinkedList(LinkedList&& other) noexcept {
head = other.head;
tail = other.tail;
length = other.length;
dir = other.dir;
other.head = other.tail = nullptr;
other.length = 0;
}

LinkedList& operator=(LinkedList&& other) noexcept {
if (this != &other) {
clear_safe();
head = other.head;
tail = other.tail;
length = other.length;
dir = other.dir;
other.head = other.tail = nullptr;
other.length = 0;
}
return *this;
}

void setDir(bool d) { dir = d; }
bool getDir() const { return dir; }

void append(int val) {
Node* newNode = new Node(val);
if (!head) {
head = tail = newNode;
} else {
tail->next = newNode;
newNode->prev = tail;
tail = newNode;
}
length++;
}

void prepend(int val) {
Node* newNode = new Node(val);
if (!head) {
head = tail = newNode;
} else {
newNode->next = head;
head->prev = newNode;
head = newNode;
}
length++;
}

void pop_head() {
if (!head) return;
Node* toDelete = head;
head = head->next;
if (head) head->prev = nullptr;
else tail = nullptr;
delete toDelete;
length--;
}

void pop_tail() {
if (!tail) return;
Node* toDelete = tail;
tail = tail->prev;
if (tail) tail->next = nullptr;
else head = nullptr;
delete toDelete;
length--;
}

void clear_safe() {
while (head) pop_head();
}

Node* getHead() const { return head; }
Node* getTail() const { return tail; }
int getLength() const { return length; }

int getHeadData() const {
return head ? head->data : -1;
}

int getTailData() const {
return tail ? tail->data : -1;
}

void merge(LinkedList&& other) {
if (!other.head) return;
if (!head) {
head = other.head;
tail = other.tail;
length = other.length;
dir = other.dir;
} else {
tail->next = other.head;
other.head->prev = tail;
tail = other.tail;
length += other.length;
}
other.head = other.tail = nullptr;
other.length = 0;
}

~LinkedList() {
clear_safe();
}
};

int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector v;
LinkedList temp;
bool flag = true;
int inter;
cin >> inter;
if (n == 1) {
cout inter;
if (inter < temp.getTail()->data) {
flag = false;
temp.setDir(false);
}
temp.append(inter);
for (int i = 0; i < n - 2; i++) {
cin >> inter;
if (flag) {
if (inter >= temp.getTail()->data) {
temp.append(inter);
} else {
v.push_back(std::move(temp));
temp = LinkedList();
temp.setDir(false);
flag = false;
temp.append(inter);
}
} else {
if (inter < temp.getTail()->data) {
temp.append(inter);
} else {
v.push_back(std::move(temp));
temp = LinkedList();
temp.setDir(true);
flag = true;
temp.append(inter);
}
}
}
v.push_back(std::move(temp));
string s;
cin >> s;
for (char op : s) {
if (v.size() > 1) {
for (int i = 0; i < v.size() - 1; i++) {
int left_tail = v.getTailData();
int right_head = v[i+1].getHeadData();
if (op == 'm') {
if (left_tail < right_head) {
v.append(left_tail);
} else {
v[i+1].prepend(right_head);
}
} else {
if (left_tail >= right_head) {
v.append(left_tail);
} else {
v[i+1].prepend(right_head);
}
}
}
}
vector non_empty;
for (auto& run : v) {
if (run.getLength() > 0) {
if (op == 'M') {
if (run.getDir()) {
run.pop_head();
} else {
run.pop_tail();
}
} else {
if (run.getDir()) {
run.pop_tail();
} else {
run.pop_head();
}
}
if (run.getLength() > 0) {
non_empty.push_back(std::move(run));
}
}
}
if (non_empty.empty()) {
break;
}
v = move(non_empty);
vector merged;
merged.push_back(std::move(v[0]));
for (int i = 1; i < v.size(); i++) {
LinkedList& current = v;
LinkedList& last = merged.back();
bool canMerge = false;
if (last.getDir() == current.getDir()) {
if (last.getDir()) {
if (last.getTailData() = current.getHeadData()) {
canMerge = true;
}
}
} else if (last.getHeadData() == last.getTailData()) {
if (current.getDir() && last.getTailData() = current.getHeadData()) {
canMerge = true;
last.setDir(false);
} else if (current.getHeadData() == last.getTailData()) {
canMerge = true;
if (last.getTailData()

Подробнее здесь: https://stackoverflow.com/questions/797 ... owing-task