Graphical editor programming challenge solution time limit exceeded c++ [closed] - c++

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 6 years ago.
Improve this question
Below is my solution to the graphical editor programming challenge, detailed here(which has taken me 3 days to solve). While the output is correct, It keeps producing a time_limit_exceeded error. I think that the problem is in the way I've implemented the flood_fill function which gets called when the user enters "F" as the first letter of a line. I would appreciate it if someone explained what is so inefficient about my code and how i could improve it. My code is below:
// graphical_editor.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <iostream> //provides access to cout and cin
#include <string> //Always import <string> if piping std input to a string in .net
#include <vector>
#include <fstream>
using std::ofstream;
using std::cin;
using std::cout;
using std::string;
using std::vector;
//This is where we store the pixels of the image
static vector<vector <string>> image_array;
ofstream myfile;
//our definition of an X,Y coordinate pair.
typedef struct point {
int x_coordinate, y_coordinate;
};
void initialise_image();
void clear_image();
void save_image(string file_name);
int get_image_width();
int get_image_height();
void color_pixel(int x, int y, string color);
void color_point(point p, string color);
void color_vertical_line(int x, int y1, int y2, string color);
void color_horizontal_line(int x1, int x2, int y, string color);
void color_box(int x1, int x2, int y1, int y2, string color);
void flood_fill(point p, string color);
vector<point> get_matching_neighbours(point p, string color);
int main()
{
string command; //first letter of a given line
myfile.open("example.txt");
while (cin >> command) {
//application terminates when command is X
if (command.compare("X") == 0) {
return 0;
} else if (command.compare("I") == 0) {
initialise_image();
}
else if (command.compare("S") == 0) {
string file_name;
cin >> file_name;
save_image(file_name);
}
else if (command.compare("L") == 0) {
string color;
point p;
cin >> p.x_coordinate >> p.y_coordinate >> color;
color_point(p, color);
}
else if (command.compare("V") == 0) {
string color;
int x, y1, y2;
cin >> x >> y1 >> y2 >> color;
color_vertical_line(x, y1, y2, color);
}
else if (command.compare("H") == 0) {
string color;
int x1, x2, y;
cin >> x1 >> x2 >> y >> color;
color_horizontal_line(x1, x2, y, color);
}
else if (command.compare("K") == 0) {
string color;
int x1, x2, y1, y2;
cin >> x1 >> x2 >> y1 >> y2 >> color;
color_box(x1, x2, y1, y2, color);
}
else if (command.compare("F") == 0) {
string color;
point p;
cin >> p.x_coordinate >> p.y_coordinate >> color;
flood_fill(p, color);
}
else if (command.compare("C") == 0) {
clear_image();
}
}
return 0;
}
void initialise_image()
{
/*read parameters height and width*/
int width, height;
cin >> width >> height;
/*first we create a vector of vectors (numRows+1)x(numColumns matrix+1). */
image_array.clear();
for (int i = 0; i < width+ 1; i++) {
image_array.push_back(vector<string>());
}
/*then we initialize each element of it one by one*/
for (int colNo = 0; colNo < width + 1; colNo++) {
for (int rowNo = 0; rowNo < height + 1; rowNo++) {
image_array[colNo].push_back("O");
}
}
}
void clear_image() {
/*we initialize each element of it one by one*/
for (int y = 1; y < get_image_height()+1 ; y++) {
for (int x = 1; x < get_image_width()+1; x++) {
image_array[x][y] = "O";
}
}
}
void save_image(string file_name) {
myfile << file_name << "\n";
//cout << file_name << "\n";
for (int y = 1; y < get_image_height()+1; y++) {
for (int x = 1; x < get_image_width()+1; x++) {
myfile << image_array[x][y];
//cout << image_array[x][y];
}
myfile << "\n";
//cout << "\n";
}
myfile.close();
}
int get_image_width() {
return image_array.size()-1;
}
int get_image_height() {
return image_array[0].size()-1;
}
void color_point(point p, string color) {
color_pixel(p.x_coordinate,p.y_coordinate, color);
}
void color_pixel(int x, int y, string color) {
image_array[x][y] = color;
}
void color_vertical_line(int x, int y1, int y2, string color) {
for (int y = y1; y <= y2; y++) {
color_pixel(x, y, color);
}
}
void color_horizontal_line(int x1, int x2, int y, string color) {
for (int x = x1; x <= x2; x++) {
color_pixel(x, y, color);
}
}
void color_box(int x1, int x2, int y1, int y2, string color) {
for (int x = x1; x <= x2; x++) {
for (int y = y1; y <= y2; y++) {
color_pixel(x, y, color);
}
}
}
string get_point_color(point p) {
return image_array[p.x_coordinate][p.y_coordinate];
}
void flood_fill(point p, string color) {
vector <point> points_queue;
points_queue.push_back(p);
string original_color = get_point_color(p);
point current_point;
while (points_queue.size() > 0) {
current_point = points_queue[0];
//if the point shares a color with the original point then color it in the new color.
if (get_point_color(current_point).compare(original_color) == 0) {
color_point(current_point, color);
}
// remove current point from the queue
points_queue.erase(points_queue.begin());
// add it's neighbours to the queue
vector<point> matching_neighbours = get_matching_neighbours(current_point, original_color);
for (int i = 0; i < matching_neighbours.size(); i++) {
points_queue.push_back(matching_neighbours[i]);
}
}
}
bool is_valid_point(point p) {
if (p.x_coordinate >= 1 && p.x_coordinate < get_image_width() + 1 && p.y_coordinate >= 1 && p.y_coordinate < get_image_height() + 1) {
return true;
}
else {
return false;
}
}
vector<point> get_matching_neighbours(point p, string color) {
vector<point> neighbours;
point left_neighbour, right_neighbour, upper_neighbour, lower_neighbour;
left_neighbour.x_coordinate = p.x_coordinate - 1;
left_neighbour.y_coordinate = p.y_coordinate;
if (is_valid_point(left_neighbour) && get_point_color(left_neighbour).compare(color) == 0) {
neighbours.push_back(left_neighbour);
}
right_neighbour.x_coordinate = p.x_coordinate + 1;
right_neighbour.y_coordinate = p.y_coordinate;
if (is_valid_point(right_neighbour) && get_point_color(right_neighbour).compare(color) == 0) {
neighbours.push_back(right_neighbour);
}
upper_neighbour.x_coordinate = p.x_coordinate;
upper_neighbour.y_coordinate = p.y_coordinate + 1;
if (is_valid_point(upper_neighbour) && get_point_color(upper_neighbour).compare(color) == 0) {
neighbours.push_back(upper_neighbour);
}
lower_neighbour.x_coordinate = p.x_coordinate;
lower_neighbour.y_coordinate = p.y_coordinate - 1;
if (is_valid_point(lower_neighbour) && get_point_color(lower_neighbour).compare(color) == 0) {
neighbours.push_back(lower_neighbour);
}
return neighbours;
}

