Beyond the Void » 位运算 http://www.byvoid.com/blog Tue, 29 Jun 2010 08:44:46 +0000 en hourly 1 http://wordpress.org/?v=3.0 POI 1997 基因串 Genotypes http://www.byvoid.com/blog/poi-1997-gen/ http://www.byvoid.com/blog/poi-1997-gen/#comments Wed, 26 Nov 2008 14:04:55 +0000 BYVoid http://www.byvoid.com/blog/?p=581 这是一个思路新颖的动态规划问题，一看道题的时候看起来像搜索，一时没有想出动态规划。但是只要把思路变一下，要求给定的字串最少由几个S变换而成，每个自串能合成什么。

假设我们已经知道了，给定的串S，从第i位到第j位，能够合成的单个字母的集合，用G[i,j]表示，那么我们可以定义

F[i,j](1<=i,j<=L L为S长度)表示串S从第i位到第j位能够合成的S的最小个数

状态转移方程

F[i,j]=Min
{
F[i,k]+F[k+1,j] | i<=k<=j-1,
1 | 'S' 属于 G[i,j]
}

边界条件

F[i,j]=∞

结果就是 F[1,L]

现在只需求出G[i,j]即可。我们定义H[A,B]为字母A,B能够合成的字母的集合，对于样例
SAB
SBC
SAA
ACA
BCC
CBC
有
H['A','B']={'S'}
H['B','C']={'S','C'}
H['A','A']={'S'}
H['C','A']={'A'}
H['C','C']={'B'}

然后G[i,j]依然可以用动态规划求出。

状态转移方程

G[i,j]=Union{H[A,B] | A 属于 G[i,k] 且 B 属于 G[k+1,j] 且 i<=k<=j-1}

上式表示从G[i,k]和G[k+1,j]两个集合中，我们各取一个元素A，B，代表S[i,k]变换而成的A和S[k+1,j]变换而成的B，将A,B合成G[i,j]的一个元素。

边界条件
G[i,j]=Ø (1<=i,j<=L , i!=j)
G[i,i]={S[i]}

以上的动态规划的方法是我第一次使用的，编程的时候要格外注意细节。关于集合的运算，我们可以用两个32位整型数保存每个字母的状态，用位运算的方法求是否包含每个元素，按位求或就是并集。

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

#include <iostream>
 
using namespace std;
 
class tSet
{
	public:
		unsigned int P;
		tSet():P(0){}
		bool Contain(int k)
		{
			return (P >> (k))&1;
		}
		void Union(tSet &k)
		{
			P |=k.P;
		}
		void Union(int k)
		{
			P |=1 << (k);
		}
};
 
const int Target='S'-'A';
const int MAX_L=101;
const int INF=0x7FFFFFF;
 
int N,M,L,Ans;
 
char S[MAX_L];
tSet H[26][26];
tSet G[MAX_L][MAX_L];
int F[MAX_L][MAX_L];
 
void init()
{
	int i,c,a,b;
	freopen("gen.in","r",stdin);
	freopen("gen.out","w",stdout);
	scanf("%dn",&M);
	for (i=1;i<=M;i++)
	{
		gets(S);
		c=S[0]-'A';
		a=S[1]-'A';
		b=S[2]-'A';
		H[a][b].Union(c);
	}
	scanf("%dn",&N);
}
 
void solve()
{
	int i,j,k,a,b;
	for (i=1;i<=L;i++)
	{
		for (j=1;j<=L;j++)
		{
			G[i][j].P=0;
		}
		G[i][i].Union((int)S[i-1]);
	}
	for (i=L;i>=1;i--)
	{
		for (j=i+1;j<=L;j++)
		{
			for (k=i;k<=j-1;k++)
			{
				for (a=0;a<26;a++)
				{
					for (b=0;b<26;b++)
					{
						if (G[i][k].Contain(a) && G[k+1][j].Contain(b))
						{
							G[i][j].Union(H[a][b]);
						}
					}
				}
			}
		}
	}
 
	for (i=1;i<=L;i++)
	{
		for (j=1;j<=L;j++)
		{
			F[i][j]=INF;
		}
	}
 
	for (i=L;i>=1;i--)
	{
		for (j=i;j<=L;j++)
		{
			if (G[i][j].Contain(Target))
			{
				F[i][j]=1;
			}
			else
			{
				for (k=i;k<=j-1;k++)
				{
					if (F[i][k]+F[k+1][j]<F[i][j])
					{
						F[i][j]=F[i][k]+F[k+1][j];
					}
				}
			}
		}
	}
 
	Ans=F[1][L];
}
 
