[hdu 6046 hash] 矩陣Hash+鴿巢定理

原創 Xingw-Xiong 2020-02-20 16:44

[hdu 6046 hash] 矩陣Hash+鴿巢定理

分類：Pigeonhole Principle Hash Matrix Hash

1. 題目鏈接

[hdu 6046 hash]

2. 題意描述

給出一個隨機算法，給定一個二維座標，可以得到該點對應的值（0或者1）。可以通過這個隨機算法可以確定一個106∗106 的二維矩陣。
現在給你一個103∗103 的矩陣，要你求出這個矩陣在106∗106 的大矩陣中的位置。（輸出左上角座標）
數據保證小矩陣一定在大矩陣裏面。

3. 解題思路

本題要求在1e6*1e6的矩形內找到一個特定的1e3*1e3的小矩形。 可以選擇每隔K行或K列選出一個長寬皆爲L的小矩形作爲識別矩形，當識別矩形出現在輸入矩形時，再進行完全匹配。根據鴿籠原理，當K+2*L<=1000時，輸入矩形一定覆蓋了至少一個識別矩形。這裏選擇L=7使得可以用一個int表示一個識別矩形。將hash結果視爲隨機的，則識別矩形匹配成功進入完全匹配的次數約爲(106k)2∗(103)2249 ，爲極小值。

題目比較特殊，是通過隨機算法得到的大矩陣，所以分佈會比較均勻。
也就容易想到先識別矩形的一部分。然後一直擴大範圍之類的做法。
感覺主要是很難想到用到鴿籠定理啊，看了題解之後，在紙上畫一畫，好像是這麼個道理。我的大概步驟就是：

  1. 預處理：可以先對輸入的103∗103 的矩陣Hash。然後將其邊長爲L 的子矩形的所有Hash值，以及該子矩陣左下角點的座標存到HashMap中。
  2. 在大矩形中枚舉(106k)2 次小矩形。求出小矩形的Hash值。在Hash表中查詢該Hash值。如果存在就枚舉103∗103 的矩陣是否匹配。

這樣下來，我的複雜度大概是O[(106k)2∗P∗103∗103] ,P 是小矩形匹配的概率。10∗10 的矩陣可以匹配的概率是很小的，因爲數據是隨機的，P=12100 。
不過，不會怎麼會怎麼用int 表示。蠢哭…

4. 實現代碼

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;
typedef long double LB;
typedef unsigned int uint;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<LB, LB> PLB;
typedef vector<int> VI;

const int INF = 0x3f3f3f3f;
const LL INFL = 0x3f3f3f3f3f3f3f3fLL;
const long double PI = acos(-1.0);
const long double eps = 1e-4;
template<typename T> inline void umax(T &a, T b) { a = max(a, b); }
template<typename T> inline void umin(T &a, T b) { a = min(a, b); }
template <typename T> inline bool scan_d (T &ret) {
    char c; int sgn;
    if (c = getchar(), c == EOF) return 0; //EOF
    while (c != '-' && (c < '0' || c > '9') ) if((c = getchar()) == EOF) return 0;
    sgn = (c == '-') ? -1 : 1;
    ret = (c == '-') ? 0 : (c - '0');
    while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
    ret *= sgn;
    return 1;
}
template<typename T, typename ...R> inline bool scan_d (T &ret, R& ...r) { scan_d(ret); scan_d(r...); }
template<typename T> void print(T x) {
    static char s[33], *s1; s1 = s;
    if (!x) *s1++ = '0';
    if (x < 0) putchar('-'), x = -x;
    while(x) *s1++ = (x % 10 + '0'), x /= 10;
    while(s1-- != s) putchar(*s1);
}
inline void print(char ch) { putchar(ch); }
inline void print(const char s[]) { printf("%s", s); }
inline void print(char s[]) { printf("%s", s); }
inline void println() { putchar('\n'); }
template<typename T> inline void println(T f) { print(f); println(); }
template<typename T, typename ...R> void print (T f, R ...r) { print(f); putchar(' '); print (r...); }
template<typename T, typename ...R> void println(T f, R ...r) { print(f); putchar(' '); print (r...); println(); }
template<typename T> T randIntv(T a, T b) { return rand() % (b - a + 1) + a; } /*[a, b]*/
void debug() { cout << endl; }
template<typename T, typename ...R> void debug (T f, R ...r) { cout << "[" << f << "]"; debug (r...); }
inline unsigned sfr(unsigned h, unsigned x) {
    return h >> x;
}
int f(LL i, LL j) {
    LL w = i * 1000000ll + j;
    int h = 0;
    for(int k = 0; k < 5; ++k) {
        h += (int) ((w >> (8 * k)) & 255);
        h += (h << 10);
        h ^= sfr(h, 6);
    }
    h += h << 3;
    h ^= sfr(h, 11);
    h += h << 15;
    return sfr(h, 27) & 1;
}
const int MAXN = 1005;

const int HASH_SIZE = 3000007;
const int MT = 1e6 + 1000;

struct HNode {
    ULL hv; int nxt;
    int x, y;
} hd[HASH_SIZE];
int head[HASH_SIZE], tot;
void HInit() {
    tot = 0;
    memset(head, -1, sizeof(head));
}

bool HQuery(ULL hv, vector<PII>& pt) {
    int u = hv % HASH_SIZE;
    bool ret = false;
    for(int i = head[u]; ~i; i = hd[i].nxt) {
        if(hd[i].hv == hv) {
            pt.push_back(PII(hd[i].x, hd[i].y));
            ret = true;
        }
    }
    return ret;
}

