1. 
/**
* FWP, Ausgewählte Probleme aus dem ACM Programming Contest, SS10
* Problem: 422 Word-Search Wonder
* Link: http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=23&page=show_problem&problem=2113
*
* @author Reichart Robert
*
* Status : Accepted
* Runtime: 0.192
*/

import java.util.*;

class Main{
static char[][] puzzle;

public static void main(String... args){
Scanner in = new Scanner(System.in);
int u = in.nextInt();
String line = in.nextLine();
while (u!=0)
{
//==============================================Array einlesen==============================================
puzzle = new char[u][u];
for (int i=0;i<u;i++){
line=in.nextLine();
char[] chars;
chars=line.toCharArray();
for (int k=0;k<u;k++)
{
puzzle[i][k]=chars[k];
}
}
//==============================================Wörter einlesen==============================================
ArrayList<String> words = new ArrayList<String>();
boolean INT=false;
while(!INT)
{
try{
line = in.nextLine();
u=Integer.parseInt(line);
INT=true;
}catch(Exception ex){
words.add(line);
}
}
//==============================================Wörter im Array Suchen==============================================
for (int i=0;i<words.size();i++)
{
int[] tmp= getcoordinates(words.get(i),false);
if (tmp[0]<0){
System.out.println("Not found");
}
else
{
System.out.println((tmp[0]+1) + "," + (tmp[1]+1) + " " + (tmp[2]+1) + "," + (tmp[3]+1));
}
}
}
}

/**
* Sucht ein Wort im array.
* @param word Wort das gesucht werden soll
* @param reverse gibt an ob das wort umgedreht wurde oder nicht
* @return due koordinaten des wortes. Array ist mit "-1" gefüllt wenn das Wort nicht gefunden werden konnte
*/
static int[] getcoordinates(String word, boolean reverse){
int[] charindex;
int[] coor = new int[4];
coor[0]=-1;
coor[1]=-1;
coor[2]=-1;
coor[3]=-1;

charindex=findChar(0,0,word.charAt(0));
while(charindex[0]>=0){
//==============================================Wort von oben nach unten==============================================
if (charindex[0]+word.length()<=puzzle.length){
if (robot(charindex[0],charindex[1],0,1,word))
{
coor[0]=charindex[0];
coor[1]=charindex[1];
coor[2]=charindex[0]+word.length()-1;
coor[3]=charindex[1];
return coor;
}
}
//==============================================Wort von links unten nach rechts oben==============================================
if (charindex[0]-word.length()+1>=0 && charindex[1]+word.length()<=puzzle.length){
if (robot(charindex[0],charindex[1],1,-1,word))
{
coor[0]=charindex[0];
coor[1]=charindex[1];
coor[2]=charindex[0]-word.length()+1;
coor[3]=charindex[1]+word.length()-1;
return coor;
}
}

//==============================================Wort von links nach rechts==============================================
if (charindex[1]+word.length()<=puzzle.length){
if (robot(charindex[0],charindex[1],1,0,word))
{
coor[0]=charindex[0];
coor[1]=charindex[1];
coor[2]=charindex[0];
coor[3]=charindex[1]+word.length()-1;
return coor;
}
}

//==============================================wort von links oben nach rechts unten==============================================
if (charindex[0]+word.length()<=puzzle.length && charindex[1]+word.length()<=puzzle.length){
if (robot(charindex[0],charindex[1],1,1,word))
{
coor[0]=charindex[0];
coor[1]=charindex[1];
coor[2]=charindex[0]+word.length()-1;
coor[3]=charindex[1]+word.length()-1;
return coor;
}
}
charindex=findChar(charindex[0],charindex[1]+1,word.charAt(0));
}
//==============================================Wurde das wort nicht gefunden und noch nicht umgedreht. Wort umdrehen und nochmals suchen
if (!reverse){
int tmp[] = getcoordinates(new StringBuilder(word).reverse().toString(),true);
coor[0]=tmp[2];
coor[1]=tmp[3];
coor[2]=tmp[0];
coor[3]=tmp[1];
}
return coor;
}

/**
* Gibt den INDEX des gesuchten CHARs in dem Array zurück.
* Sollte der CHAR nicht im Array zu finden sein ist dass Array mit "-1" gefüllt
* @param y StartZeile
* @param x StartSpalte
* @param c CHAR der gesucht werden soll
* @return Array mit dem Index der Zeile und der Spalte. Sollte der Char nicht zu finden sein ist das Array mit "-1" gefüllt
*/
static int[] findChar(int y, int x, char c){
//System.out.println("FINDCHAR=>" + y + " - " + x + " - " + c);
int[] coor = new int[2];
coor[0]=-1;
coor[1]=-1;

for (int i=0;i<puzzle.length;i++){
if (i<y){continue;}
for (int k=0;k<puzzle.length;k++){
if(i==y && k<x){continue;}
if (puzzle[i][k]==c){
coor[0]=i;
coor[1]=k;
return coor;
}
}
}
return coor;
}

/**
* Läuft über das CHARarray mit vorgegebener Richtung und kontrolliert,
* ob die CHARs in der Richtung mit dem Wort zusammen passen.
* @param y StartZeile
* @param x StartSpalte
* @param xx Bewegung nach "unten"
* @param yy Bewegung nach "oben"
* @param word Wort das kontrolliert werden soll
* @return True wenn das Wort mit den CHARs
*/
static boolean robot(int y,int x, int xx, int yy, String word)
{
for (int i=0;i<word.length();i++)
{
if (x>=puzzle.length || y>=puzzle.length || x<0 || y<0){return false;}
if(puzzle[y][x]!=word.charAt(i)){return false;}
x+=xx;
y+=yy;
}
return true;
}
}

