MestInt.KeresesV4.Completed

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Kereses_beadando
{
    class Program
    {

        /*************************************              MAIN              ******************************************/
        static void Main(string[] args)
        {
            List<Solution> lista = new List<Solution>();

            // char[][] array feltöltése a megadott táblázattal
            char[][] array = new char[7][];
            populateArray(array);

            // char[][] array átmásolása Elem[][] tomb-be
            Elem[][] tomb = new Elem[7][];
            populateTombFromArray(tomb, array);

            // A célpont hozzáadása a listához
            lista.Add(new Solution(6, 9, 1, 0, "(7, 10)"));

            // A táblázat kiíratása
            kiirArray(array);

            // A megoldás (ha van) kiíratása
            Console.WriteLine("A megoldas az (1, 1) koordinatahoz: " + keres(tomb, lista));

            Console.ReadKey();
        }

        static void populateArray(char[][] array)
        {
            array[0] = new char[] { '1', '5', '3', '4', '3', '6', '7', '1', '1', '6' };
            array[1] = new char[] { '4', '4', '3', '4', '2', '6', '2', '6', '2', '5' };
            array[2] = new char[] { '1', '3', '9', '4', '5', '2', '4', '2', '9', '5' };
            array[3] = new char[] { '5', '2', '3', '5', '5', '6', '4', '6', '2', '4' };
            array[4] = new char[] { '1', '3', '3', '2', '5', '6', '5', '2', '3', '2' };
            array[5] = new char[] { '2', '5', '2', '5', '5', '6', '4', '8', '6', '1' };
            array[6] = new char[] { '9', '2', '3', '6', '5', '6', '2', '2', '2', '*' };
        }

        static void populateTombFromArray(Elem[][] tomb, char[][] array)
        {
            for (int i = 0; i < 7; i++)
            {
                tomb[i] = new Elem[10];
                for (int j = 0; j < 10; j++)
                {
                    tomb[i][j] = new Elem(array[i][j]);
                }
            }
        }

        static void kiirArray(char[][] array)
        {
            for (int i = 0; i < 7; i++)
            {
                if (i == 0)
                    Console.WriteLine("\t1\t2\t3\t4\t5\t6\t7\t8\t9\t10\n----------------------------------------------------------------------------------");
                Console.Write((i + 1) + ". |\t");
                for (int j = 0; j < 10; j++)
                {
                    Console.Write(array[i][j] + "\t");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }

        static String keres(Elem[][] tomb, List<Solution> lista)
        {
            int max = 0;

            // Legrosszabb esetben rows*cols-szor kell megvizsgálni az elemeket (pl ha minden lentebbi vizsgálat során csak 1-1 elem kerülne bele a listába és így az összes elemen végig kéne menni, hogy eljussunk a célba
            for (int k = 1; k < 7*10; k++)
            {
                // Megnézzünk, hogy a függvény adott meghívásakor hány eleme van a listának, hogy csak addig vizsgáljuk ennek az elemeit
                max = lista.Count();

                // Ha a listában szerepel a kiindulási állapot, akkor a célba ellehet jutni belőle, szóval nem kell tovább vizsgálni
                if (lista.Contains(lista.Find(x => x.x == 0 && x.y == 0)))
                    break;

                else
                {
                    // A lista összes elemét vizsgálni kell
                    for (int l = 1; l <= max; l++)
                    {
                        // A könyebb kezelhetőség érdekében lementjük lokálisan a lista adott elemét
                        Solution item = lista.Where(z => z.sorszam == l).First();

                        // A csúcstól max 10 távolságra lévő csúcsok vizsgálata, hogy azok eljuttatnak-e egy olyan állapotba, ami megoldáshoz vezet
                        for (int i = 1; i < 10; i++)
                        {
                            // Minden vizsgálat előtt megnézzük, hogy nem-e mutatna az adott index a listán kívülre és hogy a távolsága megegyezik-e a pont értékével
                                // Ha a megoldások listában nem szerepel még a vizsgált pont, akkor hozzáadjuk
                            if ((item.x - i) >= 0 && tomb[item.x - i][item.y].ertek == i)
                                if (lista.Where(x => x.x == (item.x - i) && x.y == item.y).Count() == 0)
                                    lista.Add(new Solution((item.x - i), item.y, (lista.Max(x => x.sorszam) + 1), tomb[item.x - i][item.y].ertek, "(" + (item.x - i + 1) + ", " + (item.y + 1) + ") -> " + lista.Where(x => x.x == item.x && x.y == item.y).First().megoldas));

                            if ((item.x + i) <= 6 && tomb[item.x + i][item.y].ertek == i)
                                if (lista.Where(x => x.x == (item.x + i) && x.y == item.y).Count() == 0)
                                    lista.Add(new Solution((item.x + i), item.y, (lista.Max(x => x.sorszam) + 1), tomb[item.x + i][item.y].ertek, "(" + (item.x + i + 1) + ", " + (item.y + 1) + ") -> " + lista.Where(x => x.x == item.x && x.y == item.y).First().megoldas));

                            if ((item.y - i) >= 0 && tomb[item.x][item.y - i].ertek == i)
                                if (lista.Where(x => x.x == item.x && x.y == (item.y - i)).Count() == 0)
                                    lista.Add(new Solution((item.x), (item.y - i), (lista.Max(x => x.sorszam) + 1), tomb[item.x][item.y - i].ertek, "(" + (item.x + 1) + ", " + (item.y - i + 1) + ") -> " + lista.Where(x => x.x == item.x && x.y == item.y).First().megoldas));

                            if ((item.y + i) <= 9 && tomb[item.x][item.y + i].ertek == i)
                                if (lista.Where(x => x.x == item.x && x.y == (item.y + i)).Count() == 0)
                                    lista.Add(new Solution((item.x), item.y + i, (lista.Max(x => x.sorszam) + 1), tomb[item.x][item.y + i].ertek, "(" + (item.x + 1) + ", " + (item.y + i + 1) + ") -> " + lista.Where(x => x.x == item.x && x.y == item.y).First().megoldas));




                            if ((item.x - i) >= 0 && (item.y - i) >= 0 && tomb[item.x - i][item.y - i].ertek == i)
                                if (lista.Where(x => x.x == (item.x - i) && x.y == (item.y - i)).Count() == 0)
                                    lista.Add(new Solution((item.x - i), (item.y - i), (lista.Max(x => x.sorszam) + 1), tomb[item.x - i][item.y - i].ertek, "(" + (item.x - i + 1) + ", " + (item.y - i + 1) + ") -> " + lista.Where(x => x.x == item.x && x.y == item.y).First().megoldas));

                            if ((item.x + i) <= 6 && (item.y + i) <= 9 && tomb[item.x + i][item.y + i].ertek == i)
                                if (lista.Where(x => x.x == (item.x + i) && (x.y == item.y + i)).Count() == 0)
                                    lista.Add(new Solution((item.x + i), (item.y + i), (lista.Max(x => x.sorszam) + 1), tomb[item.x + i][item.y + i].ertek, "(" + (item.x + i + 1) + ", " + (item.y + i + 1) + ") -> " + lista.Where(x => x.x == item.x && x.y == item.y).First().megoldas));

                            if ((item.x + i) <= 6 && (item.y - i) >= 0 && tomb[item.x + i][item.y - i].ertek == i)
                                if (lista.Where(x => x.x == (item.x + i) && (x.y == item.y - i)).Count() == 0)
                                    lista.Add(new Solution((item.x + i), (item.y - i), (lista.Max(x => x.sorszam) + 1), tomb[item.x + i][item.y - i].ertek, "(" + (item.x + i + 1) + ", " + (item.y - i + 1) + ") -> " + lista.Where(x => x.x == item.x && x.y == item.y).First().megoldas));

                            if ((item.x - i >= 0) && (item.y + i) <= 9 && tomb[item.x - i][item.y + i].ertek == i)
                                if (lista.Where(x => x.x == (item.x - i) && x.y == (item.y + i)).Count() == 0)
                                    lista.Add(new Solution((item.x - i), (item.y + i), (lista.Max(x => x.sorszam) + 1), tomb[item.x - i][item.y + i].ertek, "(" + (item.x - i + 1) + ", " + (item.y + i + 1) + ") -> " + lista.Where(x => x.x == item.x && x.y == item.y).First().megoldas));
                        }
                    }
                }
            }

            if (lista.Contains(lista.Find(x => x.x == 0 && x.y == 0)))
                return lista.Where(x => x.x == 0 && x.y == 0).First().megoldas;
            else
                return "Nincs megoldas erre a pontra";
        }

    }

    class Elem
    {
        public int ertek;
        public int eredmeny;
        public String nyerout;

        public Elem(char ertek)
        {
            if (Char.IsDigit(ertek))
                this.ertek = (int)Char.GetNumericValue(ertek);
            else
                this.ertek = 0;

            this.eredmeny = 0;
            this.nyerout = "";
        }
    }

    class Solution
    {
        public int sorszam;
        public int ertek;
        public int x;
        public int y;
        public String megoldas = "";

        public Solution(int x, int y, int sorszam, int ertek, String megoldas)
        {
            this.x = x;
            this.y = y;
            this.sorszam = sorszam;
            this.ertek = ertek;
            this.megoldas = megoldas;
        }
    }
}