void HInsert(ULL hv, int x, int y) {
    int u = hv % HASH_SIZE;
    hd[tot].hv = hv;
    hd[tot].x = x;
    hd[tot].y = y;
    hd[tot].nxt = head[u];
    head[u] = tot ++;
}
const ULL SEED[2] = {131, 13331};
ULL Hash[MAXN][MAXN], qz[MAXN][2];

ULL getHashV(int x, int y, int nn, int mm) {
    assert(x - nn + 1 >= 0);
    assert(y - mm + 1 >= 0);
    return Hash[x][y] + Hash[x - nn][y - mm] * qz[mm][0] * qz[nn][1]
           - Hash[x - nn][y] * qz[nn][1] - Hash[x][y - mm] * qz[mm][0];
}

int N, M, T, L, K;
char S[MAXN][MAXN];

bool checkOri(int xl, int yl) {
    if(xl < 1 || yl < 1) return false;
    if(N + xl - 1 > MT || M + yl - 1 > MT) return false;
    for(int i = 1; i <= N; ++i) {
        for(int j = 1; j <= M; ++j) {
            if(f(i + xl - 1, j + yl - 1) != S[i][j] - '0') return false;
        }
    }
    return true;
}

ULL getOriHashV(int xl, int yl, int h) {
    ULL hv = 0;
    for(int i = 1; i <= L; ++i) {
        ULL temp = 0;
        for(int j = 1; j <= L; ++j) {
            temp = temp * SEED[0] + f(xl + i - 1, yl + j - 1);
        }
        hv = hv * SEED[1] + temp;
    }
    return hv;
}
int src[2], dst[2];
bool process(int x, int y) {
    int nx = x + L - 1, ny = y + L - 1;
    if(nx > MT || ny > MT) return false;
    ULL oriHv = getOriHashV(x, y, L);
    vector<PII> pt;
    if(HQuery(oriHv, pt) == false) return false;
    int dx, dy;
    for(int i = 0, sz = pt.size(); i < sz; ++i) {
        tie(dx, dy) = pt[i];
        pt[i] = PII(nx - dx + 1, ny - dy + 1);
    }
    sort(pt.begin(), pt.end());
    for(int i = 0, sz = pt.size(); i < sz; ++i) {
        tie(dx, dy) = pt[i];
        if(checkOri(dx, dy)) {
            dst[0] = dx, dst[1] = dy;
            return true;
        }
    }
    return false;
}

int main() {
#ifdef ___LOCAL_WONZY___
//    freopen ("input.txt", "r", stdin);
//    freopen ("ans2.txt", "w+", stdout);
#endif // ___LOCAL_WONZY___
    qz[0][0] = qz[0][1] = 1;
    for(int i = 1; i < MAXN; ++i) {
        qz[i][0] = qz[i - 1][0] * SEED[0];
        qz[i][1] = qz[i - 1][1] * SEED[1];
    }
    int cas = 0;
    N = M = 1000;
    scan_d(T);
//    T = 100;
    while(T --) {
        for(int i = 1; i <= N; ++i) scanf("%s", S[i] + 1);
//        int x = randIntv(90000, 990000), y = randIntv(90000, 990000);
//        src[0] = x, src[1] = y;
//        for(int i = 1; i <= N; ++i) {
//            for(int j = 1; j <= M; ++j) {
//                S[i][j] = f(x + i - 1, y + j - 1) + '0';
//            }
//        }
        for(int i = 0; i <= N; ++i) Hash[i][0] = 0;
        for(int j = 0; j <= M; ++j) Hash[0][j] = 0;
        for(int i = 1; i <= N; ++i) {
            for(int j = 1; j <= M; ++j) {
                Hash[i][j] = Hash[i][j - 1] * SEED[0] + S[i][j] - '0';
            }
        }
        for(int i = 1; i <= N; ++i) {
            for(int j = 1; j <= M; ++j) {
                Hash[i][j] = Hash[i - 1][j] * SEED[1] + Hash[i][j];
            }
        }
        HInit();
        L = 10; K = N - 2 * L;
        for(int i = L; i <= N; ++i) {
            for(int j = L; j <= M; ++j) {
                ULL hv = getHashV(i, j, L, L);
                HInsert(hv, i, j);
            }
        }
        bool suc = false;
        for(int i = 1; i <= MT; i += K) {
            for(int j = 1; j <= MT; j += K) {
                suc |= process(i, j);
                if(suc) break;
            }
            if(suc) break;
        }
        printf("Case #%d :%d %d\n", ++ cas, dst[0], dst[1]);
    }
#ifdef ___LOCAL_WONZY___
    cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC * 1000 << " ms." << endl;
#endif // ___LOCAL_WONZY___
    return 0;
}
Xingw-Xiong
發佈了287 篇原創文章 · 獲贊 347 · 訪問量 45萬+
他的留言板 關注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

[BZOJ 2462 BeiJing2011矩陣模板]矩陣Hash

Xingw-Xiong 2020-02-20 16:44:02

[BZOJ4337 BJOI2015 樹的同構]樹哈希

Xingw-Xiong 2020-02-20 16:44:02

[BZOJ 2462 BeiJing2011矩陣模板]矩陣Hash

Xingw-Xiong 2020-02-20 16:44:02