bzoj 1151 [CTSC2007]动物园zoo

Posted 2021-01-11 zjxxcn

Description

新建的圆形动物园是亚太地区的骄傲。圆形动物园坐落于太平洋的一个小岛上，包含一大圈围栏，每个围栏里有一

种动物。如下图所示：

你是动物园的公共主管。你要做的是，让每个来动物园的人都尽可能高兴。今天有一群小朋友来动物园参观，你希

望能让他们在动物园度过一段美好的时光。但这并不是一件容易的事——有的动物有一些小朋友喜欢，有的动物有

一些小朋友害怕。如，Alex 喜欢可爱的猴子和考拉，而害怕拥牙齿锋利的狮子。而Polly 会因狮子有美丽的鬃毛

而喜欢它，但害怕有臭味的考拉。你可以选择将一些动物从围栏中移走以使得小朋友不会害怕。但你不能移走所有

的动物，否则小朋友们就没有动物可看了。每个小朋友站在大围栏圈的外面，可以看到连续的 5 个围栏。你得到

了所有小朋友喜欢和害怕的动物信息。当下面两处情况之一发生时，小朋友就会高兴：

至少有一个他害怕的动物被移走

至少有一个他喜欢的动物没被移走

 

例如，考虑下图中的小朋友和动物：

假如你将围栏 4 和 12 的动物移走。Alex 和 Ka-Shu 将很高兴，因为至少有一个他们害怕的动物被移走了。这也

会使 Chaitanya 高兴，因为他喜欢的围栏 6 和8 中的动物都保留了。但是，Polly 和 Hwan 将不高兴，因为他们

看不到任何他们喜欢的动物，而他们害怕的动物都还在。这种安排方式使得三个小朋友高兴。现在，换一种方法，

如果你将围栏 4 和 6 中的动物移走，Alex 和 Polly 将很高兴，因为他们害怕的动物被移走了。Chaitanya 也会

高兴，虽然他喜欢的动物 6被移走了，他仍可以看到围栏 8 里面他喜欢的动物。同样的 Hwan 也会因可以看到自

己喜欢的动物 12 而高兴。唯一不高兴的只有 Ka-Shu。如果你只移走围栏 13 中的动物，Ka-Shu 将高兴，因为有

一个他害怕的动物被移走了，Alex, Polly, Chaitanya 和 Hwan 也会高兴，因为他们都可以看到至少一个他们喜

欢的动物。所以有 5 个小朋友会高兴。这种方法使得了最多的小朋友高兴。

 

 

Input

输入的第一行包含两个整数N, C，用空格分隔。

N是围栏数(10≤N≤10 000)，C是小朋友的个数(1≤C≤50 000)。

围栏按照顺时针的方向编号为1,2,3,…,N。

接下来的C行，每行描述一个小朋友的信息，

以下面的形式给出： E F L X1 X2 … XF Y1 Y2 … YL 

其中： E表示这个小朋友可以看到的第一个围栏的编号(1≤E≤N)，

换句话说，该小朋友可以看到的围栏为E, E+1, E+2, E+3, E+4。

注意，如果编号超过N将继续从1开始算。

如：当N=14, E=13时，这个小朋友可以看到的围栏为13,14,1, 2和3。 

F表示该小朋友害怕的动物数。

L表示该小朋友喜欢的动物数。

围栏X1, X2, …, XF 中包含该小朋友害怕的动物。

围栏Y1, Y2, …, YL 中包含该小朋友喜欢的动物。 

X1, X2, …, XF, Y1, Y2, …, YL是两两不同的整数，

而且所表示的围栏都是该小朋友可以看到的。

小朋友已经按照他们可以看到的第一个围栏的编号从小到大的顺序排好了

(这样最小的E对应的小朋友排在第一个，最大的E对应的小朋友排在最后一个)。

注意可能有多于一个小朋友对应的E是相同的。

Output

仅输出一个数，表示最多可以让多少个小朋友高兴

Sample Input

10 10
1 1 1 3 2
2 1 0 4
3 1 1 5 6
4 1 1 7 6
5 1 0 6
6 1 2 9 8 10
7 1 0 10
8 1 0 8
9 1 1 1 2
10 1 0 2

Sample Output

10

 

思路：枚举前5个的状态考虑环的情况，然后后面做二维状压f[i][j]表示从第i个围栏开始的5个状态是j。

