URAL 1519 Formula 1 (插头)

问用一条回路覆盖网格里的所有空格子有几种方法

虽然是论文的大裸入门题，但是AC跳出来还是好激动 =.=

最小表示：

#include <cstring>
#include <algorithm>
#include <iostream>
#include <vector>
#include <string>
using namespace std;
typedef __int64 lld;
const int N = 1001003;
int n,m,tot,code[15];
vector<string> s;
lld f[2][N],*cur,*nex;
struct Hash {
        struct Node { lld v; int id; Node *next; };
        int mod;
        Node *table[N],memo[N];
        void init() {
                mod = 1e6+3;
                tot = 0;
                for (int i = 0; i < mod; i ++) table[i] = NULL;
        }
        int operator [] (lld x) {
                int idx = x%mod;
                for (Node *i = table[idx]; i ; i = i->next)
                        if (i->v==x) return i->id;
                memo[tot] = (Node){x,tot,table[idx]};
                table[idx] = &memo[tot];
                return tot ++;
        }
}hs;
void decode(lld x) {
        for (int i = 0; i <= m; i ++)
                code[i] = x>>(i*3)&7;
}
int encode() {
        lld x = 0;
        for (int i = m; i >= 0; i --) x = x<<3|code[i];
        return hs[x];
}
void recode() {
        int rt[8],cnt = 1;
        memset(rt,-1,sizeof(rt)); rt[0] = 0;
        for (int i = 0; i <= m; i ++) {
                if (rt[code[i]]==-1) rt[code[i]] = cnt ++;
                code[i] = rt[code[i]];
        }
}
void show(int p) {
        lld v = hs.memo[p].v;
        decode(v);
        for (int i = 0; i <= m; i ++) cout << code[i] << " ";
}
lld work() {
        hs.init();
        cur = f[0]; nex = f[1];
        memset(f,0,sizeof(f));
        cur[0] = 1; hs[0];
        int ex,ey;
        for (int i = 0; i < n; i ++)
                for (int j = 0; j < m; j ++)
                        if (s[i][j]!='*') ex = i, ey = j;
        for (int i = 0; i < n; i ++) {
                for (int j = 0; j < m; j ++) {
                        for (int st = 0; st < tot; st ++) if (cur[st]) {
                                lld v = hs.memo[st].v;

                                decode(v);
                                if (s[i][j]=='*') {
                                        if (!code[m] && !code[j]) {
                                                nex[st] += cur[st];
                                        }
                                        continue;
                                }

                                if (code[m] && !code[j] && j!=m-1) {
                     //                   cout << "-" << endl;
                                        nex[st] += cur[st];
                                }

                                if (!code[m] && code[j]) {
                     //                   cout << "1" << endl;
                                        nex[st] += cur[st];
                                }

                                if (!code[m] && code[j] && j!=m-1) {
                     //                   cout << "1_" << endl;
                                        code[m] = code[j];
                                        code[j] = 0;
                                        recode();
                                        nex[encode()] += cur[st];
                                }

                                decode(v);
                                if (!code[m] && !code[j] && j!=m-1) {
                     //                   cout << "1-" << endl;
                                        code[m] = 7;
                                        code[j] = 7;
                                        recode();
                                        nex[encode()] += cur[st];
                                }

                                decode(v);
                                if (code[m] && !code[j]) {
                     //                   cout << "-1" << endl;
                                        code[j] = code[m];
                                        code[m] = 0;
                                        recode();
                                        nex[encode()] += cur[st];
                                }

                                decode(v);
                                if (code[m] && code[j]) {
                      //                  cout << "_1" << endl;
                                        bool ok = true;
                                        if (code[m]==code[j]) {
                                                if (i==ex && j==ey) {
                                                        for (int k = j+1; k < m; k ++)
                                                            if (code[k]) ok = false;
                                                } else {
                                                        ok = false;
                                                }
                                        }
                                        if (ok) {
                                                int tmp = code[m];
                                                for (int k = 0; k <= m; k ++)
                                                        if (code[k]==tmp) code[k] = code[j];
                                                code[m] = 0;
                                                code[j] = 0;
                                                recode();
                                                nex[encode()] += cur[st];
                                        }
                                }
                        }
                        swap(cur,nex);
                        for (int k = 0; k < tot; k ++) nex[k] = 0;
                }
        }
        return cur[0];
}
int main() {
        while (cin >> n >> m) {
                s.resize(n);
                for (int i = 0; i < n; i ++) cin >> s[i];
                cout << work() << endl;
        }
        return 0;
}

