How to optimize this program? - c++

Question

I am attending a coding competitions in February and I'm looking at last years problem set. The task I am trying to do is this. As input i am given an integer N(maximum 10,000,000), and a string S of length N. The string consists of only the letters 'x', 'y' and 'z'.
These letter are all 'commands'. You start out with a word consisting of only the letter 'A'. If you get a command 'x' you will add an 'A' to the back of you word.
Command'y' will add a 'B' at the front of the word. And 'y' will flip the word. So an input of N = 3, and S = "xyz", will make the word be "AAB". x: add 'A' ,y: add 'B' and z: flip the entire word.
This entire thing has to be done in under 2 seconds, which seems to be a problem for me to achieve.
I hope all that was understandable...
Well, the solution explanation said that a double-ended queue would be the most efficient way to do this, but it I can't get it any lower than a little more than 10 seconds execution time. Could someone please help me find a way to optimize this code.
using namespace std;
int main() {
int num = 10000000;
string commands = "";
bool reversed = false;
deque<char>word = { 'A' };
// just for generating the input. The real program would not need this
for (int i = 0; i < num / 5; i++) {
commands += "xyzxy'";
}
//cin >> num >> commands;
for (int i = 0; i < num; i++) {
if (commands.at(i) == 'x') { //If the command is 'x' add an A at the back
if (!reversed)
word.push_back('A');
else // if it the word is reversed, reverse the command
word.push_front('A');
}
else if (commands.at(i) == 'y') { //If the command is 'y', add a 'B' at the front
if (!reversed)
word.push_front('B');
else // if it the word is reversed, reverse the command
word.push_back('B');
}
else if (commands.at(i) == 'z') { // If the command is 'z' set the status to reversed/!reversed
reversed = !reversed;
}
}
if (reversed)
reverse(word.begin(), word.end());
for (int i = 0; i < word.size(); i++) { // print out the answer
cout << word.at(i);
}
system("pause");
return 0;
}
Thank you!

Answer 1

Usually we expect that a server executes 10^6 commands per second. Bearing in mind that N=10,000,000 and time limit is 2 seconds, O(n) complexity is required.
You can achieve that using the following technique:
Use a double linked list.
Use a boolean variable, for example flag, that gives true if result string starts at the front of linked list and false if the string starts at the back of the linked list.
For each character of input string push_back if given character is x, push_front if given character is y and change the value of flag.
When reading input finishes, print the string respectively to flag value.
Complexity: O(n)

Answer 2

The trick has two parts.
Use std::deque, which is optimized for insertion at both ends of the container.
Do not flip the word for the 'z' input. Instead, keep track of how many times 'z' was read, and change the code that adds A and B so that if the number of times is odd, the character is added to the other end of the word.
At the conclusion of the input, flip the string just once, if the final count is odd.
The main trick is to avoid wasting time flipping the string over and over again. You only need to flip it at most once.

Answer 3

Observation: push_back on vector is faster than both push_back and push_front on deque.
If you use two vectors (front and back) and treat the front as if it is reversed, then you can also eliminate all of the 'if (reverse)...' stuff by using push_back on the back vector for the x, push_back on the front vector for the y, and swapping the vectors when you hit a z.
Then when outputting the result, do a reverse iteration through the front vector and a forward iteration through the back vector.
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <string>
#include <chrono>
int main(int argc, char* argv[])
{
auto fileIn = std::ifstream{"flip.in"};
int commandSize;
std::string commands;
fileIn >> commandSize >> commands;
std::vector<char> wordFront;
std::vector<char> wordBack;
wordFront.push_back('A');
auto start = std::chrono::high_resolution_clock::now();
for (auto v : commands)
{
switch(v)
{
case 'x':
wordBack.push_back('A');
break;
case 'y':
wordFront.push_back('B');
break;
case 'z':
std::swap(wordFront, wordBack);
break;
}
}
auto finish = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> elapsed = finish - start;
std::cout << "Elapsed time (secs): " << elapsed.count() << std::endl;
auto fileOut = std::ofstream{"flip.out"};
std::for_each(crbegin(wordFront), crend(wordFront), [&fileOut](auto v){ fileOut << v; });
std::for_each(cbegin(wordBack), cend(wordBack), [&fileOut](auto v){ fileOut << v; });
}
It didn't make a positive difference on my machine, but you could also reserve some space on the front and back vectors before you start building the word.