1.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.StringTokenizer;

/**
 * ACM Training 2009 ACM Problem #750 - 8 Queens Problem Link:
 * http://uva.onlinejudge.org/external/7/750.pdf
 *
 * @author Felix Dietrich
 * @version 1.0, 30/08/2009
 *
 * Methode: Backtracking
 * Status : Accepted
 * Runtime: 0.272s
 */

public class Main
{
    public static class Queen
    {
        public final Integer row;
        public final Integer col;

        public Queen(int row, int col)
        {
            this.row = row;
            this.col = col;
        }

    }

    public static void main(String... strings) throws IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int testcases = Integer.parseInt(br.readLine());
        boolean first = true;

        while (testcases > 0)
        {
            String input = br.readLine();
            if (input.length() > 0)
            {
                StringTokenizer st = new StringTokenizer(input);

                int row = Integer.parseInt(st.nextToken());
                int col = Integer.parseInt(st.nextToken());

                List<Queen> solution = new ArrayList<Queen>();
                solution.add(new Queen(row, col));

                if(!first)
                    ;//System.out.println();
                else
                    first = false;
                
                System.out
                        .println("SOLN       COLUMN\n #      1 2 3 4 5 6 7 8\n");

                int caseNumber = 1;
                printSolutions.clear();
                
                backtrack(solution, 1);
                
                Collections.sort(printSolutions);
                for(String s: printSolutions)
                    System.out.println((caseNumber < 10 ? " " : "") + (caseNumber++) + "      " + s);
                
                if (testcases > 1)
                    System.out.println();

                testcases--;
            }
        }
    }

    private static void backtrack(List<Queen> solution, int row)
    {
        //found solution
        if (row > 8)
        {
            printSolution(solution);
            return;
        }

        if (gotQueenHere(solution, row))
        {
            backtrack(solution, row + 1);
            return;
        }

        for (int col = 1; col <= 8; col++)
        {
            if (possibleFormation(solution, row, col))
            {
                ArrayList<Queen> l = new ArrayList<Queen>(solution);
                l.add(new Queen(row, col));
                backtrack(l, row + 1);
            }
        }
    }

    private static boolean gotQueenHere(List<Queen> solution, int row)
    {
        for (Queen q : solution)
        {
            if (q.row == row)
                return true;
        }
        return false;
    }

    private static List<String> printSolutions = new ArrayList<String>();

    private static void printSolution(List<Queen> solution)
    {
        StringBuilder sb = new StringBuilder();
        Collections.sort(solution, new Comparator<Queen>()
        {

            @Override
            public int compare(Queen arg0, Queen arg1)
            {
                if (arg0.col < arg1.col)
                    return -1;
                if (arg0.col > arg1.col)
                    return 1;
                return 0;
            }

        });
        StringBuilder line = new StringBuilder();
        for (Queen q : solution)
        {
            line.append(q.row + " ");
        }
        sb.append(line.toString().trim());
        
        printSolutions.add(sb.toString());
    }

    private static boolean possibleFormation(List<Queen> solution, Integer row,
            Integer col)
    {
        for (Queen queen : solution)
        {
            if (queen.row == row || queen.col == col
                    || Math.abs(queen.col - col) == Math.abs(queen.row - row))
            {
                return false;
            }
        }
        return true;
    }
}

2.

/**
 * ACM-Contest-Training
 * ACM Problem #750 - 8 Queens Chess Problem
 * Link: http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=9&page=show_problem&problem=691
 * @author Miesel Christoph
 * @version X.0 11.08.2009
 *
 * Status : Accepted
 * Runtime: 0.208
 */

import java.util.*;

public class EightQueens
{
    public static final int CONST = 8;
    // current positions (row-values per column-index)
    private static int[] pos;
    private static int row, col, column, counter = 0;
   
    static void writeSolution()
    {
        counter++;
        if(counter - counter % 10 <= 0)
            System.out.print(" "+counter+"     ");
        else System.out.print(counter+"     ");
        for(int i = 0; i < CONST; i++)
            System.out.print(" "+(pos[i]+1));
        System.out.println();
    }
   
   
    static boolean validPosition()
    {       
        if((pos[column] == row) || Math.abs(row - pos[column]) == Math.abs(col - column))
            return false;
        if(column == 0)
            return true;
        for(int i = 0; i < column; i++)       
        {
            if(i != col)
            {
                if(pos[column] == pos[i])
                    return false;
                if(Math.abs(pos[i] - pos[column]) == Math.abs(i - column))
                    return false;
            }
        }
        return true;
    }
       
    static boolean exists()
    {
        boolean back = true;
        if(!(column < CONST))
            back &= false;
        if(!(pos[column] < CONST))
            back &= false;
        return back;
    }
   
    static void beatHimDown()
    {
        if(++column == col)
            column++;
        if(column < CONST)
            pos[column] = 0;
    }   
   
    static void stepUp()
    {
        if(column == col)
            pos[++column] = 0;
        else pos[column]++;
    }
   
    static void stepDown()
    {
        if(--column != col)
            pos[column]++;
        else
        {
            column --;
            pos[column]++;
        }
    }
   
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
       
        int cases = sc.nextInt();
       
        for(int c = 0; c < cases; c++)
        {
        pos = new int[CONST];
        counter = 0;
        row = sc.nextInt() - 1;
        col = sc.nextInt() - 1;   
        pos[col] = row;
        System.out.println("SOLN       COLUMN");
        System.out.println(" #      1 2 3 4 5 6 7 8");
        System.out.println();
               
        // Back-Track
        if(col != 0)
        {
            column = 0;
            pos[column] = 0;
        }
        else
        {
            column = 1;
            pos[column] = 0;
        }
        while(column >= 0)
        {   
            if(exists())
            {
                if(validPosition())
                {
                    beatHimDown();
                    if(column == CONST)
                    {
                        writeSolution();
                        if(--column != col)
                            pos[column]++;
                        else
                        {
                            column--;
                            pos[column]++;
                        }
                    }
                }
                else stepUp();
            }
            else
            {
                if(column == CONST)
                {
                    column--;
                }
                else
                {
                    if(pos[column] == CONST)
                    {
                        if(--column != col)
                        {
                            if(column >= 0)
                                pos[column]++;
                        }
                       
                        else
                        {
                            if(--column >= 0)                   
                                pos[column]++;
                        }
                    }
                }
            }
        }
            if(c < cases-1)
                System.out.println();
        }
       
    }
}