Answer 1

There are a couple of really bad performance problems with your flood fill.
These are the 2 biggest ones:
1) You are using a vector as a queue. That is terribly slow, since it takes O(N) time to remove an item from the start of a vector. Use a deque instead, or use the vector like a stack instead of a queue by taking items from the end instead of the start.
2) You enqueue everything that get_matching_neighbors returns, but it can return things that area already in the queue. Because of this you can end up scanning and enqueing the same pixel many times.
To fix problem (2), you should should:
a) return from the flood fill immediately if the target pixel is already the right color. Then
b) color pixels when you put them into the queue, not when you take them out. That way you won't enque anything that's already in the queue, because nothing in the queue has the original color.
It is also pretty expensive to have get_matching_neighbors allocating a new vector. You should pass it a reference to an existing vector and have it replace the contents, or pass it a reference to the queue and have it recolor and add the pixels it finds.

Answer 2

Some overall optimization tips you could apply to your code:
So first, the specification says that color is 1 Latin char... so why are you using string? Strings are slow, especially when you know you're going to receive one char.
Second - when you're using vectors and know that you'll be pushing a lot of elements (and you know the amount prior), then reserve() the actual size of the vector, and the number of elements you're going to add.
When you're appending vector to a vector just reserve enough space and then
insert(first.begin(), second.begin(), second.end());
Not to mention that I would actually advice not to use vectors... they're easy to use, but often are slower than using an array. So if the algorithm itself isn't very complicated - use arrays. Also keep in mind that c-style arrays are faster than pointers (vector operates on pointers).
Third - always use constructors when you can, use pre-incrementation/decrementation operators, and always iterate from n to 0 when you can (generates about 2 less asm instructions)for(int i=0; i<n; i++) -> for(int i(n); i>0; --i)
Fourth - If you have if()...else if()...else if() chain consider using switch(). In most cases the compiler makes a lookup table for both of them. But I believe that it's guaranteed to do that for switch, but not for if chain. In short - switch() is most likely to be faster than if
Fifth - If you must use vectors, and have to fill them with some values, either use <algorithm> and iterators, or use C++11 and vector::data() that comes with it to get the pointer to the allocated array, and iterate over it.
If you didn't understand "how" or "why", just do some research. If you already did and still don't understand then I can't help you more - I won't optimize the code for you. That way you wouldn't learn anything.
Also, when given optimizations seem not to optimize enough, consider thinking about new algorithm.