//O(Height * Width)
        public static void DeleteRow()
        {
            int[,] memo = new int[Height, Width];                      // O(1)
            for (int i = 0; i < Height; i++)                           // O(Height)
            {
                memo[i, 0] = 0;                                        // O(1)
            }
            int LeastStart = (int)1e9, currI = Height - 1, currJ = -1; // O(1)

            // O(Height * Width)
            for (int i = 1; i < Height; i++)                                                                                       // O(Height)
            {
                for (int j = 0; j < Width; j++)                                                                                    // O(Width)
                {
                    int c1 = memo[i - 1, j] + ImageOperations.CalculatePixelsEnergy(ImageList[i][j], ImageList[i - 1][j]);         // O(1)
                    int c2 = (int)1e9;                                                                                             // O(1)
                    if (j - 1 >= 0)                                                                                                // O(1)
                    {
                        c2 = memo[i - 1, j - 1] + ImageOperations.CalculatePixelsEnergy(ImageList[i][j], ImageList[i - 1][j - 1]); // O(1)
                    }
                    int c3 = (int)1e9;                                                                                             // O(1)
                    if (j + 1 < Width)                                                                                             // O(1)
                    {
                        c3 = memo[i - 1, j + 1] + ImageOperations.CalculatePixelsEnergy(ImageList[i][j], ImageList[i - 1][j + 1]); // O(1)
                    }
                    memo[i, j] = Math.Min(c1, Math.Min(c2, c3));                                                                   // O(1)

                    if (i == currI)                                                                                                // O(1)
                    {
                        if (memo[i, j] < LeastStart)                                                                               // O(1)
                        {
                            currJ      = j;                                                                                        // O(1)
                            LeastStart = memo[i, j];                                                                               // O(1)
                        }
                    }
                }
            }
            // O(N * currI) : where N is the "ImageList[currI]" count
            while (true)
            {
                ImageList[currI].RemoveAt(currJ);                                  // O(N) : where N is the list count
                if (Visualisation)                                                 // O(1)
                {
                    int tempi = currI;                                             // O(1)
                    int tempj = currJ + AddedCounter[tempi].Count(x => x < currJ); // O(1)
                    TempMatrix[tempj, tempi].red   = 1;                            // O(1)
                    TempMatrix[tempj, tempi].blue  = 0;                            // O(1)
                    TempMatrix[tempj, tempi].green = 0;                            // O(1)
                    AddedCounter[tempi].Add(tempj);                                // O(1)
                }



                if (currI == 0)                      // O(1)
                {
                    break;                           // O(1)
                }
                int c1 = memo[currI - 1, currJ];     // O(1)
                int c2 = (int)1e9, c3 = (int)1e9;    // O(1)
                if (currJ - 1 >= 0)                  // O(1)
                {
                    c2 = memo[currI - 1, currJ - 1]; // O(1)
                }
                if (currJ + 1 < Width)               // O(1)
                {
                    c3 = memo[currI - 1, currJ + 1]; // O(1)
                }
                if (c1 <= c2 && c1 <= c3)            // O(1)
                {
                    currI--;
                }                              // O(1)
                else if (c2 <= c1 && c2 <= c3) // O(1)
                {
                    currI--; currJ--;
                }                              // O(1)
                else if (c3 <= c1 && c3 <= c2) // O(1)
                {
                    currI--; currJ++;
                }       // O(1)
            }
            Width--;    // O(1)
        }