4.1 – CodinGame

using System;
using System.Linq;
using System.IO;
using System.Text;
using System.Collections;
using System.Collections.Generic;

/**
 * Auto-generated code below aims at helping you parse
 * the standard input according to the problem statement.
 **/
class Player
{
    // Maze Legend
    const string UNDISCOVERED = "?";
    const string KURT = "@";
    const string WALL = "#";
    const string START = "T";
    const string CONTROL = "C";
    
    static void Main(string[] args)
    {
        string[] inputs;
        inputs = Console.ReadLine().Split(' ');
        int R = int.Parse(inputs[0]); // number of rows.
        int C = int.Parse(inputs[1]); // number of columns.
        int A = int.Parse(inputs[2]); // number of rounds between the time the alarm countdown is activated and the time the alarm goes off.
        Tile[,] maze = new Tile[C,R]; // map for debugging
        int xControl = -1;
        int yControl = -1;
        Queue<string> instructionQueue = new Queue<string>();
        Queue<string> tempQueue = new Queue<string>();
        bool controlFound = false;
        bool controlReachable;
        bool controlActivated = false;
        for (int i=0;i<R*C;i++) // initilize the map with 'X'
        {
            maze[i%C,i/C] = new Tile(i%C, i/C, UNDISCOVERED);
        }
        // game loop
        while (true)
        {
            inputs = Console.ReadLine().Split(' ');
            int KR = int.Parse(inputs[0]); // row where Kirk is located.
            int KC = int.Parse(inputs[1]); // column where Kirk is located.
            for (int i = 0; i < R; i++)
            {
                int col = 0;
                string ROW = Console.ReadLine(); // C of the characters in '#.TC?' (i.e. one line of the ASCII maze).
                if (IsInView(i, KR))
                {
                    for(int j = 0; j < C; j++)
                    {
                        if(IsInView(j, KC))
                        {
                            maze[j,i].Type = ROW[j].ToString();
                            if (maze[j,i].Type == CONTROL)
                            {
                                xControl = j;
                                yControl = i;
                                controlFound = true;
                            }
                        }
                    }
                }
            }
            maze[KC,KR].Type = KURT;
            DisplayMaze(maze, R, C);
            if (instructionQueue.Count == 0)
            {
                if(controlActivated) //control activated, go back to start
                {
                    SearchShortestPath(KC, KR, START, maze, ref instructionQueue);
                }
                else if(controlFound)
                {
                    controlReachable = SearchShortestPath(KC, KR, CONTROL, maze, ref instructionQueue); //check is there is a path to the control room
                    Console.Error.WriteLine("ControlReachable = {0}", controlReachable);
                    if(controlReachable)
                    {
                        SearchShortestPath(xControl, yControl, START, maze, ref tempQueue); //if the control is reachable, check the path back from the control to the start
                        Console.Error.WriteLine("Dist from Ctl to Start is {0}, Alarm needs {1}", tempQueue.Count, A);
                        if(tempQueue.Count > A) //is the path back to the start is longer than the time needed to raise the alarm, go back to the start, else discover more of the map to search for a shorter path
                        {
                            Console.Error.WriteLine("Too Far");
                            SearchShortestPath(KC, KR, UNDISCOVERED, maze, ref instructionQueue);
                        }
                        else
                        {
                            Console.Error.WriteLine("Reachable");
                            controlActivated = true;
                        }
                    }
                    else //if the control isnt reachable, discover more of the maze
                    {
                        SearchShortestPath(KC, KR, UNDISCOVERED, maze, ref instructionQueue);
                    }
                }
                else //discover the closest unknown tile
                {
                    SearchShortestPath(KC, KR, UNDISCOVERED, maze, ref instructionQueue);
                }
                
            }
            Console.Error.WriteLine(instructionQueue.Count);
            Console.WriteLine(instructionQueue.Dequeue());
            // Write an action using Console.WriteLine()
            // To debug: Console.Error.WriteLine("Debug messages...");

             // Kirk's next move (UP DOWN LEFT or RIGHT).
        }
    }
    