2.

/**
* FWP, Ausgewählte Probleme aus dem ACM Programming Contest, SS10
* Problem: 422 - Word-Search Wonder
* Link: http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=6&page=show_problem&problem=363
*
* @author Evgeni Pavlidis
* @version 1.0, 06/02/2010
*
* Method : Ad hoc & Brute Force
* Status : Accepted
* Runtime: 0.500
*/

import java.io.*;
import java.util.*;

class Main {

private static int saveX;
private static int saveY;
private static char m[][] = new char[100][100];

static class Point {
int x,y;
Point(int x, int y) { this.x = x; this.y = y; }
public String toString() { return (y+1) + "," + (x+1); }
}

static boolean check(String t, Point start, Point end)
{
int dx = end.x - start.x;
if(dx != 0)
dx = dx / Math.abs(dx);

int dy = end.y - start.y;
if(dy != 0)
dy = dy / Math.abs(dy);

Point p = new Point(start.x, start.y);

for(int i = 1; i < t.length()-1; i++)
{
p.x += dx;
p.y += dy;
if(m[p.y][p.x] != t.charAt(i))
return false;
}
return true;
}

static int dist(Point a, Point b)
{
if(a.x == b.x)
return Math.abs(a.y - b.y)+1;
if(a.y == b.y)
return Math.abs(a.x - b.x)+1;
if(Math.abs(a.x - b.x) == Math.abs(a.y - b.y))
return Math.abs(a.x-b.x)+1;

return -1;
}

public static void main(String...args) throws Exception
{
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

Map<Character,Set<Point>> map = new HashMap<Character, Set<Point>>();
boolean found;

int n = Integer.parseInt(reader.readLine());

String input;
for(int y = 0; y < n; y++)
{
input = reader.readLine();
for(int x = 0; x < n; x++)
{
m[y][x] = input.charAt(x);

if(!map.containsKey(input.charAt(x)))
map.put(input.charAt(x), new HashSet<Point>());

map.get(input.charAt(x)).add(new Point(x,y));
}
}

while(!(input = reader.readLine()).equals("0"))
{
found = false;
if(map.containsKey(input.charAt(0)) && map.containsKey(input.charAt(input.length()-1)))
for(Point start: map.get(input.charAt(0)))
for(Point end: map.get(input.charAt(input.length()-1)))
if(dist(start, end) == input.length() && check(input, start, end))
{
found = true;
System.out.println(start + " " + end);
}

if(!found)
System.out.println("Not found");
}
}
}