Exemplo n.º 1
0
        /// <summary>
        /// Compare the number of the Cell.PossibleOwners for a MainBlock to the number of MainBlock.PossibleBlocks. If the number is the same, the MainBlock requires that Cell to have a solution.
        /// If this occurs once for the Cell -> mark the Cell as owned.
        /// If this occurs more that once, multiple MainBlocks require the Cell for a solution, hence no solution is possible.
        /// </summary>
        private bool CompareCellToMainBlock(ICell cell)
        {
            LinkedListNode <IMainBlock> currentMainBlockNode = cell.GetPossibleMainBlocks.First;
            int        counter           = 0;
            IMainBlock BlockRequringCell = null;

            while (currentMainBlockNode != null)
            {
                if (cell.GetPossibleOwners[currentMainBlockNode.Value].Count == currentMainBlockNode.Value.PossibleBlocks.Count)
                {
                    //Keep a reference to the last MainBlock that fulfilled the criteria, will be used if the count is 1.
                    BlockRequringCell = currentMainBlockNode.Value;
                    counter++;
                }
                currentMainBlockNode = currentMainBlockNode.Next;
            }
            if (counter == 1)
            {
                if (_ownershipSetter.MarkCellAsOwned(cell, BlockRequringCell) == true)
                {
                    return(true);
                }
            }
            if (counter > 1)
            {
                return(true);
            }
            return(false);
        }
Exemplo n.º 2
0
        /// <summary>
        /// For the current Cell, loops though the PossibleOwners removing each value from the respective MainBlock.PossibleBlocks, except the OwnerMainBlock.
        /// </summary>
        public List <IMainBlock> RemoveImpossibleBlocks(ICell cell, IMainBlock mainBlock)
        {
            LinkedListNode <IMainBlock> CurrentMainBlockNode           = cell.GetPossibleMainBlocks.First;
            List <IMainBlock>           MainBlocksWithOnePossibleBlock = new List <IMainBlock>();

            while (CurrentMainBlockNode != null)
            {
                if (mainBlock != CurrentMainBlockNode.Value)
                {
                    foreach (int possibleBlock in cell.GetPossibleOwners[CurrentMainBlockNode.Value])
                    {
                        CurrentMainBlockNode.Value.PossibleBlocks.Remove(possibleBlock);
                    }
                    if (CurrentMainBlockNode.Value.PossibleBlocks.Count == 0)
                    {
                        return(null);
                    }
                    else if (CurrentMainBlockNode.Value.PossibleBlocks.Count == 1)
                    {
                        MainBlocksWithOnePossibleBlock.Add(CurrentMainBlockNode.Value);
                    }
                }
                CurrentMainBlockNode = CurrentMainBlockNode.Next;
            }
            return(MainBlocksWithOnePossibleBlock);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Sets the DimensionSet, DimensionSet and MultipleMatrix properties.
        /// </summary>
        public static IPossibleBlock CreatPossibleBlockFromDimensionSetIndex(IMainBlock mainBlock, Dictionary <int, List <List <int> > > blockDimensionSets, int dimensionSetIndex)
        {
            IPossibleBlock possibleBlock = new PossibleBlock(mainBlock);

            possibleBlock.DimensionSetIndex = dimensionSetIndex;
            possibleBlock.DimensionSet      = blockDimensionSets[mainBlock.Capacity][dimensionSetIndex];
            possibleBlock.MultipleMatrix    = AdditionalMethods.GetMultipleMatrix(possibleBlock.DimensionSet);
            return(possibleBlock);
        }
Exemplo n.º 4
0
 /// <summary>
 /// Marks the current Cell as owned by the current OwnerMainBlock, hence these properties need to be set correctly before calling this method.
 /// </summary>
 public bool MarkCellAsOwned(ICell cell, IMainBlock mainBlock)
 {
     ChangeHasOccured = true;
     if (CheckMainBlocks(_possibleBlockRemover.RemoveImpossibleBlocks(cell, mainBlock)))
     {
         return(true);
     }
     _possibleBlockRemover.SetOwnerMainBlockPossibleBlocks(cell, mainBlock);
     cell.Owner = mainBlock;
     return(false);
 }
        /// <summary>
        /// Considers a single MainBlock at a time.
        /// </summary>
        private void ProcessMainBlock(IMainBlock mainBlock)
        {
            int dimensionSetIndex = 0;

            while (dimensionSetIndex < _solutionTracker.BlockDimensionSets[mainBlock.Capacity].Count)
            {
                PossibleBlock = AdditionalMethods.CreatPossibleBlockFromDimensionSetIndex(mainBlock, _solutionTracker.BlockDimensionSets, dimensionSetIndex);
                ProcessDimensionSet();
                dimensionSetIndex++;
            }
        }
Exemplo n.º 6
0
        /// <summary>
        /// When the current Cell is marked as owned, only the possible blocks that contain this cell are valid.
        /// The MainBlock.PossibleBlock is updated accordingly.
        /// </summary>
        public void SetOwnerMainBlockPossibleBlocks(ICell cell, IMainBlock mainBlock)
        {
            HashSet <int> possibleBlocks = new HashSet <int>();

            foreach (int possibleBlock in cell.GetPossibleOwners[cell.Owner])
            {
                possibleBlocks.Add(possibleBlock);
            }

            mainBlock.PossibleBlocks = possibleBlocks;
        }
Exemplo n.º 7
0
        /// <summary>
        /// The input is the global list of MainBlocks, Grid.MainBlocks.
        /// </summary>
        /// <param name="mainBlocks"></param>
        /// <returns></returns>
        public static IMainBlock GetMainBlockWithFewestPossibleBlock(List <IMainBlock> mainBlocks)
        {
            //Keeps Tract of the MainBlock with the fewest remaining PossibleBlock.
            //It is returned and will be used to set each of its PossibleBlocks.
            IMainBlock MBWithFewestPB = null;

            foreach (IMainBlock mainBlock in mainBlocks)
            {
                if (mainBlock.Solution == -1)
                {
                    if (MBWithFewestPB == null)
                    {
                        MBWithFewestPB = mainBlock;
                    }
                    else if (mainBlock.PossibleBlocks.Count < MBWithFewestPB.PossibleBlocks.Count)
                    {
                        MBWithFewestPB = mainBlock;
                    }
                }
            }
            return(MBWithFewestPB);
        }
Exemplo n.º 8
0
 /// <summary>
 /// The MainBlock that this PossibleBlock belongs to. The SolutionTracker contains all possible DimensionSets.
 /// </summary>
 /// <param name="mainBlock"></param>
 /// <param name="solutionTracker"></param>
 public PossibleBlock(IMainBlock mainBlock)
 {
     MainBlock = mainBlock;
 }