POJ 3274 -- Gold Balanced Lineup

Gold Balanced Lineup

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 16467		Accepted: 4664

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 K different 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

Source

USACO 2007 March Gold

 

题意：

解题思路：

牛的特征数组为f[N][K]，sum[i][j]为第i头牛到第0头牛特征j出现的次数，

对于区间第i头牛到第j头牛，特征出现的次数都相同，对应如下等式

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

我们要求满足上述等式的max(j - i)

 

经过变换，有：

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] - sum[i][0] = sum[j][K] - sum[j][0]

求满足上述等式组的max(j - i)

所以我们令c[i][j] = sum[i][j] - sum[i][0]，上述等式组就变成了：

c[i][1] = c[j][1]

c[i][2] = c[j][2]

...

c[i][K] = c[j][K]

即为c[i][] = c[j][]，求满足数组c[][]的第i行和第j行对应相等的max(j - i)

 

我们只要将特征数组经过上述转化，转化为求满足数组c[][]的第i行和第j行对应相等的max(j - i)

相应的使用hash表，先找到相同的两行，在寻找max(j - i)

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int f[100001][31];//记录牛的特征
int sum[100001][31];
int c[100001][31];
int ans;
int n,k;

const int mod = 100000;

class HashTable{
public:
    int pi;//用来存储数组c的行下标
    HashTable *next;
    HashTable()
    {
        next = 0;
    }
};

HashTable *Hash[mod];

///计算数组c第i行的key值
int computeKey(int i)
{
    int key = 0;
    for(int j=1;j<=k;j++)
    {
        key += c[i][j] * j;
    }
    key = abs(key)%mod;//由于c[][]有正有负，因此key值可能为负
    return key;
}

bool compare(int i,int j)
{
    for(int m=1;m<=k;m++)
    {
        if(c[i][m] != c[j][m])
            return false;
    }
    return true;
}

void Insert(int i)
{
    int key = computeKey(i);
    if(!Hash[key])//没有发生冲突
    {
        HashTable *temp = new HashTable;
        temp->pi = i;
        Hash[key] = temp;
    }
    else{//发生冲突
        HashTable *temp = Hash[key];
        ///c数组的两行相等,计算j-i的值，如果比当前值ans大，就更新ans
        if(compare(temp->pi,i))
        {
            if((i - temp->pi) > ans)
                ans = i-temp->pi;
            ///i一定大于temp->pi
            ///如果又有一行j等于行temp->pi，那么j-temp->pi
            ///一定小于j - i，所以不需要存i
            return;
        }else{
            while(temp->next)
            {
                temp = temp->next;
                if(compare(temp->pi,i))
                {
                    if((i - temp->pi) > ans)
                        ans = i - temp->pi;
                    return;
                }
            }

            ///发生地址冲突，而且没有与第i行相同的行
            temp->next = new HashTable;
            temp->next->pi = i;
        }
    }
    return;
}

int main()
{

    while(cin>>n>>k)
    {
        memset(Hash,0,sizeof(Hash));

        for(int p=1;p<=k;p++)
        {
            c[0][p]=0; //第0只牛的特征默认为全0
            sum[0][p]=0;
        }
        Insert(0);  //把第0只牛先放入哈希表
        memset(f,0,sizeof(f));
        ///输入特征数组feature[][]
        for(int i=1;i<=n;i++)
        {
            int j = 1;
            int feature = 0;
            cin>>feature;
            while(feature)
            {
                f[i][j++] = feature%2;
                feature = feature/2;
            }
        }
        ///计算sum[][]
        for(int i=1;i<=k;i++)
            sum[1][i] = f[1][i];
        for(int i=2;i<=n;i++)
        {
            for(int j=1;j<=k;j++)
                sum[i][j] =sum[i-1][j]+f[i][j];
        }
        ///计算c[][]
        for(int i=0;i<=n;i++)
            c[i][1] = 0;
        for(int j=2;j<=k;j++)//列
        {
            for(int i=1;i<=n;i++)
                c[i][j] = sum[i][j] - sum[i][1];
        }
        ///将c的所有行存入hash表
        ans = 0;
        for(int i=1;i<=n;i++)
            Insert(i);

        cout<<ans<<endl;
    }
    return 0;
}

测试样例：
7 3
7
6
7
2
1
4
2
 
7 3
7 7 7 7 7 7 7
 
4 4
1
2
4
8
 
4 4
8
1
2
4
 
5 4
3
1
2
4
8
 
1 5
3
 
1 2
3
 
1 3
7
 

结果：
4
7
4
4
4
0
1
1