N-Queens 問題

自己紹介

名前：津田伸秀

サイト： http://vivi.dyndns.org/

facebook：https://www.facebook.com/nobuhide.tsuda

twitter：vivisuke

枕詞：年齢不詳のおじさん

趣味：テニス、オセロ、思考ゲーム・パズル類

Qt/VC++ 使いの C++er, 一応webアプリも出来るよ

Windows用テキストエディタ ViVi を延々開発してます

Android・tmlib のパズルアプリも公開中だよ

迷走中

Contents

1. はじめに
   
2. 力まかせ探索（Brute-force search）
3. バックトラッキング
4. 制約テスト高速化（配置フラグ）
5. ビット演算（ビットマップ）による高速化
6. 対称解除去
7. 枝刈りによる高速化
8. さいごに
9. 参考文献

はじめに

力まかせ探索（Brute-force search）

• 全ての可能性のある解の候補を体系的に数えあげ、それぞれの解候補が問題の解となるかをチェックする方法
  
• パターン生成後にチェックするので「生成検査法（generate ＆ test）」とも呼ばれる
• 8-Queens の場合：
  
• 64箇所に8個のクイーンを置く場合の数は、
  64 C 8 = 4.4*10^9
• 各行には1個のクイーンしか置けないので、
  8^8 = 16,777,216 で充分
• N-Queens 問題の処理時間は O(N^N) となる
  
• int row[NQ]; に各行のクイーン位置（[1, NQ]）を保持
  
• 関数 test() で効きのチェックを行う
  
• 処理速度はかなり遅く、実用的ではない

N重ループによるコード

    int row[NQ];   //  各行のクイーン位置 [1, NQ]    for(row[0] = 1; row[0] <= NQ; ++row[0]) {
        ....
        for(row[NQ-1] = 1; row[NQ-1] <= NQ; ++row[NQ-1]) {
            if( 制約を満たしているか？ ) {
                解を発見;
            }
        }
        ....
    } 

再帰関数によるコード（ボードサイズはテンプレート引数で付与）

bool test(const int row[], int n)   //  n:配置済みクイーン数
{
    for(int r = 1; r < n; ++r) {
        for(int i = 0; i < r; ++i) {
            if( row[i] == row[r] || qAbs(row[i] - row[r]) == r - i )
                return false;
        }
    }
    return true;
}

template<int NQ>
void generateAndTest(int row[], int n)      //  配置済みクイーン数
{
    for(row[n] = 1; row[n] <= NQ; ++row[n]) {
        if( n + 1 == NQ ) {
            if( test<NQ>(row) )
                ++g_count;    // 解を発見
        } else
            generateAndTest<NQ>(row, n+1);
    }
}

パフォーマンス測定結果：

バックトラッキング

• パターンを生成し終わってからチェックを行うのではなく、途中で制約を満たさないことが明らかな場合は、 それ以降のパターン生成を行わない
• N-Queens 問題の処理時間は O(N!) 程度？となる

パフォーマンス測定結果：

• 処理量が O(N^N) → O(N!) となり、無駄な解候補生成が無くなった分、高速になった
• 探索速度：約3.8*10^7 NPS

制約テスト高速化（配置フラグ）

• 各列、対角線上にクイーンがあるかどうかのフラグを用意することで高速化を図る
• 詳細は８クイーン｜Ｎクイーン by パソコン初心者氏 を参照
• 下図は上記サイトから引用。各フラグを図示

template<int NQ>
void backtrackingFlags(
                    bool col[], bool rup[], bool rdn[],    // 垂直・対角線方向に配置済みフラグ
                    int n)      //  n:配置済みクイーン数, [0, NQ)
{
    for(int q = 0; q < NQ; ++q) {
        const int uix = n + q;
        const int dix = q - n + NQ - 1;
        if( !col[q] && !rup[uix] && !rdn[dix] ) {
            if( n + 1 == NQ )
                ++g_count;    // 解を発見
            else {
                col[q] = true;
                rup[uix] = true;
                rdn[dix] = true;
                backtrackingFlags<NQ>(col, rup, rdn, n+1);
                col[q] = false;
                rup[uix] = false;
                rdn[dix] = false;
            }
        }
    }
}

