B1567 [JSOI2008]Blue Mary的战役地图 二分答案+hash

一开始以为是dp，后来看了一下标签。。。二分答案？之前也想过，但是没往下想，然后之后的算法就顺理成章，先求出第一个地图的所有子矩阵的hash值，然后求第二个，在上一个地图例二分查找，然后就没了。

算法很好想，也很好写，但是一开始我想的和最长公共子序列差不多的dp却不行（子矩阵是子串啊）。。。总的来说不是什么难题。

lower_bound是大于等于，返回的时候不用减一。

upper_bound是大于。

题干：

Description
Blue Mary最近迷上了玩Starcraft(星际争霸) 的RPG游戏。她正在设法寻找更多的战役地图以进一步提高自己的水平。 由于Blue Mary的技术已经达到了一定的高度,因此，对于用同一种打法能够通过的战役地图，她只需要玩一张，她就能了解这一类战役的打法，然后她就没有兴趣再玩儿这一类地图了。而网上流传的地图有很多都是属于同一种打法，因此Blue Mary需要你写一个程序，来帮助她判断哪些地图是属于同一类的。 具体来说，Blue Mary已经将战役地图编码为n*n的矩阵，矩阵的每个格子里面是一个32位（有符号）正整数。对于两个矩阵，他们的相似程度定义为他们的最大公共正方形矩阵的边长。两个矩阵的相似程度越大，这两张战役地图就越有可能是属于同一类的。
Input
第一行包含一个正整数n。 以下n行，每行包含n个正整数，表示第一张战役地图的代表矩阵。 再以下n行，每行包含n个正整数，表示第二张战役地图的代表矩阵。
Output
仅包含一行。这一行仅有一个正整数，表示这两个矩阵的相似程度。
Sample Input

Sample Output

HINT
样例解释：
子矩阵：

为两个地图的最大公共矩阵

约定：
n<=
Source

代码：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<ctime>
#include<queue>
#include<algorithm>
#include<cstring>
using namespace std;
#define duke(i,a,n) for(int i = a;i <= n;i++)
#define lv(i,a,n) for(int i = a;i >= n;i--)
#define clean(a) memset(a,0,sizeof(a))
const int INF =  << ;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
template <class T>
void read(T &x)
{
    char c;
    bool op = ;
    while(c = getchar(), c < '' || c > '')
        if(c == '-') op = ;
    x = c - '';
    while(c = getchar(), c >= '' && c <= '')
        x = x *  + c - '';
    if(op) x = -x;
}
template <class T>
void write(T x)
{
    if(x < ) putchar('-'), x = -x;
    if(x >= ) write(x / );
    putchar('' + x % );
}
int n,len = ;
ull mp[][],mp2[][],w[];
bool cmp(ull a,ull b)
{
    return a < b;
}
void haxi(int x,int y,int l)
{
    ull tot = ;
    duke(i,x,x + l - )
    {
        duke(j,y,y + l - )
        {
            tot = tot *  + mp[i][j];
        }
    }
    w[++len] = tot;
}
ull haxi2(int x,int y,int l)
{
    ull tot = ;
    duke(i,x,x + l - )
    {
        duke(j,y,y + l - )
        {
            tot = tot *  + mp2[i][j];
        }
    }
    return tot;
}
int main()
{
    read(n);
    duke(i,,n)
    duke(j,,n)
    read(mp[i][j]);
    duke(i,,n)
    duke(j,,n)
    read(mp2[i][j]);
    int l = ,r = n;
    while(l != r)
    {
        clean(w);
        len = ;
        int mid = (l + r) >> ;
        duke(i,,n - mid + )
        {
            duke(j,,n - mid + )
            {
                haxi(i,j,mid);
            }
        }
        sort(w + ,w + len + ,cmp);
        int ok = ;
        duke(i,,n - mid + )
        {
            duke(j,,n - mid + )
            {
                ull p = haxi2(i,j,mid);
                int y = lower_bound(w + ,w + len + ,p) - w;
                if(w[y] == p)
                {
                    ok = ;
                    break;
                }
            }
            if(ok == )
                break;
        }
        if(ok == )
            l = mid + ;
        else
            r = mid;
    }
    clean(w);
    len = ;
    duke(i,,n - l + )
    {
        duke(j,,n - l + )
        {
            haxi(i,j,l);
        }
    }
    sort(w + ,w + len + ,cmp);
    int ok = ;
    duke(i,,n - l + )
    {
        duke(j,,n - l + )
        {
            ull p = haxi2(i,j,l);
            int y = lower_bound(w + ,w + len + ,p) - w;
            if(w[y] == p)
            {
                ok = ;
                break;
            }
        }
        if(ok == )
            break;
    }
    if(ok == )
    write(r);
    else
    write(r - );
    return ;
}
/*
3
1 2 3
4 5 6
7 8 9
5 6 7
8 9 1
2 3 4
*/
/*
5
1 2 3 4 5
5 6 7 8 9
8 9 10 11 12
1 2 3 4 5
5 4 3 2 1
1 2 3 5 7
5 3 1 2 3
1 4 5 6 7
4 5 8 9 10
4 7 1 5 6
*/