时间复杂度O(2^10*C)，感觉不会超时，但是我的写法居然常数特别大，orz

  1 #include<bits/stdc++.h>
  2 using namespace std; 
  3 #define F(i,a,b) for(int i=(a);i<=(b);i++)
  4 #define D(i,a,b) for(int i=a;i>=b;i--) 
  5 #define ms(i,a)  memset(a,i,sizeof(a)) 
  6 
  7 template <class T> void read(T &x){
  8     x=0; int w=0; char c=getchar(); 
  9     while (c<‘0‘ || c>‘9‘) c=getchar(); 
 10     while (c>=‘0‘ && c<=‘9‘) x=(x<<3)+(x<<1)+(c^48),c=getchar(); 
 11     if(w) x=-x;  
 12 }
 13 
 14 template <class T> void write(T x){
 15     if(x<0) x=-x,putchar(‘-‘); 
 16     if(x>9) write(x/10); 
 17     putchar(x%10+48); 
 18 }
 19 
 20 template <class T> void writeln(T x){
 21     write(x); 
 22     putchar(‘
‘); 
 23 }
 24 template <class T> void inline chkmin(T &x,T y){ x=min(x,y);}
 25 template <class T> void inline chkmax(T &x,T y){ x=max(x,y);}
 26 
 27 int const maxn=50003; 
 28 int const maxc=50003; 
 29 
 30 struct Edge{
 31     int to,nt; 
 32 }E[maxn<<2];  
 33 int cnt,H[maxc],n,c,st[maxc],dp[10003][1<<5],ans,xv[maxn][5],yv[maxn][5],sum[maxn]; 
 34 int e[maxc],f[maxc];   
 35 
 36 void add(int a,int b){
 37     E[cnt]=(Edge){b,H[a]}; H[a]=cnt++; 
 38 }
 39 
 40 void solve(int pre){
 41     F(i,1,n-5) F(j,0,31){
 42         int v=j>>1; 
 43         int ad=0;  
 44         if(dp[i][j]+sum[i+1]>dp[i+1][v])
 45         for(int t=H[i+1];t!=-1;t=E[t].nt){
 46             int K=E[t].to; 
 47             int check1=0,check2=0; 
 48             for(int p=0;p<5;p++)if(xv[K][p]){
 49                 if((1<<p) & v) check1=1;  
 50                 if(check1) break;  
 51             }
 52             if(!check1)
 53             for(int p=0;p<5;p++)if(yv[K][p]){
 54                 if( (1<<p) & ~v) check2=1; 
 55                 if (check2) break;  
 56             }
 57             ad+=check1 ||  check2; 
 58         }
 59         chkmax(dp[i+1][v],dp[i][j]+ad);  
 60         v=(j>>1)+16;  
 61         ad=0;  
 62         if(dp[i][j]+sum[i+1]>dp[i+1][v])  
 63         for(int t=H[i+1];t!=-1;t=E[t].nt){
 64             int K=E[t].to;  
 65             int check1=0,check2=0; 
 66             for(int p=0;p<5;p++)if(xv[K][p]){
 67                 if((1<<p) & v) check1=1;  
 68                 if(check1) break;  
 69             }
 70             if(!check1)
 71             for(int p=0;p<5;p++) if(yv[K][p]) {
 72                 if( (1<<p) & ~v) check2=1; 
 73                 if(check2) break;  
 74             }
 75             ad+=check1 ||  check2; 
 76         }
 77         chkmax(dp[i+1][v],dp[i][j]+ad);  
 78     }
 79     int g=0; 
 80     int ret=0;  
 81     F(j,0,31){
 82         int ad=0;
 83         F(i,n-3,n){
 84             int num=i-n+4; 
 85             int v=(j>>num)+(pre&((1<<num)-1))*(1<<(5-num));  
 86             for(int t=H[i];t!=-1;t=E[t].nt){
 87                 int K=E[t].to;  
 88                 int check1=0,check2=0; 
 89                 for(int p=0;p<5;p++)if(xv[K][p]){
 90                     if((1<<p) & v)  check1=1;
 91                 }
 92                 if(!check1) 
 93                 for(int p=0;p<5;p++)if(yv[K][p]){
 94                     if((1<<p) & ~v) check2=1;  
 95                 }
 96                 ad+=check1 ||  check2;  
 97             } 
 98         }
 99         chkmax(ret,dp[n-4][j] + ad);  
100     }
101     chkmax(ans,ret);  
102 }
103 int main(){
104     scanf("%d%d",&n,&c);  
105     ms(-1,H); 
106     F(i,1,c){
107         scanf("%d",&st[i]); 
108         sum[st[i]]++;  
109         add(st[i],i); 
110         int x,y; 
111         scanf("%d%d",&x,&y);  
112         while (x--){
113             int k; scanf("%d",&k); 
114             if(k<st[i]) k=n+k;
115             xv[i][k-st[i]]=1; 
116         }
117         while (y--){
118             int k; scanf("%d",&k); 
119             if(k<st[i]) k=n+k; 
120             yv[i][k-st[i]]=1;  
121         }
122     }
123     F(i,0,31){
124         ms(0,dp);  
125         for(int t=H[1];t!=-1;t=E[t].nt){
126             int k=E[t].to;    
127             int check1=0; 
128             for(int p=0;p<5;p++)if(xv[k][p]) { 
129                 if ( (1<<p) & i)  check1=1;  
130             }
131             int check2=0; 
132             for(int p=0;p<5;p++)if(yv[k][p]) {
133                 if( (1<<p) & ~i) check2=1;  
134             } 
135             dp[1][i]+=check1 || check2; 
136         }
137         solve(i);  
138     }
139     cout<<ans<<endl; 
140     return 0; 
141 }
142 
143 
144 
145 /* 
146 14 5
147 2 1 2 4 2 6
148 3 1 1 6 4
149 6 1 2 9 6 8
150 8 1 1 9 12
151 12 3 0 12 13 2
152 
153 */