private bool NeighborValid(int x, int y, ref CustomRect[][] map)
{
Point p = new Point(x, y);
bool inrange = InRange(p);
if (!inrange) return false;
bool notempty = map[x][y].Letter != ' ';
return (notempty);
}
private string[] ListPossibles(CustomRect[] crs, int len)
{
List<string> hs = new List<string>();
string str = "";
//Console.WriteLine("Possible words for length of {0}:", len);
for (int i = 0; i < crs.Length; i++)
{
crs[i].UpdateChainValue(); //update just in case
//if (crs[i].ChainedString.Equals("seam")) System.Diagnostics.Debugger.Break();
//if (crs[i].ChainedString.Equals("button")) System.Diagnostics.Debugger.Break();
if (!Regex.IsMatch(crs[i].ChainedString)) continue;
if (crs[i].ChainedString.Length != len) continue;
if (!SearchValid(FlattenChain(crs[i])))
{
//DebugFlatten((crs[i]));
continue;
}
do
{
str += crs[i].Letter;
crs[i] = crs[i].Parent;
} while (crs[i] != null);
hs.Add(Reverse(str));
str = "";
}
hs = hs.Distinct().ToList();
//check the word list
List<string> finals = new List<string>();
foreach (string word in Reader.WordList)
{
if (hs.Contains(word)) finals.Add(word);
}
#if (debug)
foreach (string item in finals)
{
Console.WriteLine(item);
}
#endif
return finals.ToArray();
}
private bool NeighborValid(Point p, ref CustomRect[][] map)
{
return NeighborValid(p.x, p.y, ref map);
}
private void DebugFlatten(CustomRect crs)
{
string str = "";
do
{
str += crs.Letter;
crs = crs.Parent;
} while (crs != null);
System.Diagnostics.Debug.WriteLine(Reverse(str));
}
/// <summary>
/// Returns from deepest to starting point
/// </summary>
private CustomRect[] FlattenChain(CustomRect cr)
{
Queue<CustomRect> qcr = new Queue<CustomRect>();
do
{
qcr.Enqueue(cr);
cr = cr.Parent;
} while (cr != null);
return qcr.ToArray();
}
public CustomRect Clone()
{
CustomRect cr = new CustomRect(loc, Parent, Letter);
cr.Visited = this.Visited;
cr.UpdateChainValue();
return cr;
}
public static void UpdateGrid(ref CustomRect[][] main)
{
//col -> row row row :: col -> row row row
//PrintGrid(ref main);
for (int i = 0; i < main.Length; i++)
{
for (int k = main.Length - 1; k >= 1; k--)
{
for (int kk = k - 1; kk >= 0; kk--)
{
if (main[k][i].Letter == ' ')
{
main[k][i].Letter = main[kk][i].Letter;
main[kk][i].Letter = ' ';
//PrintGrid(ref main);
//break; //stop inside looping
}
}
}
}
}
public CustomRect[][] RemoveWordFromGrid(ref CustomRect[] queue )
{
CustomRect[][] checkCR = new CustomRect[GridSize][];
for (int i = 0; i < GridSize; i++)
{
checkCR[i] = new CustomRect[GridSize];
for (int ii = 0; ii < GridSize; ii++)
{
checkCR[i][ii] = CRGrid[i][ii].Clone();
}
}
foreach (CustomRect item in queue)
{
checkCR[item.loc.x][item.loc.y].Letter = ' ';
}
return checkCR;
}
public CustomRect[][] RemoveWordFromGrid(ref CustomRect chainedCR, ref CustomRect[][] map)
{
CustomRect[][] checkCR = new CustomRect[GridSize][];
for (int i = 0; i < GridSize; i++)
{
checkCR[i] = new CustomRect[GridSize];
for (int ii = 0; ii < GridSize; ii++)
{
checkCR[i][ii] = map[i][ii].Clone();
}
}
do
{
checkCR[chainedCR.loc.x][chainedCR.loc.y].Letter = ' ';
chainedCR = chainedCR.Parent;
} while (chainedCR != null);
return checkCR;
}
public CustomRect[][] HardCopyGrid(CustomRect[][] source)
{
CustomRect[][] checkCR = new CustomRect[GridSize][];
for (int i = 0; i < GridSize; i++)
{
checkCR[i] = new CustomRect[GridSize];
for (int ii = 0; ii < GridSize; ii++)
{
checkCR[i][ii] = source[i][ii].Clone();
}
}
return checkCR;
}
public void Initialize()
{
WordLengths = Reader.WordLengths;
CRGrid = new CustomRect[Reader.GridSize][];
_Original = Reader.ProcessedInput;
for (int i = 0; i < GridSize; i++)
{
CRGrid[i] = new CustomRect[GridSize];
for (int ii = 0; ii < GridSize; ii++)
{
CRGrid[i][ii] = new CustomRect(new Point(i, ii), null, _Original[i][ii]);
}
}
for (int i = 0; i < GridSize; i++)
{
for (int ii = 0; ii < GridSize; ii++)
{
CRGrid[i][ii].SearchableNeighbors = CloneSearchableNeighbors(new Point(i, ii), ref CRGrid);
}
}
}
public void CopyGrid(ref CustomRect[][] target, CustomRect[][] source)
{
for (int i = 0; i < source.Length; i++)
{
for (int ii = 0; ii < source.Length; ii++)
{
target[i][ii] = source[i][ii];
}
}
}
public CustomRect[] CloneSearchableNeighbors(Point center, ref CustomRect[][] map)
{
List<CustomRect> list = new List<CustomRect>(GetNeighborClone(center));
for (int i = list.Count - 1; i >= 0; i--)
{
if (list[i].Visited) list.RemoveAt(i);
}
return list.ToArray();
}
public CustomRect[] CloneSearchableNeighbors(Point center, CustomRect[] queue)
{
List<CustomRect> list = new List<CustomRect>(GetNeighborClone(center));
for (int i = list.Count - 1; i >= 0; i--)
{
if ((queue.Contains(list[i])) || (list[i].Visited)) list.RemoveAt(i);
}
return list.ToArray();
}
private bool SearchComplete(ref CustomRect[][] grid)
{
UpdateGrid(ref grid);
bool allclear = true;
for (int i = 0; i < GridSize; i++) //each column
{
if (grid[GridSize - 1][i].Letter != ' ')
{
allclear = false;
}
}
return allclear;
}
/// <summary>
/// Tries solve recursive
/// </summary>
/// <param name="contfrom">Wordlength input position</param>
/// <param name="testg">tmp grid to use</param>
/// <returns>true: go deeper false: wrong word go back</returns>
public void Solve(int contfrom, CustomRect[][] testg)
{
CustomRect CRtmp;
string[] wordlist;
LinkedList<CustomRect> llcr = new LinkedList<CustomRect>();
List<CustomRect> finalsbackup = new List<CustomRect>();
CRGrid = testg;
for (int k = contfrom; k < WordLengths.Length; k++)
{
for (int i = 0; i < GridSize; i++)
{
for (int ii = 0; ii < GridSize; ii++)
{
if (CRGrid[i][ii].Letter == ' ') continue;
llcr.AddLast(CRGrid[i][ii].Clone());
TestBFS(llcr, WordLengths[k], finalsbackup);
llcr.Clear();
}
}
wordlist = ListPossibles(finalsbackup.ToArray(), WordLengths[k]);
foreach (string word in wordlist)
{
CRtmp = WordToCustomRect(word, finalsbackup.ToArray());
#if false
if (CRtmp == null)
{
System.Diagnostics.Debugger.Break();
}
#endif
CRGrid = RemoveWordFromGrid(ref CRtmp,ref CRGrid);
UpdateGrid(ref CRGrid);
if (SearchComplete(ref CRGrid))
{
SolutionStrings.Push(word);
completeflag = true;
return;
}
Solve(k + 1, HardCopyGrid(CRGrid));
CRGrid = HardCopyGrid(testg); //revert
if (completeflag)
{
SolutionStrings.Push(word);
if (k == 0)
{
ProcessCombination();
completeflag = false;
continue;
}
return;
}
}
return;
}
}
/// <summary>
/// Checks if this queue will cause the remaining grid to be invalid
/// </summary>
/// <param name="queue"></param>
/// <returns></returns>
private bool SearchValid(CustomRect[] queue)
{
CustomRect[][] checkCR = RemoveWordFromGrid(ref queue);
UpdateGrid(ref checkCR);
bool flag = false;
for (int i = 0; i < GridSize; i++) //each column
{
if (checkCR[GridSize - 1][i].Letter != ' ')
{
flag |= true;
}
}
return flag || SearchComplete(ref checkCR);
//return true;
}
public CustomRect WordToCustomRect(string word, CustomRect[] crs)
{
string str = "";
CustomRect backup;
for (int i = 0; i < crs.Length; i++)
{
if (!SearchValid(FlattenChain(crs[i]))) continue;
backup = crs[i];
do
{
str += crs[i].Letter;
crs[i] = crs[i].Parent;
} while (crs[i] != null);
//System.Diagnostics.Debug.WriteLine(Reverse(str));
if (word.Equals(Reverse(str)))
{
return backup;
}
str = "";
}
return null;
}
public CustomRect(Point pt, CustomRect p, char letter)
{
loc = pt;
Parent = p;
Visited = false;
Letter = letter;
Chained = GetChainValue();
}
public static void PrintGrid(ref CustomRect[][] main)
{
for (int i = 0; i < main.Length; i++)
{
for (int ii = 0; ii < main.Length; ii++)
{
Console.Write(main[i][ii].Letter);
}
Console.WriteLine();
}
}
