POJ 3274 Gold Balanced Lineup

Gold Balanced Lineup

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 10516		Accepted: 3145

Description

Farmer John's N cows (1 ≤ N ≤ 100,000) share many similarities. In fact, FJ has been able to narrow down the list of features shared by his cows to a list of only Kdifferent features (1 ≤ K ≤ 30). For example, cows exhibiting feature #1 might have spots, cows exhibiting feature #2 might prefer C to Pascal, and so on.

FJ has even devised a concise way to describe each cow in terms of its "feature ID", a single K-bit integer whose binary representation tells us the set of features exhibited by the cow. As an example, suppose a cow has feature ID = 13. Since 13 written in binary is 1101, this means our cow exhibits features 1, 3, and 4 (reading right to left), but not feature 2. More generally, we find a 1 in the 2^(i-1) place if a cow exhibits feature i.

Always the sensitive fellow, FJ lined up cows 1..N in a long row and noticed that certain ranges of cows are somewhat "balanced" in terms of the features the exhibit. A contiguous range of cows i..j is balanced if each of the K possible features is exhibited by the same number of cows in the range. FJ is curious as to the size of the largest balanced range of cows. See if you can determine it.

Input

Line 1: Two space-separated integers, N and K.  Lines 2..N+1: Line i+1 contains a single K-bit integer specifying the features present in cow i. The least-significant bit of this integer is 1 if the cow exhibits feature #1, and the most-significant bit is 1 if the cow exhibits feature #K.

Output

Line 1: A single integer giving the size of the largest contiguous balanced group of cows.

Sample Input

7 3
7
6
7
2
1
4
2

Sample Output

4

Hint

In the range from cow #3 to cow #6 (of size 4), each feature appears in exactly 2 cows in this range

 

前几天自学哈希时，在别人博客里几乎原模原样地copy了这个题。

话说前面对问题的转化确实很厉害

首先用一个数组sum[i][j]记录从第1到第i头cow属性j的出现次数。

所以题目要求等价为:求满足sum[i][0]-sum[j][0]=sum[i][1]-sum[j][1]=.....=sum[i][k-1]-sum[j][k-1] (j<i)中最大的i-j 

将上式变换可得到

　　sum[i][1]-sum[i][0] = sum[j][1]-sum[j][0]

　　sum[i][2]-sum[i][0] = sum[j][2]-sum[j][0]

　　......

　　sum[i][k-1]-sum[i][0] = sum[j][k-1]-sum[j][0] 

令C[i][y]=sum[i][y]-sum[i][0] (0<y<k)

初始条件C[0][0~k-1]=0 （这个初始条件很重要，后面会分析到）

所以只需求满足C[i][]==C[j][] 中最大的i-j，其中0<=j<i<=n。C[i][]==C[j][] 即二维数组C[][]第i行与第j行对应列的值相等。

那么原题就转化为求C数组中 相等且相隔最远的两行的距离i-j。

 

但是最大数据有10W个，即10W行，因此不能直接枚举找最大距离，必须用Hash查找相同行，找到相同行再比较最大距离。

注意C数组的值可能为负数，因此生成key值时要注意保证key为非负数。

 

为什么初始条件很重要呢，因为可能会出现下面这种情况

　　C[i][0]==C[i][1]==C[i][2]==……==C[i][k]==0

等价于：

　　sum[i][0]==sum[i][1]==sum[i][2]==……==sum[i][k]

这意味着从第一行到第i行时，所有feature出现的次数是相同的

可是只要第一次出现C数组全0行即可，而不像其他情况一样需要有两行相同的。

因此这里的做法是将C[0][] 初始化为一个全0行（也就是代码中的Hash(0)），这样出现全0行也就是这一行与C[0][]行相等。这样将这种情况的判定方式也转化成和其他情况一样的了。

 

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>

using namespace std;

const long mod=99991;

typedef class node
{
    public:
        long pi;
        class node *next;
        node()
        {
            next=NULL;
        }
} HashTable;

HashTable *cow[mod];

int feature[100001][30];
int sum[100001][30];
int c[100001][30];
int k;
long n,maxlen;

bool cmp(long ai,long bi)
{
    for(int j=0;j<k;j++)
        if(c[ai][j]!=c[bi][j])
            return false;
    return true;
}

void Hash(long ci)
{
    long key=0;
    for(int j=1;j<k;j++)
        key+=c[ci][j]*j;
    key=((long)fabs((double)key))%mod;
    if(!cow[key])
    {
        HashTable *temp=new HashTable;
        temp->pi=ci;
        cow[key]=temp;
    }
    else
    {
        if(cmp(cow[key]->pi,ci))
        {
            long dist=ci-(cow[key]->pi);
            if(dist>maxlen)
                maxlen=dist;
            return;
        }
        else
        {
            HashTable *p=cow[key];
            while(p->next)
            {
                if(cmp(p->next->pi,ci))
                {
                    long dist=ci-(p->next->pi);
                    if(dist>maxlen)
                        maxlen=dist;
                    return;
                }
                p=p->next;
            }
            HashTable *temp=new HashTable;
            temp->pi=ci;
            p->next=temp;
        }
    }
}

int main()
{
    long temp;

    while(scanf("%ld %d",&n,&k)==2)
    {
        for(int i=0;i<k;i++)
        {
            c[0][i]=0;
            sum[0][i]=0;
        }
        memset(cow,0,sizeof(cow));
        Hash(0);
        maxlen=0;

        for(int i=1;i<=n;i++)
        {
            scanf("%ld",&temp);
            for(int j=0;j<k;j++)
            {
                feature[i][j]=temp&1;
                temp>>=1;
                sum[i][j]=sum[i-1][j]+feature[i][j];
                c[i][j]=sum[i][j]-sum[i][0];
            }
            Hash(i);
        }

        printf("%ld
",maxlen);
    }

    return 0;
}