【HDOJ】1979 Fill the blanks

预处理+搜索剪枝。
4*4的边界上的数字必须是奇数。

/* 1979 */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
//#pragma comment(linker,"/STACK:102400000,1024000")

#define sti                set<int>
#define stpii            set<pair<int, int> >
#define mpii            map<int,int>
#define vi                vector<int>
#define pii                pair<int,int>
#define vpii            vector<pair<int,int> >
#define rep(i, a, n)     for (int i=a;i<n;++i)
#define per(i, a, n)     for (int i=n-1;i>=a;--i)
#define clr                clear
#define pb                 push_back
#define mp                 make_pair
#define fir                first
#define sec                second
#define all(x)             (x).begin(),(x).end()
#define SZ(x)             ((int)(x).size())
#define lson            l, mid, rt<<1
#define rson            mid+1, r, rt<<1|1

typedef struct node_t {
    char s[20];

    node_t() {}
    node_t(int a[][4]) {
        int l = 0;
        rep(i, 0, 4)
            rep(j, 0, 4)
                s[l++] = a[i][j]+'0';
        s[l] = '';
    }

    friend bool operator< (const node_t& a, const node_t& b) {
        return strcmp(a.s, b.s)<0 ? true:false;
    }

    friend bool operator== (const node_t& a, const node_t& b) {
        return strcmp(a.s, b.s)==0;
    }

    friend bool operator!= (const node_t& a, const node_t& b) {
        return strcmp(a.s, b.s)!=0;
    }

    void print() {
        for (int i=0; i<16; i+=4) {
            for (int j=0; j<4; ++j)
                putchar(s[i+j]);
            putchar('
');
        }
    }

} node_t;

const int maxn = 10001;
bool isPrime[maxn];
bool valid[maxn];
int a[maxn], an;
int b[maxn], bn;
int c[maxn], cn;
bool M03[10][10];
vector<node_t> ans;
vi AV21[100];
vi AV30[100];
vi CV21[100];
vi CV30[100];
int M[4][4];

void getV(int* a, int n, vi vc30[], vi vc21[]) {
    int d[4];

    rep(i, 0, n) {
        int x = a[i];
        rep(j, 0, 4) {
            d[j] = x % 10;
            x /= 10;
        }
        int v30 = d[3]*10+d[0];
        int v21 = d[2]*10+d[1];
        vc30[v30].pb(v21);
        vc21[v21].pb(v30);
    }

    vi::iterator iter;
    rep(i, 0, 100) {
        sort(all(vc30[i]));
        iter = unique(all(vc30[i]));
        vc30[i].erase(iter, vc30[i].end());

        sort(all(vc21[i]));
        iter = unique(all(vc21[i]));
        vc21[i].erase(iter, vc21[i].end());
    }
}

void init() {
    int i, j, k;
    int x;
    int d[4];

    an = bn = cn = 0;
    memset(isPrime, true, sizeof(isPrime));
    memset(valid, false, sizeof(valid));
    isPrime[0] = isPrime[1] = false;

    for (i=2; i<maxn; ++i) {
        if (isPrime[i]) {
            b[bn++] = i;
            for (j=i*i; j<maxn; j+=i)
                isPrime[j] = false;
        }
    }

    memset(M03, false, sizeof(M03));
    for (i=0; i<bn; ++i) {
        x = b[i];
        if (valid[x])
            continue;
        for (j=0; j<4; ++j) {
            d[j] = x % 10;
            x /= 10;
        }
        if ((d[0]&1)==0 || (d[3]&1)==0)
            continue;
        x = 0;
        for (j=0; j<4; ++j) {
            x = x * 10 + d[j];
        }
        if (isPrime[x]) {
            valid[x] = valid[b[i]] = true;
            a[an++] = x;
            a[an++] = b[i];
            M03[d[0]][d[3]] = M03[d[3]][d[0]] = true;
            bool flag = true;
            for (j=0; j<4; ++j) {
                if ((d[j] & 1)==0) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                c[cn++] = x;
                c[cn++] = b[i];
            }
        }
    }

    sort(a, a+an);
    an = unique(a, a+an) - a;
    sort(c, c+cn);
    cn = unique(c, c+cn) - c;

    getV(a, an, AV30, AV21);
    getV(c, cn, CV30, CV21);
}

void solve_() {
    int v30 = 10*M[0][0]+M[3][3];
    int v30_ = 10*M[0][3]+M[3][0];

    int sz = SZ(AV30[v30]);
    int sz_ = SZ(AV30[v30_]);
    rep(i, 0, sz) {
        int v21 = AV30[v30][i];
        M[1][1] = v21/10;
        M[2][2] = v21%10;
        rep(j, 0, sz_) {
            int v21_ = AV30[v30_][j];
            M[1][2] = v21_/10;
            M[2][1] = v21_%10;

            int v1 = M[0][1]*1000+100*M[1][1]+M[2][1]*10+M[3][1];
            int v2 = M[0][2]*1000+100*M[1][2]+M[2][2]*10+M[3][2];
            int v3 = M[1][0]*1000+100*M[1][1]+M[1][2]*10+M[1][3];
            int v4 = M[2][0]*1000+100*M[2][1]+M[2][2]*10+M[2][3];

            if (valid[v1] && valid[v2] && valid[v3] && valid[v4]) {
                ans.pb(node_t(M));
            }
        }
    }
}

void solve() {
    int d1[4];
    int d2[4];
    int d3[4];

    rep(i, 0, cn) {
        int x = c[i];
        rep(dd, 0, 4) {
            d1[dd] = x % 10;
            x /= 10;
        }
        int f1 = d1[3];
        int e1 = d1[0];
        rep(j, 0, cn) {
            int x = c[j];
            rep(dd, 0, 4) {
                d2[dd] = x % 10;
                x /= 10;
            }
            int f2 = d2[3];
            int e2 = d2[0];
            if (f1 != f2)
                continue;
            rep(k, 0, cn) {
                int x = c[k];
                rep(dd, 0, 4) {
                    d3[dd] = x % 10;
                    x /= 10;
                }
                int f3 = d3[3];
                int e3 = d3[0];
                if (f3 != e1)
                    continue;

                int v30 = e2*10 + e3;
                int sz_CV30 = SZ(CV30[v30]);
                rep(ii, 0, sz_CV30) {
                    int v21 = CV30[v30][ii];
                    int x3 = v21/10;
                    int y3 = v21%10;

                    M[0][0] = d1[3];
                    M[0][1] = d1[2];
                    M[0][2] = d1[1];
                    M[0][3] = d1[0];

                    M[1][0] = d2[2];
                    M[2][0] = d2[1];
                    M[3][0] = d2[0];

                    M[1][3] = d3[2];
                    M[2][3] = d3[1];
                    M[3][3] = d3[0];

                    M[3][1] = x3;
                    M[3][2] = y3;
                    
                    solve_();
                }
            }
        }
    }
}

void print() {
    sort(all(ans));
    vector<node_t>::iterator iter = unique(all(ans));
    ans.erase(iter, ans.end());
    int sz = SZ(ans);
    ans[0].print();
    rep(i, 1, sz) {
        putchar('
');
        ans[i].print();
    }
}

int main() {
    ios::sync_with_stdio(false);
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
        freopen("data.out", "w", stdout);
    #endif

    init();
    solve();
    print();

    #ifndef ONLINE_JUDGE
        printf("time = %d.
", (int)clock());
    #endif

    return 0;
}