括号表示：这道题上括号表示果然比最小表示快3倍不止。。虽然一部分是最小表示写搓的原因-0-

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
using namespace std;
typedef __int64 lld;
const int INF = 0x3f3f3f3f;
const int N = 1e6+100;
int tot,n,m,code[15];
lld f[2][N],*cur,*nex;
vector<string> s;
struct Hash {
        struct Node { lld v; int id; Node *next; };
        Node memo[N],*table[N];
        int mod;
        void init() { 
                memset(table,0,sizeof(table));
                mod = 1e6+3;
                tot = 0;
        }
        int operator [] (lld x) {
                int idx = x%mod;
                for (Node *i = table[idx]; i ; i = i->next) 
                        if (i->v==x) return i->id;
                memo[tot] = (Node) {x,tot,table[idx]};
                table[idx] = &memo[tot];
                return tot ++;
        }
}hash;
void decode(lld v) {
        for (int i = 0; i <= m; i ++) code[i] = v>>(i<<1)&3;
}
lld work() {
        cur = f[0]; nex = f[1];
        memset(f,0,sizeof(f));
        cur[0] = 1;
        hash.init();
        hash[0];
        int ex,ey;
        for (int i = 0; i < n; i ++)
                for (int j = 0; j < m; j ++)
                        if (s[i][j]!='*') ex = i, ey = j;
        for (int i = 0; i < n; i ++) {
                for (int j = 0; j < m; j ++) {
                        for (int st = 0; st < tot; st ++) if (cur[st]) {
                                lld v = hash.memo[st].v,nv;
                                decode(v);

                                if (s[i][j]=='*') {
                                        if (!code[m] && !code[j]) 
                                                nex[st] += cur[st];
                                        continue;
                                }

                                if (!code[m] && !code[j] && j!=m-1) {
                                        nv = v^(1<<(j<<1))^(2<<(m<<1));
                                        nex[hash[nv]] += cur[st];
                                }

                                if (!code[m] && code[j]) {
                                        nex[st] += cur[st];
                                        if (j!=m-1) {
                                                nv = v^(code[j]<<(m<<1))^(code[j]<<(j<<1));
                                                nex[hash[nv]] += cur[st];
                                        }
                                }

                                if (code[m] && !code[j]) {
                                        if (j!=m-1)
                                                nex[st] += cur[st];
                                        nv = v^(code[m]<<(j<<1))^(code[m]<<(m<<1));
                                        nex[hash[nv]] += cur[st];
                                }

                                if (code[m] && code[j]) {
                                        if (code[m]==2 && code[j]==1) {
                                                nv = v^(2<<(m<<1))^(1<<(j<<1));
                                                nex[hash[nv]] += cur[st];
                                        } else if (code[m]==1 && code[j]==2) {
                                                if (i==ex && j==ey) {
                                                        nv = v^(1<<(m<<1))^(2<<(j<<1));
                                                        nex[hash[nv]] += cur[st];
                                                }
                                        } else if (code[m]==1 && code[j]==1) {
                                                int k,cnt = 0;
                                                for (k = j+1; k < m; k ++) {
                                                        if (code[k]==2) cnt --;
                                                        else if (code[k]==1) cnt ++;
                                                        if (cnt==-1) break;
                                                }
                                                nv = v^(1<<(m<<1))^(1<<(j<<1))^(2<<(k<<1))^(1<<(k<<1));
                                                nex[hash[nv]] += cur[st];
                                        } else if (code[m]==2 && code[j]==2) {
                                                int k,cnt = 0;
                                                for (k = j-1; k >= 0; k --) {
                                                        if (code[k]==2) cnt --;
                                                        else if (code[k]==1) cnt ++;
                                                        if (cnt==1) break;
                                                }
                                                nv = v^(2<<(m<<1))^(2<<(j<<1))^(1<<(k<<1))^(2<<(k<<1));
                                                nex[hash[nv]] += cur[st];
                                        } else {
                                                cout << "something wrong" << endl;
                                        }
                                }
                        }
                        swap(cur,nex);
                        for (int i = 0; i < tot; i ++) nex[i] = 0;
                }
        }
        return cur[0];
}
int main() {
        while (cin >> n >> m) {
                s.resize(n);
                for (int i = 0; i < n; i ++) cin >> s[i];
                cout << work() << endl;
        }
        return 0;
}