パフォーマンス測定結果：

• 前章の方法では、重複チェックに O(N) の時間を要するが、フラグを利用することで O(1) に短縮される
• 単純なバックトラッキング法に比べ、４倍程度高速になった
• 探索速度：約1.9*10^8 NPS、末端ノード数に変化は無いが、NPSが向上

ビット演算（ビットマップ）による高速化

• ビット演算によりさらに高速化を図る
• 状態をビットマップにパックし、処理する
• 各カラムに配置可能かどうかを cols で表す（初期値は (1<<NQ)-1）
• N = 32 or 64 が上限となり、配列に比べるとスケーラビリティに劣る
• が、世界記録（2009年7月）でも N = 26 なので、32 が上限でも問題にならない

• 斜め方向にクイーンを配置したかどうかをビットマップのフラグで表す（lt, rt）
• ビットマップであれば、シフトにより高速にデータを移動できる
• フラグ配列ではデータの移動に O(N) の時間がかかるが、ビットマップであれば O(1)
• 前章のフラグ配列のように斜め方向に 2*N-1 の要素を用意するのではなく N ビットで充分
• 初期値は０

• これはビット演算（ビットマップ）でよく使用するテクニックのひとつである
• -x = ~x + 1 であることを考えると、分かりやすい

 template<int NQ>
void backtrackingBitmap(uint cols,      //  配置可能カラム位置
                    uint lt, uint rt,   //  1 for 使用済み
                    int n)              //  n:配置済みクイーン数, [0, NQ)
{
    uint flags = ~(lt|rt) & cols;
    while( flags ) {
        uint bit = -flags & flags;      //  一番右の１のビットを取り出す
        if( n + 1 == NQ )
            ++g_count;    // 解を発見
        else
            backtrackingBitmap<NQ>(cols^bit, (lt|bit)<<1, (rt|bit)>>1, n+1);
        flags ^= bit;       //  処理済みビットをOFF
    }
}

• 計算量（オーダー）は変わっていないが、単純なバックトラッキング法よりも20～30倍程度高速になった。
• 探索速度：約3.4*10^7 NPS、NPSが減少するも、末端ノード数がそれ以上に減少
• 配置可能な場所を dn, lt, rt のビット演算で求め、可能な場所についてのみ処理しているので、 配置不可能な位置は末端ノードとしてはカウントしていない
• パターンを生成してから重複チェックを行うのではなく、解の可能性があるかどうかを予めチェックし、 無ければバックトラッキングを行うという方法（Forward Checking 法）もある
• が、実装して速度計測してみたところ Bitmap 法よりも遅くなってしまった
• Bitmap 法があまりに単純・高速なためにパターンの生成と単なるチェックに処理時間差が無いためと考えられる

対称解除去

• ひとつの解には、盤面を90度・180度・270度回転、及びそれらの鏡像の合計8個の対称解が存在する

		１２ ４１ ３４ ２３
		４３ ３２ ２１ １４

		２１ １４ ４３ ３２
		３４ ２３ １２ ４１
		

• 上図左上がユニーク解。１行目はユニーク解を90度、180度、270度回転したもの
• 2行目は1行目のそれぞれを左右反転したもの。
• 2行目はユニーク解を左右反転、対角反転、上下反転、逆対角反転したものとも解釈可
• ただし、回転・線対称な解もある

• 対称的な解を除去し、ユニーク解のみを求める方法はいくつかあるが、解がみつかるとすべての対称解を生成し、 状態を数値とみなして最も小さいもののみを解とする方法（最小解選択法）が優れる
• 状態→数値の変換方法は任意である
• 変換された数値を「ユニーク判定値」と呼ぶ
• 例えば、各行のクイーン位置を数値（1～N）で表したN桁の数で充分
• 上図の様な場合、数値を４桁の数とみなすと、左上の「１２４３」が最小であり、ユニーク解となる
• 解を全て保存しておき、新しい解が発見されるたびに対称形が無いかどうかを調べる方法もあるが、 保存領域を必要とするし、比較時に対称形を生成する必要があり、最小解選択法より劣る

 uint g_row[MAX_N];      //  ボード状態//  90度、180度、270度回転・およびその鏡像よりも小さいか等しい場合は true を返す
