POJ 1358 Housing Complexes（二分匹配）

int n,m,h,w,K,f[N][N][26];


struct node
{
    char s[N][N];
    int a[26],flag;


    void get()
    {
        int i;
        FOR1(i,n) RD(s[i]+1);
    }


    void init()
    {
        clr(a,0); flag=0; clr(f,0);
        int i,j,k,t,cnt;
        FOR1(i,n) FOR1(j,m)
        {
            FOR0(k,26)
            {
                f[i][j][k]=f[i-1][j][k]+f[i][j-1][k]-f[i-1][j-1][k];
            }
            if(s[i][j]!=‘0‘) f[i][j][s[i][j]-‘A‘]++;
            if(i>=h&&j>=w)
            {
                cnt=0;
                FOR0(k,26) if(f[i][j][k]-f[i-h][j][k]-f[i][j-w][k]+f[i-h][j-w][k]) cnt++,t=k;
                if(!cnt)
                {
                    flag=1;
                    return;
                }
                else if(cnt==1) a[t]=1;
            }
        }
    }
};

node a[N];

int g[N][N],visit[N],match[N];

int DFS(int u)
{
    int i,v;
    FOR1(i,K) if(!visit[i]&&g[u][i])
    {
        visit[i]=1;
        if(match[i]==-1||DFS(match[i]))
        {
            match[i]=u;
            return 1;
        }
    }
    return 0;
}


int main()
{
    rush()
    {
        RD(K,n,m); RD(h,w);
        int i,j;
        FOR1(i,K) a[i].get(),a[i].init();
        int ans=0;
        clr(g,0);
        FOR1(i,K)
        {
            if(a[i].flag) ans++;
            else
            {
                FOR0(j,26) if(a[i].a[j]) g[j][i]=1;
            }
        }
        clr(match,-1);
        FOR0(i,26)
        {
            clr(visit,0);
            if(DFS(i)) ans++;
        }
        PR(ans);
    }
    return 0;
}