    static bool SearchShortestPath(int xOrigin, int yOrigin, string destinationType, Tile[,] maze, ref Queue<string> instructionQueue) //simple BFS on the 4 directions around the active tile
    {
        bool found = false;
        List<Tile> toTest = new List<Tile>();
        toTest.Add(maze[xOrigin, yOrigin]);
        List<Tile> visited = new List<Tile>(); 
        Tile targetTile = null;
        
        while (toTest.Count != 0 & !found)
        {   List<Tile> tempTile = new List<Tile>();
            foreach (Tile todo in toTest)
            {
                Tile up = maze[todo.Coordinates.Item1, todo.Coordinates.Item2-1];
                Tile down = maze[todo.Coordinates.Item1, todo.Coordinates.Item2+1];
                Tile left = maze[todo.Coordinates.Item1-1, todo.Coordinates.Item2];
                Tile right = maze[todo.Coordinates.Item1+1, todo.Coordinates.Item2];
                if(!toTest.Contains(right) && !tempTile.Contains(right) && !visited.Contains(right) && !found)
                {
                    right.SetInstructionsValues(todo.GetInstructions());
                    
                    if (right.Type != WALL && right.Type != UNDISCOVERED && (right.Type != CONTROL | destinationType == CONTROL))
                    {
                        right.AddDirection("RIGHT");
                    }
                    if(right.Type == destinationType)
                    {
                        targetTile = right;
                        found = true;
                    }
                    else if (right.Type != WALL && right.Type != UNDISCOVERED && (right.Type != CONTROL | destinationType == CONTROL))
                    {
                        tempTile.Add(right);
                    }
                    
                }
                if(!toTest.Contains(left) && !tempTile.Contains(left) && !visited.Contains(left) && !found)
                {
                    left.SetInstructionsValues(todo.GetInstructions());
                    if (left.Type != WALL && left.Type != UNDISCOVERED && (left.Type != CONTROL | destinationType == CONTROL))
                    {
                        left.AddDirection("LEFT");
                    }
                    if(left.Type == destinationType)
                    {
                        targetTile = left;
                        found = true;
                    }
                    else if (left.Type != WALL && left.Type != UNDISCOVERED && (left.Type != CONTROL | destinationType == CONTROL))
                    {
                        tempTile.Add(left);
                    }
                    
                }
                if(!toTest.Contains(up) && !tempTile.Contains(up) && !visited.Contains(up) && !found)
                {
                    up.SetInstructionsValues(todo.GetInstructions());
                    if (up.Type != WALL && up.Type != UNDISCOVERED && (up.Type != CONTROL | destinationType == CONTROL))
                    {
                        up.AddDirection("UP");
                    }
                    if(up.Type == destinationType)
                    {
                        targetTile = up;
                        found = true;
                    }
                    else if (up.Type != WALL && up.Type != UNDISCOVERED && (up.Type != CONTROL | destinationType == CONTROL))
                    {
                        tempTile.Add(up);
                    }
                    
                }
                if(!toTest.Contains(down) && !tempTile.Contains(down) && !visited.Contains(down) && !found)
                {
                    down.SetInstructionsValues(todo.GetInstructions());
                    if (down.Type != WALL && down.Type != UNDISCOVERED && (down.Type != CONTROL | destinationType == CONTROL))
                    {
                        down.AddDirection("DOWN");
                    }
                    if(down.Type == destinationType)
                    {
                        targetTile = down;
                        found = true;
                    }
                    else if (down.Type != WALL && down.Type != UNDISCOVERED && (down.Type != CONTROL | destinationType == CONTROL))
                    {
                        tempTile.Add(down);
                    }
                }
                todo.FlushInstructions(); //resets the path to the current since this is not the one searched.
            }
            visited = toTest;
            toTest = tempTile;
        }
        if (found == true)
        {
            instructionQueue = new Queue<string>(targetTile.GetInstructions());
            targetTile.FlushInstructions();
        }
        foreach (Tile todo in toTest)
        {
            todo.FlushInstructions(); //resets the path to the current since this is not the one searched.
        }
        return found;
    }
    
    static void DisplayMaze(Tile[,] maze,int xLength , int yLength) //Display the map in the error out. Debug function
    {
        for (int i=0;i<xLength;i++)
        {
            string xString = "";
            for (int j=0; j<yLength; j++)
            {
                xString += maze[j,i].Type;
            }
            Console.Error.WriteLine(xString);
        }
    }
    
    static bool IsInView(int inRow, int kurtRow) //return true of the tile is "in view" of kurt (meaning 2 tiles distance from him)
    {
        return (inRow == kurtRow-2) |  (inRow == kurtRow-1) |  (inRow == kurtRow) |  (inRow == kurtRow+1) |  (inRow == kurtRow+2);
    }
}

class Tile
{
    private Tuple<int, int> _coord; //coordinates of the tile
    private string _type = ""; //type of the tile (see the legend at the top of the player class)
    private Queue<string> _dirInstructions = new Queue<string>(); //queue of the instructions to reach the tile from the current start position
    
    public Tuple<int, int> Coordinates { get { return _coord; } }
    public string Type { get {return _type;} set {_type = value;} }
    
    public Tile(int x, int y, string type) //constructor for tile
    {
        _coord = new Tuple<int, int>(x, y);
        _type = type;
    }
    
    public void AddDirection(string dir) //enqueue a direction in the instruction queue
    {
        _dirInstructions.Enqueue(dir);
    }
    
    public Queue<string> GetInstructions() //returns the instruction queue
    {
        return _dirInstructions;
    }
    
    public void FlushInstructions() //removes all instructions in the queue
    {
        _dirInstructions.Clear();
    }
    
    public void SetInstructionsValues(Queue<string> qdir) //replace the currentinstruction queu from the object by qdi
    {
        this.FlushInstructions();
        _dirInstructions = new Queue<string> (qdir);
    }
    
    public override string ToString() //override ToString() for debugging purpose
    {
        return _coord.ToString() + ":" + _type + "<" + _dirInstructions.Count.ToString(); 
    }
    
    //OVERRIDE FOR EQUALITY
    public override bool Equals(System.Object obj) // Needed to override '=='
    {
        if (obj == null) // If parameter is null return false.
        {
            return false;
        }
        Tile t = obj as Tile;
        if ((System.Object)t == null) // If parameter cannot be cast to Point return false.
        {
            return false;
        }
        return _coord.Equals(t.Coordinates); // Could include type, buit as it is supposed to change, letÄs not over complicate it
    }
    
    public override int GetHashCode() // Needed to override '=='
    {
        return _coord.GetHashCode();
    }
    
    public static bool operator == (Tile a, Tile b) //overrides == between 2 tiles
    {
        if (System.Object.ReferenceEquals(a, b)) // If both are null, or both are same instance, return true.
        {
            return true;
        }
        if (((object)a == null) || ((object)b == null)) // If one is null, but not both, return false.
        {
            return false;
        }
        return a.Coordinates.Equals(b.Coordinates); // Return true if the coordinates match:
    }
    
    public static bool operator !=(Tile a, Tile b) //override != between 2 tiles
    {
        return !(a == b);
    }
}