#include <iostream>
#define MAX_QUEEN_NUM   8
#define BOARD_SIZE      8
#define MAX_POSITION    7
#define MIN_POSITION    0
#define NO_DATA         0xF

class EightQueen
{
public:
    EightQueen()
    {
        primaryNum = 0;
        
        for(int i=0; i<BOARD_SIZE; ++i)
        {
            tmpRowPosition[i]       = NO_DATA;
            tmpColumnPosition[i]    = NO_DATA;
        }
    }
    
    ~EightQueen(){;}
    
    void make(void)
    {
        input();
        search(primaryNum);
        output();
    }
    
    
private:
    int primaryNum;             /* 初期配置のQueen数 */
    int tmpRowPosition[8];      /* N番目に置かれたQueenの行番号 */
    int tmpColumnPosition[8];   /* N番目に置かれたQueenの列番号 */

    /**
     * @brief 標準入力からQueenの初期配置数、位置を取得する
     */
    void input(void)
    {
        std::cin >> primaryNum;
        
        int rowPosition     = 0;
        int columnPosition  = 0;
        for(int index = 0; index < primaryNum; ++index)
        {
            std::cin >> rowPosition >> columnPosition;
            setQueen(index, rowPosition, columnPosition);
        }
    }
    
    /**
     * @brief これから置くN番目のQueenの位置を再帰呼び出しで探索
     * 
     * @param[in]   index           何番目に仮置きするQueenか
     * @return      設置数が8個 = true, 設置数が7個以下 = false
     */
    bool search(int currentQueenIndex)
    {
        if(currentQueenIndex > MAX_QUEEN_NUM - 1) /* 設置数が8個になったら探索終了 */
        {
            return true;
        }
        
        for(int rowPosition = 0; rowPosition < BOARD_SIZE; ++rowPosition)
        {
            for(int columnPosition = 0; columnPosition < BOARD_SIZE; ++columnPosition)
            {
                /* 現在注目しているマスがQueenを設置可能か確認 */
                if(isPossiblePosition(rowPosition, columnPosition))
                {
                    /* 可能なら、今のマスにN番目のQueenを仮置き */
                    setQueen(currentQueenIndex, rowPosition, columnPosition);
                    
                    if(!search(currentQueenIndex + 1))  /* N+1番目のQueenを設置 */
                    {
                        /* 次を置こうとしたが置けなかったので、N番目のQueenの仮置きをやめて次のマスへ進む */
                        clrQueen(currentQueenIndex);
                    }
                    else
                    {
                        /* 8個置けたので、これまでの再帰呼び出しをすべてtureで返す */
                        return true;
                    }
                }
                else
                {
                    /* 不可能なら、次のマスへ進む */
                }
            }
        }
        return false;
    }
    
    /**
     * @brief 指定したマスがQueenの置けるマスか
     * 
     * @param[in]   rowPosition     行番号
     * @param[in]   columnPosition  列番号
     * @return      置ける = true, 置けない = false
     */
    /* 指定された座標から見て8方向にQueenがなければtrueを返す */
    bool isPossiblePosition(int rowPosition, int columnPosition)
    {
        for(int i = 0; (i <= MAX_POSITION); ++i)
        {
            /* 水平方向 */
            if(tmpRowPosition[i] == rowPosition)
            {
                return false;
            }
            /* 垂直方向 */
            if(tmpColumnPosition[i] == columnPosition)
            {
                return false;
            }
        }
        
        /* 右上方向 */
        for(int i = rowPosition - 1 , j = columnPosition + 1;
            (i >= MIN_POSITION) && (j <= MAX_POSITION);
            --i, ++j)
        {
            if(isQueenExists(i, j))
            {
                return false;
            }
        }
        
        /* 右下方向 */
        for(int i = rowPosition + 1 , j = columnPosition + 1;
            (i <= MAX_POSITION) && (j <= MAX_POSITION);
            ++i, ++j)
        {
            if(isQueenExists(i, j))
            {
                return false;
            }
        }
        
        /* 左下方向 */
        for(int i = rowPosition + 1 , j = columnPosition - 1;
            (i <= MAX_POSITION) && (j >= MIN_POSITION);
            ++i, --j)
        {
            if(isQueenExists(i, j))
            {
                return false;
            }
        }
        
        /* 左上方向 */
        for(int i = rowPosition - 1 , j = columnPosition - 1;
            (i >= MIN_POSITION) && (j >= MIN_POSITION);
            --i, --j)
        {
            if(isQueenExists(i, j))
            {
                return false;
            }
        }
        
        return true;
    }
    
    /**
     * @brief 指定したマスにQueenを仮置きする
     * 
     * @param[in]   index           何番目に仮置きしたQueenか
     * @param[in]   rowPosition     行番号
     * @param[in]   columnPosition  列番号
     */
    void setQueen(int index, int rowPosition, int columnPosition)
    {
        tmpRowPosition[index] = rowPosition;
        tmpColumnPosition[index] = columnPosition;
    }
    
    /**
     * @brief 指定した仮置きQueenを取り消す
     * 
     * @param[in]   index           何番目に仮置きしたQueenか
     */
    void clrQueen(int index)
    {
        tmpRowPosition[index] = NO_DATA;
        tmpColumnPosition[index] = NO_DATA;
    }
    
    /**
     * @brief 指定したマスにQueenが居るか
     * 
     * @param[in]   rowPosition     行番号
     * @param[in]   columnPosition  列番号
     * @return      指定したマスにQueenが居る = true, 居ない = false
     */
    bool isQueenExists(int rowPosition, int columnPosition)
    {
        bool result = false;
        for(int index = MIN_POSITION; index <= MAX_POSITION; ++index)
        {
            if( (tmpRowPosition[index] == rowPosition) && (tmpColumnPosition[index] == columnPosition) )
            {
                result = true;
            }
        }
        return result;
    }
    
    /**
     * @brief 現在のQueenリストを二次元の図として出力する
     */
    void output(void)
    {
        for(int rowPosition = 0; rowPosition < BOARD_SIZE; ++rowPosition)
        {
            for(int columnPosition = 0; columnPosition < BOARD_SIZE; ++columnPosition)
            {
                /* 登録されていたら「Q」を表示 */
                if(isQueenExists(rowPosition, columnPosition))
                {
                     std::cout << 'Q';
                }
                else
                {
                     std::cout << '.';
                }
            }
            std::cout << std::endl;
        }
    }
    
};


/**
 * @brief 形だけのmain
 */
int main(void)
{
    EightQueen eightQueen;
    eightQueen.make();
    
    return 0;
}



Measured memory_bytes: 3116