public static Bitmap GetEneryMatrixs(Bitmap image)
{
    BitmapData bmData = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
    //address of the first line. IntPtr is a platform specific type that represents pointer in C#.
    IntPtr ptr = bmData.Scan0;
    //one line length of an image in rgb pixel including padding.
    int stride = bmData.Stride;

    //if you notice, here we use 2 image. One image from method parameter and one to be an output image.
    //You can guess that at first the output image (newBm) is empty. 
    Bitmap newBm = new Bitmap(image.Width, image.Height);
    BitmapData newBmData = newBm.LockBits(new Rectangle(0, 0, newBm.Width, newBm.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
    IntPtr newPtr = newBmData.Scan0;
    int newStride = newBmData.Stride;

    unsafe
    {
        //convert pointer ptr into byte* explicitly.
        byte* p = (byte*)ptr;
        int rgbWidth = image.Width * 3;
        int paddingOffset = stride - rgbWidth;

        byte* newP = (byte*)newPtr;
        int newRgbWidth = newBm.Width * 3;
        int newPaddingOffset = newStride - newRgbWidth;

        int rLrR = 0, gLgR = 0, bLbR = 0, rTrB = 0, gTgB = 0, bTbB = 0;
        byte result;
        double dIdx = 0, dIdy = 0;
        for (int j = 0; j < image.Height; j++)
        {
            for (int i = 0; i < image.Width; i++)
            {
                //at the topmost row we don't have p[-3] => B ,p[-2] => G, p[-1] => R. 
                //So we use p[0],p[1],p[2] to replace that respectively.
                int offSetT = 0, offSetB = 0;
                if (j == 0) offSetT = stride;
                else if (j == image.Height - 1) offSetB = -stride;

                bLbR = p[-stride + offSetT] - p[stride + offSetB];
                gTgB = p[-stride + 1 + offSetT] - p[stride + 1 + offSetB];
                rLrR = p[-stride + 2 + offSetT] - p[stride + 2 + offSetB];

                //handle leftmost and rightmost column.
                int offSetL = 0, offSetR = 0;
                if (i == 0) offSetL = 3;
                else if (i == image.Width - 1) offSetR = -3;

                //rLrR is Bleft - Bright, the same for the others.
                bLbR = p[-3 + offSetL] - p[3 + offSetR];
                gLgR = p[-2 + offSetL] - p[4 + offSetR];
                rLrR = p[-1 + offSetL] - p[5 + offSetR];

                dIdx = PythagoreanAdd(bLbR, gLgR, rLrR);
                dIdy = PythagoreanAdd(bTbB, gTgB, rTrB);

                //get the energy result from computing R,G,B channel vectors.
                result = (byte)Math.Round(dIdx + dIdy);
                //save the energy value to our new locked image (newBm) via its pointer (newP).
                newP[0] = result;
                newP[1] = result;
                newP[2] = result;

                //advance the pointers by 3 (R,G,B).
                p += 3;
                newP += 3;
            }

            //add paddingOffset to skip to the next row.
            p += paddingOffset;
            newP += newPaddingOffset;
        }
    }
    //release the resources.
    image.UnlockBits(bmData);
    newBm.UnlockBits(newBmData);

    return newBm;
}
public static double PythagoreanAdd(params int[] varList)
{
    long result = 0;
    for (int i = 0; i < varList.Length; i++)
    {
        //power two for each
        result += varList[i] * varList[i];
    }
    return Math.Sqrt(result);
}

public override int[] ApplyCarvingAlgorithm()
{
    int height = _EnergyImg.Height;
    int width = _EnergyImg.Width;

    int[,] m = new int[height, width];
    int[,] k = new int[height, width];

    BitmapData bmData = _EnergyImg.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
    //address of the first line.
    IntPtr ptr = bmData.Scan0;
    //one line length of an image in rgb pixel including padding
    int stride = bmData.Stride;
    unsafe
    {
        //convert pointer ptr into byte* explicitly
        byte* p = (byte*)ptr;
        int rgbWidth = width * 3;
        int paddingOffset = stride - rgbWidth;

        //initialize the first row of m and k matrix.
        for (int i = 0; i < width; i++)
        {
            m[0, i] = p[0];
            k[0, i] = 0;
            p += 3;
        }

        //find matrix m and k values.
        p = (byte*)ptr; //energy image pointer must be reset its position.
        int minIndex = 0;
        for (int j = 1; j < height; j++)
        {
            for (int i = 0; i < width; i++)
            {
                //check left
                if (i <= 0) minIndex = FindMinIndex(999999, m[j - 1, i], m[j - 1, i + 1]);
                //check right
                else if (i + 1 >= width) minIndex = FindMinIndex(m[j - 1, i - 1], m[j - 1, i], 999999);
                else minIndex = FindMinIndex(m[j - 1, i - 1], m[j - 1, i], m[j - 1, i + 1]);

                //minIndex has only 0,1,2 and it doesn't consider the current index, so we need to use minIndex + i(current index)
                m[j, i] = p[0] + m[j - 1, i + minIndex - 1];    //chosen m (***i + minIndex - 1) plus current energy bit.
                k[j, i] = minIndex + 1;   //either 1,2,3 (top row values are all zero)

                p += 3;
            }
            p += paddingOffset;
        }
    }

    _EnergyImg.UnlockBits(bmData);

    return CalculatePositionMatrix(m, k, width, height);
}

public static Bitmap CutSeam(Bitmap image, int[] positionMatrix)
{
    BitmapData bmData = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
    //address of the first line.
    IntPtr ptr = bmData.Scan0;
    //one line length of an image in rgb pixel including padding
    int stride = bmData.Stride;

    Bitmap newBm = new Bitmap(image.Width - 1, image.Height);
    BitmapData newBmData = newBm.LockBits(new Rectangle(0, 0, newBm.Width, newBm.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
    IntPtr newPtr = newBmData.Scan0;
    int newStride = newBmData.Stride;

    unsafe
    {
        //convert pointer ptr into byte* explicitly
        byte* p = (byte*)ptr;
        int rgbWidth = image.Width * 3;
        int paddingOffset = stride - rgbWidth;

        byte* newP = (byte*)newPtr;
        int newRgbWidth = newBm.Width * 3;
        int newPaddingOffset = newStride - newRgbWidth;

        for (int j = 0; j < image.Height; j++)
        {
            for (int i = 0; i < image.Width - 1; i++)
            {
                if (positionMatrix[j] <= i)
                {
                    newP[0] = p[3];
                    newP[1] = p[4];
                    newP[2] = p[5];
                }
                else
                {
                    newP[0] = p[0];
                    newP[1] = p[1];
                    newP[2] = p[2];
                }
                p += 3;
                newP += 3;
            }
            //advance p 1 pixel (account for r,g,b 3 pigments) because we newP has 1 more pixel than p.
            p += paddingOffset + 3;
            newP += newPaddingOffset;
        }
    }
    image.UnlockBits(bmData);
    newBm.UnlockBits(newBmData);
    return newBm;
}

public static Bitmap AddSeam(Bitmap image, int[] positionMatrix)
{
    BitmapData bmData = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
    //address of the first line.
    IntPtr ptr = bmData.Scan0;
    //one line length of an image in rgb pixel including padding
    int stride = bmData.Stride;

    Bitmap newBm = new Bitmap(image.Width + 1, image.Height);
    BitmapData newBmData = newBm.LockBits(new Rectangle(0, 0, newBm.Width, newBm.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
    IntPtr newPtr = newBmData.Scan0;
    int newStride = newBmData.Stride;

    unsafe
    {
        //convert pointer ptr into byte* explicitly
        byte* p = (byte*)ptr;
        int rgbWidth = image.Width * 3;
        int paddingOffset = stride - rgbWidth;

        byte* newP = (byte*)newPtr;
        int newRgbWidth = newBm.Width * 3;
        int newPaddingOffset = newStride - newRgbWidth;

        for (int j = 0; j < image.Height; j++)
        {
            for (int i = 0; i < image.Width + 1; i++)
            {
                if (positionMatrix[j] == i && j != image.Height - 1 && j != 0 && i != 0 && i != image.Width - 1)
                {
                    newP[0] = (byte)((p[-3] + p[0- stride]+ p[3 + stride]) / 3.0);
                    newP[1] = (byte)((p[-2] + p[1 - stride] + p[4 + stride]) / 3.0);
                    newP[2] = (byte)((p[-1] + p[2 - stride] + p[5 + stride]) / 3.0);
                }
                else if (positionMatrix[j] < i)
                {
                    //copy this lowest enery seam
                    newP[0] = p[-3];
                    newP[1] = p[-2];
                    newP[2] = p[-1];
                }
                else
                {
                    newP[0] = p[0];
                    newP[1] = p[1];
                    newP[2] = p[2];
                }
                p += 3;
                newP += 3;

            }
            //we use image.Width + 1 for newP, but for p it must rely on image.Width 
            //not image.Width + 1. So, jump back one pixel (3, from the pointer's point of view).
            p += paddingOffset - 3;
            newP += newPaddingOffset;
        }
    }
    image.UnlockBits(bmData);
    newBm.UnlockBits(newBmData);
    return newBm;
}

protected static int[] CalculatePositionMatrix(int[,] m, int[,] k, int width, int height)
{
    //find the minimum value of the last row.
    int minIndex = 0;
    //use oldMinIndex as the initializer.
    int chosenIndex = 1;

    for (; chosenIndex < width; chosenIndex++)
        if (m[height - 1, chosenIndex] < m[height - 1, minIndex])
            minIndex = chosenIndex;

    //mark the position of image bits that we are going to cut off or copy.
    int[] positionMatrix = new int[height];
    //go upward and find the route that has lowest enery.
    for (int y = height - 1; y >= 0; y--)
    {
        positionMatrix[y] = minIndex;    //save current chosen index
        if (k[y, minIndex] == 0) break;  //we reach the top row
        else if (k[y, minIndex] == 1) minIndex--;  //go left in the next loop
        else if (k[y, minIndex] == 3) minIndex++; //go right in the next loop
        //else use the same chosenIndex value
    }
    return positionMatrix;
}

In this topic I will introduce you about Breadth First Search with a Graph that is created by an array.

Before we go to the example, we need to know about what are the graph and graph's components.

 Graph contains 2 things : Vertices are nodes in the graph , which represent the places or positions in the graph, and Edges that show the connections between vertices.

Next, what is the Breadth First Search : is a basic search algorithm that use queue keep track the visited nodes.

This algorithm will find all posible paths that connect to the current state first and then it will go to the next level by expanding all paths from next states, which are expanded from current state.

Doing these again and again until there is one path find the goal.

Advantage : you can find the solution centainly.

Disadvantage : it uses a lot of memory and number of expanding paths.

Example :

using System;

namespace BreadthFirstSearch
{
    class Vertex
    {
        private char title;
        private Boolean visited;

        public Vertex(char label)
        {
            title = label;
            visited = false;
        }

        public Boolean Visited
        {
            get
            {
                return visited;
            }
            set
            {
                visited = value;
            }
        }

        public Char Title
        {
            get
            {
                return title;
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

namespace BreadthFirstSearch
{
    class Graph
    {
        private const int MAX = 20;
        private Vertex[] list;
        private int[,] adjMatrix;
        private int numVertices, nVert;
        private char[] vertex;
        private List<int> keep;

        public Graph()
        {
            list = new Vertex[MAX];
            adjMatrix = new int[MAX,MAX];
            numVertices = nVert = 0;
            for(int i = 0; i < MAX; i++)
                for(int j = 0; j < MAX; j++)
                    adjMatrix[i,j] = 0;
            keep = new List<int>();
            vertex = new char[MAX];
        }

        //add this vertex to the list
        public void AddVertex(char title) 
        {
            list[numVertices++] = new Vertex(title);
        }

        //connect these two vertices
        public void AddEdge(int start, int end)
        {
            adjMatrix[start,end] = 1;
            adjMatrix[end,start] = 1;
        }


        //display vertex's title
        public void ShowVertex(String s, int v)
        {
            Console.Write(s + list[v].Title);
        }

        //save this vertex's title (marked as visited)
        public void SaveVertex(char label)
        {
            vertex[nVert++] = label;
        }

        //display all vertices
        public void PrintVertices() 
        {
            Console.Write("\nVertices visited: ");
            for(int i = 0; i < nVert; i++)
               Console.Write(vertex[i]);
            Console.WriteLine();
        }

        //display contents of queue during operations
        public void Content() 
        {
            //display contents of a in reverse order
            for(int j = keep.Count-1; j >= 0; j--) {
                Console.Write(list[keep.ElementAt<int>(j)].Title);
            }
            Console.WriteLine();
        }

        /*breadth-first search to keep track of events and contents of queue
        during visitation operations*/
        public void BFS() 
        {
            int v2;
            Console.WriteLine("Event\t\t\tQueue");
            list[0].Visited = true;
            ShowVertex("  Visit: ", 0);
            Console.WriteLine("");
            keep.Insert(0,0);
            SaveVertex(list[0].Title);
            while(keep.Count!=0) 
            {
                //remove vertex
                int index = keep[keep.Count-1];
                keep.RemoveAt(keep.Count-1);
                int v1 = index;
                //not printing the first vertex
                if(v1 != 0) {
                    ShowVertex("Removed: ", v1);
                    Console.Write("\t\t");
                    Content();
                }
                //until unvisited neighbors are gone
                while((v2 = GetAdjUnvisitedVertex(v1)) != -1)
                {
                    list[v2].Visited = true;
                    ShowVertex("  Visit: ", v2);
                    keep.Insert(0,v2);
                    Console.Write("\t\t");
                    Content();
                    SaveVertex(list[v2].Title);
                }
            }
            //print all vertices visited
            PrintVertices();
            //set all vertices back to original
            for(int j = 0; j < numVertices; j++)
            {
                list[j].Visited = false;
            }
        }

        /*return either index of unvisited connected vertcies
        from v to i, or -1 if the vertex has been visited*/
        private int GetAdjUnvisitedVertex(int v)
        {
            for (int i = 0; i < numVertices; i++)
                if (adjMatrix[v,i] == 1 && !list[i].Visited)
                    return i;
            return -1;
        }
    }
}

using System;

namespace BreadthFirstSearch
{
    class Program
    {
        static void Main(string[] args)
        {
            Graph g = new Graph();

            //create vertices
            g.AddVertex('A');    //0
            g.AddVertex('B');    //1
            g.AddVertex('C');    //2
            g.AddVertex('D');    //3
            g.AddVertex('E');    //4
            g.AddVertex('F');    //5
            g.AddVertex('G');    //6
            g.AddVertex('H');    //7
            g.AddVertex('I');    //8

            //connect vertices
            g.AddEdge(0, 1); //AB
            g.AddEdge(0, 2); //AC
            g.AddEdge(0, 8); //AI
            g.AddEdge(1, 5); //BF
            g.AddEdge(2, 3); //BF
            g.AddEdge(2, 4); //CE
            g.AddEdge(3, 5); //DF
            g.AddEdge(3, 6); //DG
            g.AddEdge(3, 7); //DH
            g.AddEdge(3, 8); //DI
            g.AddEdge(5, 7); //FH
            g.AddEdge(6, 8); //GI

            g.BFS();    //visit with BFS.
            Console.ReadLine();
        }
    }
}

You will see that class Vertex will has the label for be assigned the name of node, and visit for keeping track that this vertex is visited whelter or not.

And, class Graph uses adjMatrix to keep the connection between the nodes in the array and uses another array called vertex to keep track the answer [visited nodes].

The sequence of each node removed from the queue is the answer.

You can follow the program step by step by using hand calculation, you can understand more easier.