Beyond the Void » HAOI http://www.byvoid.com/blog Tue, 29 Jun 2010 08:44:46 +0000 en hourly 1 http://wordpress.org/?v=3.0 HAOI2009 即将到来 http://www.byvoid.com/blog/haoi2009-coming/ http://www.byvoid.com/blog/haoi2009-coming/#comments Sat, 25 Apr 2009 08:46:40 +0000 BYVoid http://www.byvoid.com/blog/?p=1278 明年将是省选的日子，转眼又是一年。与上次不同，这次省选过后，我的OI生涯就只剩下区区3个月了（也可能会立即彻底结束）。

这一年过来，我的水平没有达到我期望的高度，总结一下原因，关键在于这几点：

  1. 浮躁的学习态度，对于各种算法浅尝辄止，尤其表现在高一初次学习的时候；
  2. 不合理的时间安排，对文化课和竞赛的学习不能有机调和，总是顾此失彼；
  3. 过于功利化地看待OI，认为OI是一条通往理想大学的捷径，忽略了全面发展；
  4. 总是被一点小小的失败困扰，为一些小小的成绩骄傲，心浮气躁。

冲击NOI和文化课的努力学习是存在着某种冲突的，至少在我的能力范围之内是如此。我已经清楚地认识到了这一点，该如何选择？高翔在OI前途一片大好的时候，突然选择了放弃冲击NOI，要去好好准备保送生考试了，尽管还有半年。我非常佩服他激流勇退的精神，只是常人罕见的胸怀才能接受的。

在这次省选之前，我还在犹豫，我想明天过后结果就会出来了。我要准备好接受现实。我想，我应该彻底抛弃心理负担。毕竟我有很多机会，省选不成，还有夏令营；NOI不成，还有NOIP的保送；保送不成，还有高考；高考不成，还可以考虑出国……总之，天无绝人之路。

不可改变的是时光荏苒，可以改变的是我的心态。我究竟能不能走通NOI这条路，还看我自己。从现在开始，我要改变我自己。

赐予我力量，去改变我所能改变的；赐予我勇气，去接受我不能改变的；并赐予我智慧，去分辨这两者。

Maybe you like

]]> http://www.byvoid.com/blog/haoi2009-coming/feed/ 8 HAOI 2007 修筑绿化带 http://www.byvoid.com/blog/haoi-2007-parterre/ http://www.byvoid.com/blog/haoi-2007-parterre/#comments Mon, 20 Apr 2009 02:42:01 +0000 BYVoid http://www.byvoid.com/blog/?p=1266 首先求出每个A*B的矩阵的数值和，以及每个C*D的矩阵的数值和，用递推的方法可以达到O(N*M)。
接下来，求出每个(A-2)*(B-2)范围内最小的C*D的矩阵（因为花坛不能建在绿化带边缘），可以用单调队列的方法递推，时间复杂度为O(N*M)。最后对于每个A*B的局限，求出其范围内最小的花坛，时间复杂度为O(N*M)，总的时间复杂度就是O(N*M)。

这道题本身不难，关键在仔细处理好递推的边界。

?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