int main()
{
	init();
	for (int i=1;i<=N;i++)
	{
		gets(S);
		for (L=0;S[L];L++)
		{
			S[L]-='A';
		}
		solve();
		if (Ans==INF)
			printf("NIEn");
		else
			printf("%dn",Ans);
	}
	return 0;
}

基因串

基因串是由一串有限长度的基因所组成的，其中每一个基因都可以用26个英文大写字母中的一个来表示，不同的字母表示不同的基因类型。一个单独的基因可以生长成为一对新的基因，而可能成长的规则是通过一个有限的成长规则集所决定的。每一个成长的规则可以用三个大写英文字母A1A2A3来描述，这个规则的意思是基因A1可以成长为一对基因A2A3。

我们用大写字母S来表示一类被称作超级基因的基因。因为每一个基因串都是由一串超级基因根据给出的规则所成长出来的。

任务：

请写一个程序：

* 从文本文件中读入有限条成长的规则和一些我们想要得到的基因串；
* 对于每个基因串，试判断它是否可以由一个有限长度的超级基因串成长得出。如果可以，那么请给出可成长为该基因串的最短超级基因串的长度；
* 把结果输出到文本文件中。

输入格式：

在文本文件GEN.IN的第一行包括一个整数n，1 <= n <= 10000。以下的n行中每行都包括一个成长的规则，每个规则由三个大写英文字母组成。

在该文件的第n+1行包括一个整数k，1 <= k <= 10000。以下的k行中每行都有一个基因串。每个基因串都是一个长度不超过100的大写字符串。

输出格式：

在文件的第i（应共k行）行中你应该输出入下内容：

一个正整数，表示成长为改基因串所需的最短的超级基因串的长度；

或一个单词NIE（波兰语的“否”），如果说无法由超级基因串成长成为该基因串。

样例：

输入

6
SAB
SBC
SAA
ACA
BCC
CBC
3
ABBCAAABCA
CCC
BA

输出

3
1
NIE

Maybe you like

]]> http://www.byvoid.com/blog/poi-1997-gen/feed/ 0 USACO 3.4.4 Raucous Rockers 破锣摇滚乐队 http://www.byvoid.com/blog/usaco-344-raucous-rockers/ http://www.byvoid.com/blog/usaco-344-raucous-rockers/#comments Sun, 20 Apr 2008 07:22:36 +0000 BYVoid http://www.byvoid.com/blog/?p=131
一道动态规划题，但观察数据规模，穷举就行了。
穷举每首歌是否选取所有的组合可能(2^20种)，算出每种情况所有光盘上一共能存的歌曲数目，保留最大值即可。

对于穷举每首歌是否选取所有的组合可能，我采用了位运算的高效方法

?View Code CPP
limit=(1 << N)-1;
for (i=0;i<=limit;i++)

然后i对应的每种状况计算能装进光盘中的最大的歌曲数目即可。

USER: CmYkRgB CmYkRgB [cmykrgb1]
TASK: rockers
LANG: C++

Compiling…
Compile: OK

Executing…
Test 1: TEST OK [0.000 secs, 2844 KB]
Test 2: TEST OK [0.000 secs, 2840 KB]
Test 3: TEST OK [0.011 secs, 2840 KB]
Test 4: TEST OK [0.000 secs, 2844 KB]
Test 5: TEST OK [0.011 secs, 2844 KB]
Test 6: TEST OK [0.011 secs, 2840 KB]
Test 7: TEST OK [0.410 secs, 2840 KB]
Test 8: TEST OK [0.454 secs, 2840 KB]
Test 9: TEST OK [0.097 secs, 2844 KB]
Test 10: TEST OK [0.000 secs, 2840 KB]
Test 11: TEST OK [0.421 secs, 2844 KB]
Test 12: TEST OK [0.454 secs, 2840 KB]

All tests OK.

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

/*
ID: cmykrgb1
PROG: rockers
LANG: C++
*/
#include <iostream>
#include <fstream>
#define MAX 21
using namespace std;
ifstream fi("rockers.in");
ofstream fo("rockers.out");
long N,T,M,maxr=0;
long len[MAX];
 
void init()
{
	long i;
	fi >> N >> T >> M;
	for (i=1;i<=N;i++)
		fi >> len[i];
}
 
void comser()
{
	unsigned long limit,i;
	long j,k,rec,st;
	bool A;
	long use[MAX];
	limit=(1 << N)-1;
	for (i=0;i<=limit;i++)
	{
		memset(use,0,sizeof(use));
		rec=0;st=1;
		for (j=1;j<=N;j++)
		{
			A=(i & (1 << (j-1))) >> (j-1);
			if (A) for (k=st;k<=M;k++)
					if (use[k]+len[j]<=T)
					{
						use[k]+=len[j];
						rec++;
						st=k;
						break;
					}
		}
		if (rec>maxr) maxr=rec;
	}
}
 