template<int NQ>
bool checkSymmetryBitmap()
{
    uint t[NQ], t2[NQ];
    revHorzBitmap<NQ>(g_row, t2);
    if( less<NQ, uint>(t2, g_row) ) return false;
    rotateBitmap90<NQ>(g_row, t);
    if( less<NQ, uint>(t, g_row) ) return false;
    revHorzBitmap<NQ>(t, t2);
    if( less<NQ, uint>(t2, g_row) ) return false;
    rotateBitmap90<NQ>(t, t2);
    if( less<NQ, uint>(t2, g_row) ) return false;
    revHorzBitmap<NQ>(t2, t);
    if( less<NQ, uint>(t, g_row) ) return false;
    rotateBitmap90<NQ>(t2, t);
    if( less<NQ, uint>(t, g_row) ) return false;
    revHorzBitmap<NQ>(t, t2);
    if( less<NQ, uint>(t2, g_row) ) return false;
    return true;
}

 template<int NQ>
void backtrackingBitmapS(uint cols,
                    uint lt, uint rt,     //  1 for 使用済み
                    int n)      //  n:配置済みクイーン数, [0, NQ)
{
    uint flags = ~(lt|rt) & cols;
    if( n + 1 == NQ ) {
        if( flags != 0 ) {
            g_row[n] = flags;
            if( checkSymmetryBitmap<NQ>() ) {
                ++g_count;
            }
        }
    } else {
        while( flags ) {
            uint bit = -flags & flags;      //  一番右の１のビットのみ取り出す
            g_row[n] = bit;
            backtrackingBitmapS<NQ>(cols^bit, (lt|bit)<<1, (rt|bit)>>1, n+1);
            flags ^= bit;       //  処理済みビットをOFF
        }
    }
}

パフォーマンス測定結果：

• ビットマップ法に比べ、探索局面数は変わらないのに対称解除去の処理が増えた分、処理時間を要している
  

枝刈りによる高速化

• 前章のコードは全ての解を求めた後に、ユニーク解以外の対称解を除去していた
• ある意味、「生成検査法（generate ＆ test）」と同じである
• 問題の性質を分析し、バックトラッキング/前方検査法と同じように、無駄な探索を省略することを考える
• ユニーク解に対する左右対称解を予め削除するには、1行目のループのところで、 右半分だけにクイーンを配置するようにすればよい
• Nが奇数の場合、クイーンを1行目中央に配置する解は無い。
• 他の3辺のクィーンが中央に無い場合、その辺が上辺に来るよう回転し、場合により左右反転することで、 最小値解とすることが可能だから、中央に配置したものしかユニーク解には成り得ない
• しかし、上辺とその他の辺の中央にクィーンは互いの効きになるので、配置することが出来ない

 template<int NQ>
void backtrackingBitmapS()
{
    g_count = 0;
    for(uint mask = 1<<(NQ/2-1); mask; mask>>=1) {
        g_row[0] = mask;
        backtrackingBitmapS<NQ>(mask<<1, mask, mask>>1, 1);
    }
}

• １行目角にクイーンがある場合、とそうでない場合で処理を分ける

 template<int NQ>
void backtrackingBitmapS()
{
    g_count = 0;
    for(uint mask = 1<<(NQ/2-1); mask; mask>>=1) {
        g_row[0] = mask;
        if( mask == 1 )    //  角にクイーンを配置した場合
            .....
        else
            .....
        }
}

• １行目角にクイーンがある場合、回転対称形チェックを省略することが出来る
• １行目角にクイーンがある場合、他の角にクイーンを配置することは不可
• 鏡像についても、主対角線鏡像のみを判定すればよい
• ２行目、２列目を数値とみなし、２行目＜２列目という条件を課せばよい

 //  １行め角にクイーンを配置した場合template<int NQ>