/* 
 * Problem: HAOI2007 parterre
 * Author: Guo Jiabao
 * Time: 2009.4.20 10:32
 * State: Solved
 * Memo: 动态规划 单调队列 矩阵压缩
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=1001;
using namespace std;
struct MonoQueue
{
	struct MQElement
	{
		int id,value;
	}Q[MAXN];
	int head,tail;
	void clear(){head=0;tail=-1;}
	void ins(int value,int id)
	{
		while(tail>=head && value<Q[tail].value) tail--;
		Q[++tail].value=value;
		Q[tail].id=id;
	}
	int getmin(int id)
	{
		while (Q[head].id<id) head++;
		return Q[head].value;
	}
}MQ;
struct Matrix
{
	int N,M;
	int X[MAXN][MAXN];
}Green,Flower,FM;
int N,M,A,B,C,D,EN,EM,Ans=0;
int X[MAXN][MAXN],Y[MAXN][MAXN];
void init()
{
	int i,j;
	freopen("parterre.in","r",stdin);
	freopen("parterre.out","w",stdout);
	scanf("%d%d%d%d%d%d",&N,&M,&A,&B,&C,&D);
	for (i=1;i<=N;i++)
		for (j=1;j<=M;j++)
			scanf("%d",&X[i][j]);
}
void solve()
{
	int i,j;
	Green.N=N+1-A; Green.M=M+1-B;
	Flower.N=N+1-C; Flower.M=M+1-D;
	EN=A-2-C+1; EM=B-2-D+1;
	FM.N=Flower.N+1-EN; FM.M=Flower.M+1-EM;
	for (j=1;j<=M;j++)
	{
		Y[1][j]=0;
		for (i=1;i<=A;i++)
			Y[1][j]+=X[i][j];
		for (i=2;i+A-1<=N;i++)
			Y[i][j]=Y[i-1][j]-X[i-1][j]+X[i+A-1][j];
	}
 
	for (i=1;i<=Green.N;i++)
	{
		Green.X[i][1]=0;
		for (j=1;j<=B;j++)
			Green.X[i][1]+=Y[i][j];
		for (j=2;j<=Green.M;j++)
			Green.X[i][j]=Green.X[i][j-1]-Y[i][j-1]+Y[i][j+B-1];
	}
	for (j=1;j<=M;j++)
	{
		Y[1][j]=0;
		for (i=1;i<=C;i++)
			Y[1][j]+=X[i][j];
		for (i=2;i+C-1<=N;i++)
			Y[i][j]=Y[i-1][j]-X[i-1][j]+X[i+C-1][j];
	}
 
	for (i=1;i<=Flower.N;i++)
	{
		Flower.X[i][1]=0;
		for (j=1;j<=D;j++)
			Flower.X[i][1]+=Y[i][j];
		for (j=2;j<=Flower.M;j++)
			Flower.X[i][j]=Flower.X[i][j-1]-Y[i][j-1]+Y[i][j+D-1];
	}
	for (j=1;j<=Flower.M;j++)
	{
		MQ.clear();
		for (i=1;i<=EN-1;i++)
			MQ.ins(Flower.X[i][j],i);
		for (i=1;i<=FM.N;i++)
		{
			MQ.ins(Flower.X[i+EN-1][j],i+EN-1);
			Y[i][j]=MQ.getmin(i);
		}
	}
	for (i=1;i<=FM.N;i++)
	{
		MQ.clear();
		for (j=1;j<=EM-1;j++)
			MQ.ins(Y[i][j],j);
		for (j=1;j<=FM.M;j++)
		{
			MQ.ins(Y[i][j+EM-1],j+EM-1);
			FM.X[i][j]=MQ.getmin(j);
		}
	}
	for (i=1;i<=Green.N;i++)
	{
		for (j=1;j<=Green.M;j++)
		{
			int R=Green.X[i][j];
			R-=FM.X[i+1][j+1];
			if (R>Ans)
				Ans=R;
		}
	}
}
int main()
{
	init();
	solve();
	printf("%dn",Ans);
	return 0;
}

http://www.ruvtex.cn/cogs/problem/pdetail.php?pid=24

修筑绿化带

【问题描述】

为了增添公园的景致，现在需要在公园中修筑一个花坛，同时在画坛四周修建一片绿化带，让花坛被绿化带围起来。
如果把公园看成一个M*N的矩形，那么花坛可以看成一个C*D的矩形，绿化带和花坛一起可以看成一个A*B的矩形。
如果将花园中的每一块土地的“肥沃度”定义为该块土地上每一个小块肥沃度之和，那么，
绿化带的肥沃度=A*B块的肥沃度-C*D块的肥沃度
为了使得绿化带的生长得旺盛，我们希望绿化带的肥沃度最大。

【输入】:

第一行有6个正整数M,N,A,B,C,D
接下来一个M*N的数字矩阵，其中矩阵的第i行j列元素为一个整数Xij,表示该花园的第i行第j列的土地“肥沃度”。

【输出】:

一个正整数，表示绿化带的最大肥沃程度。

【输入输出样例】
parterre.in
4 5 4 4 2 2
20 19 18 17 16
15 14 13 12 11
10 9 8 7 6
5 4 3 2 1

parterre.out
132

【数据范围】

30%的数据，1<=M,N<=50
100%的数据，1<=M,N<=1000,1<=A<=M,1<=B<=N,1<=C<=A-2,1<=D<=B-2，1<=“肥沃度”<=100

Maybe you like

]]> http://www.byvoid.com/blog/haoi-2007-parterre/feed/ 0 HAOI 2008 玩具取名 http://www.byvoid.com/blog/haoi-2008-name/ http://www.byvoid.com/blog/haoi-2008-name/#comments Mon, 20 Apr 2009 01:00:13 +0000 BYVoid http://www.byvoid.com/blog/?p=1263 这是一个动态规划可行性判定问题。

设玩具名字的字符串为A，状态 F[i,j,k] 表示A中，从第i位到第j位，是否可以变换成字符k。

状态转移方程

F[i,j,k] = Or{F[i,l,k1] And F[l+1,j,k2] | i<=l<=j-1 且字符[k1k2]可以变换成k }

边界条件

F[i,i,A[i]]=true

目标结果

F[1,N,k]

?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

/* 
 * Problem: HAOI2008 name
 * Author: Guo Jiabao
 * Time: 2009.4.20 8:53
 * State: Solved
 * Memo: 动态规划 可行性判定
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXL=201,MAXR=17;
const char Charset[5]="WING";
using namespace std;
int N,R[4],Rule[4][MAXR][2],A[MAXL];
bool F[MAXL][MAXL][4],Turn[4][4][4],noans=true;
inline int c2i(char c)
{
	if (c=='W') return 0;
	if (c=='I') return 1;
	if (c=='N') return 2;
	return 3;
}
void init()
{
	int i,j,a,b;
	char C[MAXL],c;
	freopen("name.in","r",stdin);
	freopen("name.out","w",stdout);
	memset(F,0,sizeof(F));
	memset(Turn,0,sizeof(Turn));
	for (i=0;i<4;i++)
		scanf("%d",&R[i]);
	for (i=0;i<4;i++)
	{
		for (j=1;j<=R[i];j++)
		{
			do c=getchar(); while (c==10||c==13);ungetc(c,stdin);
			c=getchar();a=c2i(c);
			c=getchar();b=c2i(c);
			Turn[a][b][i]=true;
		}
	}
	scanf("%s",C);i=1;
	for (char *p=C;*p;p++,i++)
		A[i]=c2i(*p);
	N=i-1;
}
void dynamic()
{
	int i,j,k,k1,k2,l;
	for (i=1;i<=N;i++)
		F[i][i][A[i]]=true;
	for (i=N;i>=1;i--)
		for (j=1;j<=N;j++)
			for (l=i;l<=j-1;l++)
				for (k=0;k<4;k++)
					for (k1=0;k1<4;k1++)
						for (k2=0;k2<4;k2++)
							F[i][j][k] |= Turn[k1][k2][k] && F[i][l][k1] && F[l+1][j][k2];
}
void solve()
{
	dynamic();
	for (int i=0;i<4;i++)
	{
		if (F[1][N][i])
		{
			printf("%c",Charset[i]);
			noans=false;
		}
	}
	if (noans)
		printf("The name is wrong!");
	printf("n");
}
int main()
{
	init();
	solve();
	return 0;
}

http://www.ruvtex.cn/cogs/problem/pdetail.php?pid=317

玩具取名

[题目描述]

某人有一套玩具，并想法给玩具命名。首先他选择WING四个字母中的任意一个字母作为玩具的基本名字。然后他会根据自己的喜好，将名字中任意一个字母用“WING”中任意两个字母代替，使得自己的名字能够扩充得很长。

现在，他想请你猜猜某一个很长的名字，最初可能是由哪几个字母变形过来的。

[输入]

  • 第一行四个整数W、I、N、G。表示每一个字母能由几种两个字母所替代。
  • 接下来W行，每行两个字母,表示W可以用这两个字母替代。
  • 接下来I行，每行两个字母,表示I可以用这两个字母替代。
  • 接下来N行，每行两个字母,表示N可以用这两个字母替代。
  • 接下来G行，每行两个字母,表示G可以用这两个字母替代。
  • 最后一行一个长度不超过Len的字符串。表示这个玩具的名字。

[输出]

  • 一行字符串，该名字可能由哪些字母变形而得到。（按照WING的顺序输出）
  • 如果给的名字不能由任何一个字母变形而得到则输出“The name is wrong!”

[样例]

Input

1 1 1 1
II
WW
WW
IG
IIII

Output

IN

[样例解释]

  • W可以变成II所以IIII可以缩成WW
  • IN均能变成WW所以WW又可以缩成I或者N
  • 所以最终答案应该按照“WING”的顺序输出IN

[数据范围]

  • 30%数据满足Len<=20，W、I、N、G<=6
  • 100%数据满足Len<=200，W、I、N、G<=16

Maybe you like

]]> http://www.byvoid.com/blog/haoi-2008-name/feed/ 3 HAOI 2008 硬币购物 http://www.byvoid.com/blog/haoi-2008-coin/ http://www.byvoid.com/blog/haoi-2008-coin/#comments Wed, 15 Apr 2009 14:08:44 +0000 BYVoid http://www.byvoid.com/blog/?p=1241 原来背包问题还有这种解法，动态规划+容斥原理。由于有tot次询问，如果对每次询问单独都做一次多重背包问题，会超时。有一种一次预处理，每次询问只有O(1)的神奇解法：容斥原理。

设F[i]为不考虑每种硬币的数量限制的情况下，得到面值i的方案数。则状态转移方程为

F[i]=Sum{F[i-C[k]] | i-C[k]>=0 且 k=1..4}

为避免方案重复，要以k为阶段递推，边界条件为F[0]=1，这样预处理的时间复杂度就是O(S)。

接下来对于每次询问，奇妙的解法如下：根据容斥原理，答案为 得到面值S的超过限制的方案数 – 第1种硬币超过限制的方案数 – 第2种硬币超过限制的方案数 – 第3种硬币超过限制的方案数 – 第4种硬币超过限制的方案数 + 第1,2种硬币同时超过限制的方案数 + 第1,3种硬币同时超过限制的方案数 + …… + 第1,2,3,4种硬币全部同时超过限制的方案数。

当第1种硬币超过限制时，只要要用到D[1]+1枚硬币，剩余的硬币可以任意分配，所以方案数为 F[ S - (D[1]+1)*C[1] ]，当且仅当(S – (D[1]+1)*C[1])>=0，否则方案数为0。其余情况类似，每次询问只用问16次，所以询问的时间复杂度为O(1)。

?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

/* 
 * Problem: HAOI2008 coin
 * Author: Guo Jiabao
 * Time: 2009.4.15 21:54
 * State: Solved
 * Memo: 动态规划 容斥原理
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=100001;
using namespace std;
int D[5],C[5],T,S;
long long F[MAXN],Ans;
void init()
{
	freopen("coin.in","r",stdin);
	freopen("coin.out","w",stdout);
	scanf("%d%d%d%d%d",&C[1],&C[2],&C[3],&C[4],&T);
}
inline long long Fn(int a)
{
	return a>=0?F[a]:0;
}
void printint64(long long a)
{
	int m=100000000;
	if (a<=m)
		printf("%dn",a);
	else
	{
		printf("%d",Ans/m);
		printf("%08dn",Ans%m);
	}
}
void solve()
{
	int i,j;
	F[0]=1;
	for (j=1;j<=4;j++)
		for (i=1;i<MAXN;i++)
			if (i-C[j]>=0)
				F[i] += F[i-C[j]];
	for (i=1;i<=T;i++)
	{
		scanf("%d%d%d%d%d",&D[1],&D[2],&D[3],&D[4],&S);
		Ans =Fn( S );
		Ans-=Fn( S - (D[1]+1)*C[1] );
		Ans-=Fn( S - (D[2]+1)*C[2] );
		Ans-=Fn( S - (D[3]+1)*C[3] );
		Ans-=Fn( S - (D[4]+1)*C[4] );
		Ans+=Fn( S - (D[1]+1)*C[1] - (D[2]+1)*C[2] );
		Ans+=Fn( S - (D[1]+1)*C[1] - (D[3]+1)*C[3] );
		Ans+=Fn( S - (D[1]+1)*C[1] - (D[4]+1)*C[4] );
		Ans+=Fn( S - (D[2]+1)*C[2] - (D[3]+1)*C[3] );
		Ans+=Fn( S - (D[2]+1)*C[2] - (D[4]+1)*C[4] );
		Ans+=Fn( S - (D[3]+1)*C[3] - (D[4]+1)*C[4] );
		Ans-=Fn( S - (D[1]+1)*C[1] - (D[2]+1)*C[2] - (D[3]+1)*C[3] );
		Ans-=Fn( S - (D[1]+1)*C[1] - (D[2]+1)*C[2] - (D[4]+1)*C[4] );
		Ans-=Fn( S - (D[1]+1)*C[1] - (D[3]+1)*C[3] - (D[4]+1)*C[4] );
		Ans-=Fn( S - (D[2]+1)*C[2] - (D[3]+1)*C[3] - (D[4]+1)*C[4] );
		Ans+=Fn( S - (D[1]+1)*C[1] - (D[2]+1)*C[2] - (D[3]+1)*C[3] - (D[4]+1)*C[4] );
		printint64(Ans);
	}
}
int main()
{
	init();
	solve();
	return 0;
}

http://www.ruvtex.cn/cogs/problem/pdetail.php?pid=302

硬币购物

【问题描述】

一共有 4 种硬币,面值分别为 c1,c2,c3,c4 。阿Q带着一些硬币去商店买东西，他带了d1枚第一种硬币,d2枚第二种硬币,d3枚第三种硬币,d4枚第四种硬币,若想买一个价值为s的东西,问阿Q有多少种付coins的方法。

比如 c={1,2,5,10},d={3,2,3,1},s=10,一共有4种方法:
10=1+1+1+2+5
10=1+2+2+5
10=5+5
10=10

注意,阿Q可能会去很多次商店,每次带的硬币数量和要买的东西价值可能不一样,你需要对每次都求出方法总数.

【数据输入】

输入文件的第一行是5个整数, c1,c2,c3,c4,tot 分别表示4种硬币的面值和阿Q去商店的次数,下面 tot 行 ,每行5个非负整数,d1,d2,d3,d4,s

【数据输出】

输出有tot行,表示第i次付coins的方法总数,保证答案在int64/long long范围内

【输入样例】
1 2 5 10 2
3 2 3 1 10
1000 2 2 2 900

【输出样例】
4
27

【数据范围】

（1）100%的数据,d1,d2,d3,d4,s<=1,00,000

（2）30%的数据,tot<=50

（3）100%的数据,tot<=1000

Maybe you like

]]> http://www.byvoid.com/blog/haoi-2008-coin/feed/ 5