void print()
{
	fo << maxr << endl;
	fi.close();
	fo.close();
}
 
int main()
{
	init();
	comser();
	print();
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/usaco-344-raucous-rockers/feed/ 1 USACO 3.2.5 Magic Squares 魔板 msquare http://www.byvoid.com/blog/usaco-325-magic-squares/ http://www.byvoid.com/blog/usaco-325-magic-squares/#comments Thu, 17 Apr 2008 05:28:26 +0000 BYVoid http://www.byvoid.com/blog/?p=122
这道题类似于八数码难题，基本思想是宽搜，使用Hash判重。如果使用一般的八维数组空间可以达到8^8=16777216，会超过USACO的16MB空间限制。所以我们应该对状态进行散列存储，观察发现每位的数字不能重复，存在空间冗余。我们可以对于每个状态建立一个映射，采用康托展开算法。(参见Nocow)
定义cantor(s)为s串大大小顺序。可样将哈希容量缩减到8!=40320。

另外发现，对于魔板当前状态可以由一个8位的8进制数来表示，即无符号32位长整型 unsigned long 表示。
对于魔板的变换可以转化为对一个数字的位运算。这样可以大大提高程序效率。

程序有些长，但是效率很高。

USER: CmYkRgB CmYkRgB [cmykrgb1]
TASK: msquare
LANG: C++

Compiling…
Compile: OK

Executing…
Test 1: TEST OK [0.011 secs, 3476 KB]
Test 2: TEST OK [0.054 secs, 3444 KB]
Test 3: TEST OK [0.011 secs, 3476 KB]
Test 4: TEST OK [0.011 secs, 3472 KB]
Test 5: TEST OK [0.011 secs, 3480 KB]
Test 6: TEST OK [0.022 secs, 3476 KB]
Test 7: TEST OK [0.022 secs, 3476 KB]
Test 8: TEST OK [0.023 secs, 3484 KB]

All tests OK.

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

/*
ID: cmykrgb1
PROG: msquare
LANG: C++
*/
#include <iostream>
#include <fstream>
#define MAX 40320
using namespace std;
 
class state
{
public:
	state()
	{
		comefrom=0;cur=0;cont=0;
	}
	state *comefrom;
	unsigned long cur;
	short cont;
};
state O;
state S[MAX];
 
class queue
{
private:
	long first,last;
	long list[MAX];
public:
	long size;
 
	queue()
	{
		reset();
	}
 
	void reset()
	{
		first=0;
		size=0;
		last=-1;
	}
 
	void ins(state *comefrom,unsigned long cur,long cont)
	{
		size++;
		last++;
		list[last]=last;
		S[last].comefrom=comefrom;
		S[last].cur=cur;
		S[last].cont=cont;
	}
 
	long del()
	{
		size--;
		return list[first++];
	}
};
 
ifstream fi("msquare.in");
ofstream fo("msquare.out");
bool hash[MAX];
char B[4]={0,'A','B','C'};
 
long fac[8]={1,1,2,6,24,120,720,5040};
unsigned long Finish;
 
unsigned long cantor(unsigned long S)
{
	long x=0,i,p,k,j;
	bool hash[8]={false};
	for (i=8;i>=2;i--)
	{
		k=S>> 3*(i-1);
		S-=k<<3*(i-1);
		hash[k]=true;
		p=k;
		for (j=0;j<=k-1;j++)
			if (hash[j])
				p--;
		x+=fac[i-1]*p;
	}
	return x;
}
 
void init()
{
	long i,t;
	for (i=0;i<8;i++)
	{
		fi>>t;
		t--;
		O.cur*=8;
		O.cur+=t;
	}
	Finish=cantor(O.cur);
	hash[0]=true;
}
 
unsigned long turn(unsigned long S,int f)
{
	long i;
	unsigned long P=0;
	switch (f)
	{
	case 1:
		for (i=1;i<=8;i++)
			P+=(S & (7<< ( (i-1)*3) ) )>> (i-1)*3 << ((8-i)*3);
		return P;
		break;
	case 2:
		P+=(S & 07000)>>3*3;
		P+=(S & 00777)<<3;
		P+=(S & 070000)<<3*3;
		P+=(S & 077700000)>>3;
		return P;
		break;
	case 3:
		P= (S & 070077007);
		P+=(S & 070)<<5*3;
		P+=(S & 0700)>>1*3;
		P+=(S & 0700000)>>3*3;
		P+=(S & 07000000)>>1*3;
		return P;
		break;
	}
}
 
void print(long ed,long f)
{
	string O;
	state *P=&S[ed];
	char OUT[MAX];
	long cnt=0,i;
	while (P->cont)
	{
		cnt++;
		OUT[cnt]=B[P->cont];
		P=P->comefrom;
	}
 
	fo << cnt+1<<endl;
	for (i=cnt;i>=1;i--)
		fo << OUT[i];
	fo << B[f] << endl;
 
	fi.close();
	fo.close();
	exit(0);
}
 
void bfs()
{
	long i=0,j;
	queue Q;
	Q.ins(&O,001234567,0);
	while (Q.size)
	{
		unsigned long p,ct;
		i=Q.del();
		for (j=1;j<=3;j++)
		{
			p=turn(S[i].cur,j);
			ct=cantor(p);
			if (!hash[ct])
			{
				hash[ct]=true;
				if (ct==Finish)
					print(i,j);
				Q.ins(&S[i],p,j);
			}
		}
	}
}
 
int main()
{
	init();
	bfs();
	fo << '0' <<'n'<<'n';
	fi.close();
	fo.close();
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/usaco-325-magic-squares/feed/ 3 USACO 3.1.5 Contact 联系 http://www.byvoid.com/blog/usaco-315-contact/ http://www.byvoid.com/blog/usaco-315-contact/#comments Tue, 15 Apr 2008 13:50:08 +0000 BYVoid http://www.byvoid.com/blog/?p=119
经典的位运算解题，边读入边计算。
设置极限掩码为limit=(1<<(B))-1; //2的B此次方-1
每读入一个二进制数0或1，令unsigned int数字串str=((str<<1)+c) & limit;
然后扫描str，从末尾向前扫描i=(A到B)位，把所得的数字串t最高位添加1，以区别有前导0的串，例如001和01，添加后变为1001和101

?View Code CPP
mask=(1<<i)-1;
mask2=mask+1;
t=(S & mask) | mask2;

用哈希表记录t的频率 hash[t]++;

最后再排序按格式输出即可，一定要小心，我格式错了好几次。

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

/*
ID: cmykrgb1
PROG: contact
LANG: C++
*/
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
	long value,cnt;
} bins;
FILE *fi,*fo;
long A,B,n;
unsigned int limit;
long hash[10000];
long cnt=0;
bins R[10000];
 
void print_bin(unsigned int t)
{
	int tmp[13],cnt=0;
	do{
		tmp[++cnt]=(t & 1)+48;
		t>>=1;
	}while (t);
	for (int i=cnt-1;i>=1;i--) putc(tmp[i],fo);
}
 
void vote(unsigned int S,int cy)
{
	int i;
	unsigned int mask,mask2,t;
	for (i=A;i<=B && i<=cy;i++)
	{
		mask=(1<<(i))-1;mask2=mask+1;
		t=(S & mask) | mask2;
		hash[t]++;
	}
}
 
void count()
{
	char c;	unsigned int str=0,cy=0;
	fi=fopen("contact.in","r");
	fo=fopen("contact.out","w");
	fscanf(fi,"%ld%ld%ldn",&A,&B,&n);
	limit=(1<<(B))-1; //2的B此次方-1
	while ((c=getc(fi))!=EOF)
		if (c!=10 && c!=13)
		{
			cy++;c-=48;
			str=((str<<1)+c) & limit;
			vote(str,cy);
		}
}
 
int cmp ( const void *a , const void *b ) 
{
	bins ta=(*(bins *)a),tb=(*(bins *)b);
	if (ta.cnt>tb.cnt) return -1;
	else if (ta.cnt<tb.cnt) return 1;
	else if (ta.cnt==tb.cnt)
	if (ta.value<tb.value) return -1;
	else return 1;
}
 
void print()
{
	unsigned int lt=(1<<(B+1))-1;
	int i;
	int now=0,pc=0,linecnt=0;
	bool flag,first=true;
	for (i=0;i<=lt;i++)
		if (hash[i])
		{
			cnt++;R[cnt].value=i;
			R[cnt].cnt=hash[i];
		}
	qsort(R+1,cnt,sizeof(bins),cmp);
 
	for (i=1;i<=cnt;i++)
	{
		if (R[i].cnt!=now)
		{
			now=R[i].cnt;
			if (pc==n) break;
			if (!first) fprintf(fo,"n");
			else first=false;
			fprintf(fo,"%ldn",now);
			pc++;linecnt=0;
		}
		else
		{
			linecnt++;
			if (linecnt==6)
			{
				putc('n',fo);linecnt=0;
			}
			elsefprintf(fo," ");
		}
		print_bin(R[i].value);
	}
	putc('n',fo);
	fclose(fi);
	fclose(fo);
}
 
int main()
{
	count();
	print();
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/usaco-315-contact/feed/ 2