POJ 3274/洛谷 1360:Gold Balanced Lineup 黄金阵容平衡

题目描述

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.

神牛小R在许多方面都有着很强的能力，具体的说，他总共有m种能力，并将这些能力编号为1到m。他的能力是一天一天地提升的，每天都会有一些能力得到一次提升，R对每天的能力提升都用一个数字表示，称之为能力提升数字，比如数字13，转化为二进制为1101，并且从右往左看，表示他的编号为1,3,4的能力分别得到了一次提升。小R把每天表示能力提升的数字的记了下来，如果在连续的一段时间内，小R的每项能力都提升了相同的次数，小R就会称这段时间为一个均衡时期，比如在连续5天内，小R的每种能力都提升了4次，那么这就是一个长度为5的均衡时期。

于是，问题来了，给出 小R n天的能力提升数字，请求出均衡时期的最大长度。

【数据规模】对于50%的数据，N <= 1000。

输入输出格式

输入格式：
第一行有两个整数n,m，表示有n天，m种能力。接下来有n行，每行有一个整数，分别表示第1到n天的能力提升数字。能力提升数字转化为二进制后，从右到左的每一位表示对应的能力是否在当天得到了一次提升。

n<=100000, m<=30

输出格式：
输出只有一个整数，表示长度最大的均衡时期的长度。

输入输出样例

输入样例#1：
7 3
7
6
7
2
1
4
2
输出样例#1：
4

说明

【样例解释】

每天被提升的能力种类分别为：

第一天:1，2，3

第二天:2，3

第三天:1，2，3

第四天：2

第五天：1

第六天：3

第七天：2

第三天到第六天为长度最长的均衡时期

因为 这四天 每种能力分别提升了 2次

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath> 
#include<vector> 
#define mod 100003 
#define inf 1<<29
using namespace std;
int n,k,tz[mod][40],ms[mod][40],sum[mod][40],key[mod],ans; 
vector<int>list[mod];
void init()
{
    for(int i=0;i<mod;++i) list[i].clear();
    list[0].push_back(0);
    for(int i=1;i<=n;++i){
        for(int j=0;j<k;++j){
            sum[i][j]=sum[i-1][j]+tz[i][j];
            ms[i][j]=sum[i][j]-sum[i][0]; 
            key[i]+=ms[i][j]; 
        }
        key[i]=abs(key[i])%mod; 
    }
}
void search(int knum,int id)
{
    int len=list[knum].size();
    for(int j=0;j<len;++j){
        int f=1;
        for(int l=0;l<k;++l)
            if(ms[list[knum][j]][l]!=ms[id][l]){
                f=0;
                break; 
            } 
        if(f){
            ans=max(ans,id-list[knum][j]);
            return; 
        }
    }
    list[knum].push_back(id); 
}
int main()
{
    int t; 
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;++i){
        scanf("%d",&t); 
        for(int j=0;j<k;++j){
            tz[i][j]=t%2;
            t/=2; 
        }
    }
    init();
    for(int i=1;i<=n;++i) search(key[i],i);
    printf("%d",ans); 
    return 0;
}

　　

　　芒果君：一上来就粘代码2333333求一段最长的“平衡区间”，就是在这段区间内各种特征的数量和相等。首先十进制转二进制，然后求前缀和sum，这是为了方便作差判断——区间开头两特征的差sum[start][x]-sum[start][0]==结尾两特征的差(sum[start][x]+y)-(sum[start][0]+y)==sum[end][x]-sum[end][0]，0<=x<k,y是每个特征增加的数量。那么，如果对于每个x都满足以上等式，就可以判断区间成立。为了减小时间复杂度，我们考虑一个哈希操作，minus[i][x]=sum[i][x]-sum[i][0],将∑minus[i][x] %mod表示为key[i]，它就是我们哈希的“钥匙”。当然，只是求和+mod还不够，我们需要进一步比较每一位是否都满足，更新答案为编号的差，这样我们就有了一个能AC的思路。

　　此外还有好多细节（如果你觉得太烦可以不看23333333）。

　　①22行 将key[i]变为正数再模——不然如果它还是负数就会数组越界。

　　②search找答案，如果判出相等直接return而不用放入队列——我们设a,b,c三个minus，id a<id b<id c，找到a==b更新答案，如果a==c，那么id c-id a>id b-id a，显然b没有必要放入队列。

　　③把list[0]放入0——给一组数据1 3 0，应该输出1而不是0。

 

------------------------------------悲剧的分割线--------------------------------------------

 

我第一次知道map里还可以塞vector O_o 虽然慢了点但这道题还是绰绰有余。

这道题最简单的方法是：用vector维护当前数值的情况，求出每种能力与能力1的相对值，强行塞进map里。因为如果两个时刻的相对值对应相等，说明他们在中间这段时间的增减了同一个值。

 

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<vector>
#include<map>
using namespace std;
typedef long long ll;
map<vector<int>,int>mp;
int n,m,x,ans;
int main()
{
    scanf("%d%d",&n,&m);
    vector<int>now(m);
    mp[now]=0;
    for(int i=1;i<=n;++i){
        scanf("%d",&x);
        for(int j=0;j<m;++j) now[j]+=(x&(1<<j)?1:0)-(x&1);
        if(mp.count(now)) ans=max(ans,i-mp[now]);
        else mp[now]=i;
    }
    printf("%d\n",ans);
    return 0;
}