void backtrackingBitmapSCorner(uint lt, uint dn, uint rt,
                    int n)      //  配置済み個数
{
    uint flags = ~(lt|dn|rt) & ((1<<NQ)-1);
    if( n == NQ - 1 ) {
        if( flags ) {
            g_row[n] = flags;
            ++g_count;
        }
    } else {
        if( (1<<n) <= g_row[1] )
            flags &= ~2;        //  主対角線鏡像を枝刈り
        while( flags ) {
            uint bit = -flags & flags;
            flags ^= bit;
            g_row[n] = bit;
            backtrackingBitmapSCorner<NQ>((lt|bit)<<1, (dn|bit), (rt|bit)>>1, n+1);
        }
    }
}

 template<int NQ>
void backtrackingBitmapS()
{
    g_count = 0;
    for(uint mask = 1; mask < (1<<NQ/2); mask<<=1) {
        g_row[0] = mask;
        if( mask == 1 ) {
            uint flags = ((1<<NQ-1) - 1) ^ 3;
            while( flags ) {
                uint bit = -flags & flags;
                flags ^= bit;
                g_row[1] = bit;
                backtrackingBitmapSCorner<NQ>((bit<<1)|(1<<2), bit|1, bit>>1, 2);
            }
        } else
            .....
        }
}

• １行目角にクイーンが無い場合、クイーン位置より右位置の８対称位置にクイーンを置くことはできない
• 置いた場合、回転・鏡像変換により得られる状態のユニーク判定値が明らかに大きくなる

    ☓☓☓・・Ｑ☓☓☓
    ☓・・・・・・・☓
    ☓・・・・・・・☓
    ｃ・・・・・・・rt
    ・・・・・・・・・
    lt・・・・・・・ａ
    ☓・・・・・・・☓
    ☓・・・・・・・☓
    ☓☓☓ｂ・dn☓☓☓    

uint g_prohibit;    // 配置可能位置フラグ    
template<int NQ>
void backtrackingBitmapSEdge(uint lt, uint dn, uint rt,
                    int n)      //  配置済み個数
{
    uint flags = ~(lt|dn|rt) & ((1<<NQ)-1);
    if( n == NQ - 1 ) {
        flags &= g_prohibit;
        if( flags ) {
            g_row[n] = flags;
            if( symmetryCheck<NQ>() ) {
                ++g_count;
            }
        }
    } else {
        if( !((1<<n) & g_prohibit) )
            flags &= ~(1|(1<<NQ-1));
        while( flags ) {
            uint bit = -flags & flags;
            flags ^= bit;
            g_row[n] = bit;
            backtrackingBitmapSEdge<NQ>((lt|bit)<<1, (dn|bit), (rt|bit)>>1, n+1);
        }
    }
}

 template<int NQ>
void backtrackingBitmapS2()
{
    g_count = 0;
    for(uint mask = 1; mask < (1<<(NQ/2)); mask<<=1) {
        g_row[0] = mask;
        if( mask == 1 ) {
            .....
        } else {
            g_prohibit = mask - 1;
            g_prohibit |= reverse<NQ>(g_prohibit);
            g_prohibit = ~g_prohibit;       //  配置可能フラグ
            backtrackingBitmapSEdge<NQ>(mask<<1, mask, mask>>1, 1);
        }
    }
}

• ユニーク解数を得るための枝刈りにより、末端局面数が大幅に減り、処理時間も6倍程度高速になった
• 解総数を求めるビットマップ法に比べても約４倍高速である
• 探索速度：約5.7*10^6 NPS

さいごに

• N-Queens 問題を４種のアルゴリズム/データ構造で記述し、パフォーマンス計測を行った
  
• ビットマップを用いるバックトラッキングが予想以上に高速であった
  
• N-Queens 問題の分析に基づく枝刈りにより、さらなる高速化が達成できた
  
• N-Queens 問題は単純な探索問題だと思っていたが、予想外に奥が深く、びっくりしたでござる
  

参考文献

• ビットマップを N-Queens に最初に応用したのは Jeff Somers 氏のようだ。
  参照： The N Queens Problem
  
• 対称解の除去方法については、takaken氏による詳しい解説がある
  参照： Ｎクイーン問題（解の個数を求める）
  
• 2004年、電気通信大学の研究グループが、処理を並列化し、N=24 の解の個数を世界で初めて発見。
  参照： N-queens Homepage in Japanese