public static int Score(Solution solution, PictureDescription pd)
 {
     if(!Validate(solution, pd))
     {
         return 0;
     }
     return 0;
 }
        private static void TryHorizontalLines(PictureDescription descriptor, Solution solution, ref Command? bestCommand, ref int bestScore)
        {
            for (int y = 0; y < descriptor.NumRows; ++y)
            {
                for (int x = 0; x < descriptor.NumCols;)
                {
                    int startX = x;
                    int endX = x;
                    bool skipped = false;
                    int score = 0;
                    
                    for (;;)
                    {
                        if (x >= descriptor.NumCols)
                        {
                            break;
                        }
                        if (descriptor.IsFilled(x, y))
                        {
                            if (!solution.IsFilled(x, y))
                            {
                                ++score;
                                endX = x;
                            }
                        } else if (skipped)
                        {
                            skipped = true;
                        } else
                        {
                            ++x;
                            break;
                        }

                        ++x;
                    }

                    int len = endX - startX + 1;

                    if (len > 0)
                    {
                        if (score > 0 && score > bestScore)
                        {
                            var command = solution.MakeHorizontalLine(startX, y, len);

                            if (score > bestScore)
                            {
                                bestCommand = command;
                                bestScore = score;
                            }
                        }
                    }
                }
            }
        }
        public static Solution solve(PictureDescription pd)
        {
            Solution solution = new Solution(pd);
            //PictureDescription auxPd = new PictureDescription(pd.NumRows, pd.NumCols);
            for (int row = 0; row < pd.NumRows; row++)
            {
                DrawState currentState = DrawState.EMPTY;
                int[] from = new int[2];
                int length = 0;

                for (int column = 0; column < pd.NumCols; column++)
                {
                    switch (currentState)
                    {
                        case DrawState.EMPTY:
                            if (pd.IsFilled(column, row))
                            {
                                from[0] = column;
                                from[1] = row;
                                length = 1;
                                currentState = DrawState.FILL;
                                if (column == pd.NumCols - 1)
                                {
                                    solution.AddCommand(solution.MakeHorizontalLine(from[0], from[1], length));
                                    currentState = DrawState.EMPTY;
                                }
                            }

                            break;
                        case DrawState.FILL:
                            if (!pd.IsFilled(column, row))
                            {
                                solution.AddCommand(solution.MakeHorizontalLine(from[0], from[1], length));
                                currentState = DrawState.EMPTY;
                            }else if (column == pd.NumCols - 1)
                            {
                                solution.AddCommand(solution.MakeHorizontalLine(from[0], from[1], ++length));
                                currentState = DrawState.EMPTY;
                            }
                            else
                            {
                                length++;
                            }
                            break;
                    }
                }
            }

            return solution;
        }
 public static bool Validate(Solution solution, PictureDescription pd)
 {
     for (int row = 0; row < pd.NumRows; row++)
     {
         for (int column = 0; column < pd.NumCols; column++)
         {
             if(solution.IsFilled(column, row) != pd.IsFilled(column, row))
             {
                 Console.WriteLine(row + " " + column);
                 return false;
             }
         }
     }
     return true;
 }
        public static Solution Solve(PictureDescription descriptor)
        {
            var solution = new Solution(descriptor);

            while (!solution.Covers(descriptor))
            {
                int bestScore = int.MinValue;
                Command? bestCommand = null;

                TryHorizontalLines(descriptor, solution, ref bestCommand, ref bestScore);

                solution.AddCommand(bestCommand.Value);
            }

            solution.AddClearCommands(descriptor);

            return solution;
        }