Beyond the Void » 1999 http://www.byvoid.com/blog Tue, 29 Jun 2010 08:44:46 +0000 en hourly 1 http://wordpress.org/?v=3.0 NOI 1999 解题报告 http://www.byvoid.com/blog/noi-1999-solution/ http://www.byvoid.com/blog/noi-1999-solution/#comments Sat, 28 Feb 2009 05:13:54 +0000 BYVoid http://www.byvoid.com/blog/?p=896 NOI1999的6道题分别是[钉子和小球][棋盘分割][生日蛋糕][最优连通子集][01串][内存分配]。六道题个题难易差别不太大，没有送分题，也没有特别困难的题。

[钉子和小球]是概率递推问题，需要处理分数。[棋盘分割]是一个动态规划问题，但是很容易想成搜索。[生日蛋糕]是经典的搜索+剪枝，强力剪枝需要对题目足够透彻地分析，还需要一定的数学推导。[最优连通子集]是一个树形动态规划问题，题目描述全部以各种定义给出，需要耐心读题，仔细分析。[01串]的解决需要构造差分约束系统，然后利用最短路径算法求解，其数学模型有一定隐蔽性。[内存分配]是一道模拟题，但其细节却十分复杂，容易遗漏各种情况，需要缜密的思维和良好的编程能力。

做1999年的题我花了4天时间，还需继续努力。

[钉子和小球]

这道题算是个递推问题吧。我们可以知道小球落到钉子上以后，或向左右各有1/2的概率继续下落，根据条件概率的计算公式，设落到该位置的概率为F[i,j]，则有

F[i,j] = Sum
{
	F[i-1,j]*1/2, 		(如果(i-1,j)有钉子)
	F[i-1,j-1]*1/2, 	(如果(i-1,j-1)有钉子)
	F[i-2,j-1],		(如果(i-1,j-1)没有钉子)
}

有了上述公式，可以很容易地求出F[N+1,M+1]的值，注意题意没有说清第M个是哪个，但是从样例看来是(N+1,M+1)出的概率。

还有一个问题，题上要求输出一个既约分数，所以我们在计算F[i,j]时要按分数计算规则，加法要通分，算完要约分。注意要使用64位长整 型(long long)，因为分母可能很大，为了防止溢出，通分要通分到分母的最小公倍数，其中lcm(a,b)=a/gcd(a,b)*b，lcm是最小公倍 数，gcd是最大公约数，防止溢出要先除。

?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

/* 
 * Problem: NOI1999 ball
 * Author: Guo Jiabao
 * Time: 2009.2.23
 * State: Solved
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=52;
using namespace std;
template <typename T> class fraction
{
	public:
	T den,num;
	fraction():den(1),num(0){}
	T gcd(T a,T b)
	{
		T c;
		while(b)
		{
			c=b;
			b=a % b;
			a=c;
		}
		return a;
	}
	void common(fraction *A)
	{
		T comt=den/gcd(den,A->den)*A->den;
		A->num*=comt/A->den;
		num*=comt/den;
		A->den=den=comt;
	}
	void reduce()
	{
		T g=gcd(num,den);
		num/=g;
		den/=g;
		if (num==0)
			den=1;
	}
	void plus(fraction A)
	{
		common(&A);
		num+=A.num;
		reduce();
	}
	fraction devide()
	{
		fraction A=*this;
		A.den*=2;
		A.reduce();
		return A;
	}
};
fraction<long long> F[MAXN][MAXN];
bool nail[MAXN][MAXN];
int N,M;
void init()
{
	int i,j;
	char c;
	freopen("ball.in","r",stdin);
	freopen("ball.out","w",stdout);
	scanf("%d%d",&N,&M);
	for (i=1;i<=N;i++)
	{
		do c=getchar(); while (c==10 || c==13);
		ungetc(c,stdin);
		for (j=1;j<=i;j++)
		{
			do c=getchar(); while(c!='*' && c!='.' && c!=10 && c!=13);
			if (c=='*')
				nail[i][j]=true;
			else if (c=='.')
				nail[i][j]=false;
			else
				break;
		}
	}
}
void dynamic()
{
	int i,j;
	F[1][1].num=1;
	for (i=1;i<=N;i++)
	{
		for (j=1;j<=i;j++)
		{
			if (nail[i][j])
			{
				F[i+1][j].plus(F[i][j].devide());
				F[i+1][j+1].plus(F[i][j].devide());
			}
			else
				F[i+2][j+1].plus(F[i][j]);
		}
	}
	printf("%lld/%lldn",F[N+1][M+1].num,F[N+1][M+1].den);
}
int main()
{
	init();
	dynamic();
	return 0;
}

[棋盘分割]

貌似为搜索题，其实可以动态规划。首先平均值是一个常数，因为已经给定了所有的格子中的数，和总共的块数，所以可以首先算出平均值。

状态设定

  • F[i,x1,y1,x2,y2]为在(x1,y1)-(x2,y2)的矩阵内，分成i块的最小的(每块的值-平均值)^2。

状态转移方程

F[i,x1,y1,x2,y2]=Min
{
	F[1,x1,y1,k,y2] + F[i-1,k+1,y1,x2,y2]; (x1<=k<=x2-1) //左右切割
	F[1,x1,y1,x2,k] + F[i-1,x1,k+1,x2,y2]; (y1<=k<=y2-1) //上下切割
}

目标结果

  • Ans = sqrt(F[N,1,1,H,W] / N)

初始条件

  • F[1,x1,y1,x2,y2]为(x1,y1)-(x2,y2)的矩阵中所有数的和。
?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

/* 
 * Problem: NOI1999 division
 * Author: Guo Jiabao
 * Time: 2009.2.24 14:01
 * State: Solved
 * Memo: 动态规划
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=16,MAXL=9;
const double INF=1e20;
using namespace std;
double F[MAXN][MAXL][MAXL][MAXL][MAXL],Ans,avg;
double V[MAXL][MAXL];
int N,H,W;
void init()
{
	int i,j;
	freopen("division.in","r",stdin);
	freopen("division.out","w",stdout);
	H=W=8;
	scanf("%d",&N);
	for (i=1;i<=H;i++)
		for (j=1;j<=W;j++)
		{
			scanf("%lf",&V[i][j]);
			avg+=V[i][j];
		}
	avg/=N;
}
void dynamic()
{
	int i,j,x1,y1,x2,y2,k,p,q;
	for (x1=1;x1<=H;x1++)
		for (y1=1;y1<=W;y1++)
			for (x2=1;x2<=H;x2++)
				for (y2=1;y2<=W;y2++)
				{
					F[1][x1][y1][x2][y2]=0;
					for (i=x1;i<=x2;i++)
						for (j=y1;j<=y2;j++)
							F[1][x1][y1][x2][y2] += V[i][j];
					F[1][x1][y1][x2][y2]= (F[1][x1][y1][x2][y2] -avg)*(F[1][x1][y1][x2][y2] -avg);
				}
	for (i=2;i<=N;i++)
		for (x1=1;x1<=H;x1++)
			for (y1=1;y1<=W;y1++)
				for (x2=1;x2<=H;x2++)
					for (y2=1;y2<=W;y2++)
					{
						F[i][x1][y1][x2][y2]=INF;
						for (p=1;p<=1;p++)
						{
							q=i-p;
							for (k=x1;k<x2;k++)
								if (F[p][x1][y1][k][y2] + F[q][k+1][y1][x2][y2] < F[i][x1][y1][x2][y2])
									F[i][x1][y1][x2][y2] = F[p][x1][y1][k][y2] + F[q][k+1][y1][x2][y2];
							for (k=y1;k<y2;k++)
								if (F[p][x1][y1][x2][k] + F[q][x1][k+1][x2][y2] < F[i][x1][y1][x2][y2])
									F[i][x1][y1][x2][y2] = F[p][x1][y1][x2][k] + F[q][x1][k+1][x2][y2];
						}
					}
	Ans=sqrt(F[N][1][1][H][W] / N);
}
int main()
{
	init();
	dynamic();
	printf("%.3lfn",Ans);
	return 0;
}

[生日蛋糕]

搜索，显然暴力是会超时的，优化的技巧很重要。按照从底到顶以此搜索每层的半径和高度。 注，由于π是多余的，下文在所有计算中均省略了π。

剪枝1

  • 当还有p层没有搜索，最少需要的体积是V’=∑(i^3)(1<=i<=p)，即以上p层全是半径为1高为1。如果当前剩余的体积是V，小于最少需要的体积V’，则不可能完成搜索，剪枝。

剪枝2

  • 与剪枝1类似，当还有p层没有搜索，设当前顶层的半径是R，高是H，最多需要的体积是V’=∑((R-i)^2*(H-i))(1& lt;=i<=p)，即以上p层的半径和高都以最小的公差递减。如果当前剩余的体积是V，大于最多需要的体积V’，则一定会有剩余，剪枝。

剪枝3

  • 考虑满足当前剩余体积V，所构成的其余层最小的面积S’，若当前的面积是S，已知最优解是MinS，如果S+S’>Mins，继续 搜索没有意义，剪枝。关键在于如何求出S’。根据推理，已经知道S’=3 * V ^ (2/3) – (R[k]-1)*(R[k]-1)，R[k]为当前层的半径，下面是推理过程。

假设只有一层，体积为V=R^2*H，表面积S=R^2+2*R*H，可以推导出S的最小值，过程如下：

	S  = R^2 + 2*R*H
	   = V/H + 2*V/R
	   = V * ( 1/H + 1/R + 1/R )
	由均值不等式
	S >= V * 3 * (1/(H*R^2))^(1/3)
	   = 3 * V * (1/V)^(1/3)
	   = 3 * V ^ (2/3)
	当 H=R 时，等号成立，S最小值=3 * V ^ (2/3)

上述为只有一层的情况，推广到多层，还是一层是面积最小的，证明如下：

若体积为V蛋糕已有k层(k>=1)，设第k层半径为R[k]，高为H[k]，体积为V[k]。 若从顶层蛋糕截取高为ΔH的部分，其体积为ΔV，把它重塑成第k+1层，半径为R[k+1]，高为H[k+1]。 ΔV = R[k+1]^2 * H[k+1] = R[k]^2 * ΔH (1) 设重塑后蛋糕总表面积的增量为ΔS，则有

	ΔS = 2 * R[k+1] * H[k+1] - 2 * R[k] * ΔH
	    = 2 * ΔV / R[k+1] + 2 * ΔV / R[k]
	    = 2 * ΔV * (1 / R[k+1] - 1 / R[k])
	因为 R[k+1] < R[k]，所以 1 / R[k+1] > 1 / R[k]，
	所以ΔS>0，即表面积增大。

由上述证明我们可以得出对于给定的体积V，构成最小表面积的蛋糕一定为一层，而且表面积最小值为3 * V ^ (2/3)。但是在剪枝3中，上层的蛋糕是不用计算表面积的，所以应减去上面一层最大可能的表面积，即S’=3 * V ^ (2/3) – (R[k]-1)*(R[k]-1)，R[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

/* 
 * Problem: NOI1999 cake
 * Author: Guo Jiabao
 * Time: 2009.2.24 21:27
 * State: Solved
 * Memo: 不等式剪枝搜索
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXM=21,INF=0x7FFFFFFF;
using namespace std;
int V,M,Ans=INF;
int R[MAXM],H[MAXM],prefix[MAXM];
void init()
{
	int i;
	freopen("cake.in","r",stdin);
	freopen("cake.out","w",stdout);
	scanf("%d%d",&V,&M);
	for (i=1;i<=M;i++)
		prefix[i]=prefix[i-1]+i*i*i;
	R[0]=H[0]=sqrt((double)V)- M*(M-1)/2 +1;
}
inline double least(double V)
{
	return 3*pow(V,2.0/3.0);
}
inline int last(int R,int H,int k)
{
	int i,p=0;
	for (i=1;i<=k;i++)
		p+=(R-i)*(R-i)*(H-i);
	return p;
}
void dfs(int k,int rV,int cS)
{
	int nV,nS,pS=cS;
	double mS;
	for (R[k]=R[k-1]-1;R[k]>=1;R[k]--)
	{
		if (k==1)
			pS=cS+R[k]*R[k];
		for (H[k]=1;H[k]<H[k-1] && R[k]*R[k]*H[k]<=rV;H[k]++)
		{
			nS=pS+2*R[k]*H[k];
			nV=rV-R[k]*R[k]*H[k];
			if (nV<prefix[M-k])
				break;
			if (nV>last(R[k],H[k],M-k))
				continue;
			mS=least(nV)-(R[k]-1)*(R[k]-1);
			if (nS+mS>Ans)
				continue;
			if (k+1<=M)
				dfs(k+1,nV,nS);
			else if (nS<Ans)
				Ans=nS;
		}
	}
}
int main()
{
	init();
	dfs(1,V,0);
	printf("%dn",Ans);
	return 0;
}

[最优连通子集]

把每个点抽象成图中的顶点，相邻的点连接一条无向边，每个顶点都有其权值。从题中定义4可以看出，图中每两点之间有且只有一条路径，所以这是一棵树。而最大连通子集，就是树中权值之和最大的部分，如此可以动态规划。

状态设定

  • F[i]为以顶点i为根的子树的最大权值之和
  • C[i]为顶点i的权值

状态转移方程

  • F[i] = C[i] + Σ{ F[j] | j为i的子节点，且F[j]>0 }

目标状态

  • F[root] root为根节点

由于该树根不固定，枚举每个点为根，保留最大值。时间复杂度为O(N^2)。

?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

/* 
 * Problem: NOI1999 subset
 * Author: Guo Jiabao
 * Time: 2009.2.27 13:38
 * State: Solved
 * Memo: 树形动态规划
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=1001,INF=0x7FFFFFFF;
using namespace std;
struct point{int x,y;}P[MAXN];
struct edge{edge *next;int t;};
struct vertex{edge *f,*l;int c,s;}V[MAXN];
int N,EC=-1,Ans;
edge ES[MAXN*2];
inline void addedge(int a,int b)
{
	if (V[a].l)
		V[a].l=V[a].l->next=&ES[++EC];
	else
		V[a].f=V[a].l=&ES[++EC];
	ES[EC].t=b;
}
inline int ABS(int a) {return a>0?a:-a;}
void init()
{
	int i,j;
	freopen("subset.in","r",stdin);
	freopen("subset.out","w",stdout);
	scanf("%d",&N);
	for (i=1;i<=N;i++)
		scanf("%d%d%d",&P[i].x,&P[i].y,&V[i].c);
	for (i=1;i<N;i++)
		for (j=i+1;j<=N;j++)
			if (ABS(P[i].x-P[j].x) + ABS(P[i].y-P[j].y)==1)
			{
				addedge(i,j);
				addedge(j,i);
			}
}
void compute(int u,int f)
{
	V[u].s=V[u].c;
	for (edge *k=V[u].f;k;k=k->next)
	{
		int v=k->t;
		if (v!=f)
		{
			compute(v,u);
			if (V[v].s>0)
				V[u].s+=V[v].s;
		}
	}
}
void solve()
{
	int i,j;
	for (i=1;i<=N;i++)
	{
		compute(i,0);
		if (V[i].s>Ans)
			Ans=V[i].s;
	}
}
int main()
{
	init();
	solve();
	printf("%dn",Ans);
	return 0;
}

[01串]

解决这道题可以构造差分约束系统。为了方便表述，我们定义C[i]为串的前i位之和，显然有S[i] = C[i] – C[i-1]。

根据C的意义，我们可以很容易得出约束条件 0 <= C[i] – C[i-1] <= 1 ①。

当i>=L1时，从S[i-L1+1]至S[i]，长度为L1的子串，其中1的个数为C[i] – C[i-L1]。根据题中条件，应满足 A[1] <= C[i] – C[i-L1] <= B[1] ②。同样的，当i>=L0，从S[i-L0+1]至S[i]，长度为L0的子串，其中0的个数为L0 – (C[i] – C[i-L1])，应满足 A[0] <= L0 – (C[i] – C[i-L1]) <= A[1]③。

由上述①②③3个不等式，可以得出

  • C[i] – C[i-1] <= 1 (1<=i<=N)
  • C[i-1] – C[i] <= 0 (1<=i<=N)
  • C[i-L[1]] – C[i] <= -A[1] (i-L[1]>=0)
  • C[i] – C[i-L[1]] <= B[1] (i-L[1]>=0)
  • C[i] – C[i-L[0]] <= L[0]-A[0] (i-L[0]>=0)
  • C[i-L[0]] – C[i] <= B[0]-L[0] (i-L[0]>=0)

根据以上构造差分约束系统，求出C的一组可行解即可。具体要用到SPFA算法求最短路，如果出现负权圈，则说明无解。

?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

/* 
 * Problem: NOI1999 sequence
 * Author: Guo Jiabao
 * Time: 2009.2.27 20:45
 * State: Solved
 * Memo: 差分约束系统 SPFA判断负权圈
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=1001,MAXP=MAXN*10,INF=0x7FFFFFF;
using namespace std;
struct edge
{
	edge *next;
	int t,c;
}ES[MAXP];
struct vertex
{
	edge *f,*l;
	int sp;
}V[MAXN];
struct qlist
{
	qlist *next;
	int v;
};
int N,A[2],B[2],L[2],EC=-1,Q_Size;
bool Q_In[MAXN];
int RelaxCount[MAXN];
qlist *qf,*ql;
void Q_Insert_Tail(int v)
{
	if (Q_Size)
		ql=ql->next=new qlist;
	else
		qf=ql=new qlist;
	ql->next=0;
	ql->v=v;
	Q_Size++;
	Q_In[v]=true;
}
int Q_Pop()
{
	int r=qf->v;
	Q_In[r]=false;
	Q_Size--;
	qlist *t=qf;
	qf=qf->next;
	delete t;
	return r;
}
void init()
{
	freopen("sequence.in","r",stdin);
	freopen("sequence.out","w",stdout);
	scanf("%d%d%d%d%d%d%d",&N,&A[0],&B[0],&L[0],&A[1],&B[1],&L[1]);
}
inline void addedge(int a,int b,int c)
{
	if (V[a].l)
		V[a].l=V[a].l->next=&ES[++EC];
	else
		V[a].f=V[a].l=&ES[++EC];
	ES[EC].t=b; ES[EC].c=c;
}
void construct()
{
	int i;
	for (i=1;i<=N;i++)
	{
		addedge(0,i,N);
		if (i >= L[0])
		{
			addedge(i-L[0],i,L[0]-A[0]);
			addedge(i,i-L[0],B[0]-L[0]);
		}
		if (i >= L[1])
		{
			addedge(i,i-L[1],-A[1]);
			addedge(i-L[1],i, B[1]);
		}
		if (i < N)
		{
			addedge(i+1,i,0);
			addedge(i,i+1,1);
		}
	}
}
bool spfa()
{
	int u,v,c;
	for (u=1;u<=N;u++)
		V[u].sp=INF;
	V[0].sp=0;
	Q_Insert_Tail(0);
	while (Q_Size)
	{
		u=Q_Pop();
		for (edge *k=V[u].f;k;k=k->next)
		{
			v=k->t; c=k->c;
			if (V[u].sp + c < V[v].sp)
			{
				RelaxCount[v]++;
				if (RelaxCount[v]>=N)
					return false;
				V[v].sp = V[u].sp + c;
				if (!Q_In[v])
					Q_Insert_Tail(v);
			}
		}
	}
	return true;
}
void decode()
{
	int i,M=INF;
	for (i=1;i<=N;i++)
		if (V[i].sp<M)
			M=V[i].sp;
	for (i=1;i<=N;i++)
		V[i].sp-=M-1;
	for (i=1;i<=N;i++)
		printf("%d",V[i].sp-V[i-1].sp);
}
int main()
{
	init();
	construct();
	if (spfa())
		decode();
	else 
		printf("-1n");
	return 0;
}

[内存分配]

这道题看似容易，却有着很容易忽略的致命的细节问题！在写这道题时，由于没有看清数据范围，我首先写了基于线段树的方法，但是对于10^9，空间是不足的，于是改用链表。

建立一个进程链表，每个单元表示一个内存区段。在申请空间时，遍历链表，寻找两个相邻区段之间的空闲部分长度不小于所需要的空间的位置。如 果不能找到，则此时无法将该进程放入，否则就在该位置插入一个内存区段。为了加快查找速度，我们可以在插入时把连续的内存区段合并为一块。

当删除一个区段时，在链表中查找到包含待删除的区段的位置，在两端可以直接修改，否则将该块裂开为两块。

为了能够快速删除已经结束的进程，还需要建立一个堆，维护进程的结束时间。对于每个请求，在处理之前，要先把该进程开始时间之前的已经结束 的进程删除。每次删除的同时，还要将处理等待队列。注意，每次一定要把所有结束时间相同的进程一起删除后，才能尝试将等待队列中的首元素加入。之后，在尝 试将新的进程加入内存，如果没有空间，就加入等待队列。在加入进程到内存中时，计算它的结束时间，然后加入堆中。在处理完成所有新进程后，还要把等待队列 和内存中剩余的进程处理完。

根据上述过程模拟，全部进程都运行完毕的时刻和被放入过等待队列的进程总数是很容易统计出的。还是细节决定成败。

?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
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227

/* 
 * Problem: NOI1999 memory
 * Author: Guo Jiabao
 * Time: 2009.2.26 13:52
 * State: Solved
 * Memo: 堆 + 链表
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXP=10001,MAX=1000000001;
using namespace std;
struct proc
{
	int starttime,runtime,endtime,size,a,b;
}P[MAXP];
struct blk
{
	blk *next;
	int a,b;
}BS[MAXP];
int N,Total,temporary,Heapsize,Qcnt,Etime;
int Queue[MAXP],QH,QT,BC,Heap[MAXP],R[MAXP];
blk *blk_first,*blk_last;
bool fst;
inline blk *blk_new()
{
	return &BS[BC++];
}
void init()
{
	freopen("memory.in","r",stdin);
	freopen("memory.out","w",stdout);
	scanf("%d",&Total);
	for(;;)
	{
		N++;
		scanf("%d%d%d",&P[N].starttime,&P[N].size,&P[N].runtime);
		if (P[N].starttime == 0 && P[N].size==0 && P[N].runtime==0)
		{
			N--;
			break;
		}
	}
	P[Heap[0]=0].endtime=-1;
	blk_first=blk_new();
	blk_last=blk_new();
	blk_first->a=blk_first->b=-1;
	blk_last->next=0;
	blk_last->a=blk_last->b=Total;
	blk *p,*q;
	p=blk_first;
	q=blk_new();
	q->next=blk_last;
	p->next=q;
	q->b=(q->a=0)-1;
}
void Heap_insert(int p)
{
	int i,f;
	for (i=++Heapsize;P[p].endtime<P[Heap[f=i/2]].endtime;i=f)
		Heap[i]=Heap[f];
	Heap[i]=p;
}
void Heap_remove()
{
	int i,c,p=Heap[Heapsize];
	for (i=1;(c=i*2)<=Heapsize;i=c)
	{
		if (c+1<=Heapsize && P[Heap[c+1]].endtime<P[Heap[c]].endtime)
			c++;
		if (P[Heap[c]].endtime<P[p].endtime)
			Heap[i]=Heap[c];
		else
			break;
	}
	Heap[i]=p;
	Heapsize--;
}
inline blk* blk_find(int size)
{
	blk *p=blk_first;
	while (p->next)
	{
		if (p->next->a-1-p->b>=size)
			return p;
		p=p->next;
	}
	return 0;
}
inline void blk_insert(blk *p,int size)
{
	p->b+=size;
	if (p->b+1==p->next->a)
	{
		p->b=p->next->b;
		p->next=p->next->next;
	}
}
void blk_remove(int a,int b)
{
	blk *p=blk_first,*q,*r;
	int size=b-a+1;
	while (p->next)
	{
		q=p->next;
		if (a>=q->a && b<=q->b)
		{
			if (a==q->a && b==q->b)
			{
				if (p!=blk_first)
					p->next=q->next;
				else
					q->b=-1;
			}
			else if (a==q->a)
			{
				if (p!=blk_first)
					q->a+=size;
				else
				{
					r=blk_new();
					r->next=p->next; p->next=r;
					r->a=0; r->b=-1;
					q->a=b+1;
				}
			}
			else if (b==q->b)
				q->b-=size;
			else
			{
				r=blk_new();
				r->next=q->next; q->next=r;
				r->a=b+1; r->b=q->b;
				q->b=a-1;
			}
			return;
		}
		p=q;
	}
}
void join(int q,int T,blk *p)
{
	P[q].a=p->b+1;
	P[q].b=P[q].a+P[q].size-1;
	blk_insert(p,P[q].size);
	P[q].endtime=T+P[q].runtime-1;
	Heap_insert(q);
}
void process_wait(int T) //处理队列中元素，以T+1为开始时间
{
	while (QH<=QT)
	{
		int q=Queue[QH];
		blk *p=blk_find(P[q].size);
		if (p)
			join(Queue[QH++],T+1,p);
		else
			break;
	}
}
void freeonce(int T)
{
	int CR=0,q,i;
	while (Heapsize && P[q=Heap[1]].endtime==T)
	{
		R[++CR]=q;
		Heap_remove();
		if (P[q].endtime > Etime)
			Etime=P[q].endtime;
	}
	for (i=1;i<=CR;i++)
	{
		q=R[i];
		blk_remove(P[q].a,P[q].b);
	}
}
void freespace(int T)
{
	int t,q;
	while (Heapsize) //释放内存
	{
		q=Heap[1];
		t=P[q].endtime;
		if (t<T)
		{
			freeonce(t);
			process_wait(t); //处理等待队列
		}
		else
			break;
	}
}
void process()
{
	int T,i,t;
	QT=-1;QH=0;
	for (i=1;i<=N;i++)
	{
		T=P[i].starttime;
		fst=false;
		freespace(T);
		blk *p=blk_find(P[i].size);
		if (p) //处理新申请
			join(i,T,p);
		else
		{
			Queue[++QT]=i;
			Qcnt++;
		}
	}
	while (Heapsize) //处理剩余队列
	{
		int q=Heap[1];
		t=P[q].endtime;
		freespace(t+1);
	}
}
int main()
{
	init();
	process();
	printf("%dn%dn",Etime+1,Qcnt);
	return 0;
}

钉子和小球

有一个三角形木板,竖直立放，上面钉着n(n+1)/2颗钉子，还有(n+1)个格子（当n=5时如图1）。每颗钉子和周围的钉子的距离都等于d，每个格子的宽度也都等于d，且除了最左端和最右端的格子外每个格子都正对着最下面一排钉子的间隙。

让一个直径略小于d的小球中心正对着最上面的钉子在板上自由滚落，小球每碰到一个钉子都可能落向左边或右边（概率各1/2），且球的中心还会正对着下一颗将要碰上的钉子。例如图2就是小球一条可能的路径。

我们知道小球落在第i个格子中的概率pi= Image:Ball1.gif ，其中i为格子的编号，从左至右依次为0,1,…,n。

现在的问题是计算拔掉某些钉子后，小球落在编号为m的格子中的概率pm。假定最下面一排钉子不会被拔掉。例如图3是某些钉子被拔掉后小球一条可能的路径。

Image:Ball2.gif

输入

第1行为整数n（2<=n<=50）和m（0<=m<=n）。以下n行依次为木板上从上至下n行钉子的信息，每行中‘*’表示钉子还在，‘.’表示钉子被拔去，注意在这n行中空格符可能出现在任何位置。

输出

仅一行，是一个既约分数(0写成0/1)，为小球落在编号为m的格子中的概pm。既约分数的定义：A/B是既约分数，当且仅当A、B为正整数且A和B没有大于1的公因子。

样例输入

5 2
    *
   * .
  * * *
 * . * *
* * * * *

样例输出

7/16

棋盘分割

将一个８×８的棋盘进行如下分割：将原棋盘割下一块矩形棋盘并使剩下部分也是矩形，再将剩下的部分继续如此分割，这样割了(n-1)次后，连同最后剩下的矩形棋盘共有n块矩形棋盘。(每次切割都只能沿着棋盘格子的边进行)

Image:Chess.gif

允许的分割方案 不允许的分割方案

原棋盘上每一格有一个分值，一块矩形棋盘的总分为其所含各格分值之和。现在需要把棋盘按上述规则分割成n块矩形棋盘，并使各矩形棋盘总分的均方差最小。

均方差Image:Division-1.gif，其中平均值Image:Division-2.gifxi为第i块矩形棋盘的分。 请编程对给出的棋盘及n，求出Image:Division-3.gif的最小值。

输入

  • 第1行为一个整数n(1<n<15)。
  • 第2行至第9行每行为8个小于100的非负整数，表示棋盘上相应格子的分值。每行相邻两数之间用一个空格分隔。

输出

  • 仅一个数，为Image:Division-3.gif（四舍五入精确到小数点后三位）。

样例输入

3
1 1 1 1 1 1 1 3
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 0
1 1 1 1 1 1 0 3

样例输出

1.633

生日蛋糕

7月17日是Mr.W的生日，ACM-THU为此要制作一个体积为Nπ的M层生日蛋糕，每层都是一个圆柱体。设从下往上数第i(1<=i& lt;=M)层蛋糕是半径为Ri, 高度为Hi的圆柱。当i<M时，要求Ri>Ri+1且Hi>Hi+1。由于要在蛋糕上抹奶油，为尽可能节约经费，我们希望蛋糕外表面 （最下一层的下底面除外）的面积Q最小。

令Q= Sπ请编程对给出的N和M，找出蛋糕的制作方案（适当的Ri和Hi的值），使S最小。（除Q外，以上所有数据皆为正整数）

输入

有两行，第一行为N（N<=10000），表示待制作的蛋糕的体积为Nπ；第二行为M(M<=20)，表示蛋糕的层数为M。

输出

仅一行，是一个正整数S（若无解则S=0）。

样例输入

100
2

样例输出

68

附：圆柱公式

  • 体积V=πR2H
  • 侧面积A’=2πRH
  • 底面积A=πR2

最优连通子集

众所周知，我们可以通过直角坐标系把平面上的任何一个点P用一个有序数对(x,y)来唯一表示，如果x,y都是整数，我们就把点P称为整点，否则点P称为非整点。我们把平面上所有整点构成的集合记为W。

定义1

  • 两个整点P1(x1,y1),P2(x2,y2)，若|x1-x2|+|y1-y2|=1，则称P1,P2相邻，记作P1~P2，否则称P1,P2不相邻。

定义2

  • 设点集S是W的一个有限子集，即S={P1,P2,…,Pn}(n>=1)，其中Pi(1<=i<=n)属于W，我们把S称为整点集。

定义3

  • 设S是一个整点集，若点R,T属于S，且存在一个有限的点序列Q1,Q2,…,Qk满足:
    1. Qi属于S（1<=i<=k）;
    2. Q1=R,Qk= T;
    3. Qi~Qi+1(1<=i<=k-1)，即Qi与Qi+1相邻;
    4. 对于任何1<=i<j<=k有Qi≠Qj;
  • 我们则称点R与点T在整点集S上连通，把点序列Q1,Q2,…,Qk称为整点集S中连接点R与点T的一条道路。

定义4

  • 若整点集V满足：对于V中的任何两个整点，V中有且仅有一条连接这两点的道路，则V称为单整点集。

定义5

  • 对于平面上的每一个整点，我们可以赋予它一个整数，作为该点的权，于是我们把一个整点集中所有点的权的总和称为该整点集的权和。

我们希望对于给定的一个单整点集V，求出一个V的最优连通子集B，满足：

  1. B是V的子集
  2. 对于B中的任何两个整点，在B中连通；
  3. B是满足条件(1)和(2)的所有整点集中权和最大的。

输入

第1行是一个整数N，表示单整点集V中点的个数；

以下N行中，第i行(1<=i<=N)有三个整数，Xi,Yi,Ci依次表示第i个点的横坐标，纵坐标和权。同一行相邻两数之间用一个空格分隔。

输出

仅一个整数，表示所求最优连通集的权和。

样例输入

5
0 0 -2
0 1 1
1 0 1
0 -1 1
-1 0 1

样例输出

2

参数约定

  • 2<=N<=1000
  • -10^6<=Xi,Yi<=10^6
  • -100<=Ci<=100

01串

给定7个整数N,A0,B0,L0,A1,B1,L1，要求设计一个01串S=s1s2…si…sN，满足：

  1. si=0或si=1，1<=i<=N；
  2. 对于S的任何连续的长度为L0的子串sjsj+1…sj+L0-1(1<=j<=N-L0+1)，0的个数大于等于A0且小于等于B0;
  3. 对于S的任何连续的长度为L1的子串sjsj+1…sj+L1-1(1<=j<=N-L1+1)，1的个数大于等于A1且小于等于B1;

例如，N=6,A0=1,B0=2,L0=3,A1=1,B1=1,L1=2，则存在一个满足上述所有条件的01串S=010101。

输入

  • 仅一行，有7个整数，依次表示N,A0,B0,L0,A1,B1,L1（3<=N<=1000，1<= A0<=B0<=L0<=N，1<=A1<=B1<=L1<=N），相邻两个整数之间用一个空格分隔

输出

  • 仅一行，若不存在满足所有条件的01串，则输出一个整数-1，否则输出一个满足所有条件的01串。

样例输入

6 1 2 3 1 1 2

样例输出

010101

内存分配

内存是计算机重要的资源之一，程序运行的过程中必须对内存进行分配。

经典的内存分配过程是这样进行的：

  1. 内存以内存单元为基本单位，每个内存单元用一个固定的整数作为标识，称为地址。地址从0开始连续排列，地址相邻的内存单元被认为是逻辑上连续的。我们把从地址i开始的s个连续的内存单元称为首地址为i长度为s的地址片。
  2. 运行过程中有若干进程需要占用内存，对于每个进程有一个申请时刻T，需要内存单元数M及运行时间P。在运行时间P内（即T时刻开始，T+P时刻结束），这M个被占用的内存单元不能再被其他进程使用。
  3. 假设在T时刻有一个进程申请M个单元，且运行时间为P，则：
    1. 若T时刻内存中存在长度为M的空闲地址片，则系统将这M个空闲单元分配给该进程。若存在多个长度为M个空闲地址片，则系统将首地址最小的那个空闲地址片分配给该进程。
    2. 如果T时刻不存在长度为M的空闲地址片，则该进程被放入一个等待队列。对于处于等待队列队头的进程，只要在任一时刻，存在长度为M的空 闲地址片，系统马上将该进程取出队列，并为它分配内存单元。注意，在进行内存分配处理过程中，处于等待队列队头的进程的处理优先级最高，队列中的其它进程 不能先于队头进程被处理。

现在给出一系列描述进程的数据，请编写一程序模拟系统分配内存的过程。

输入

  • 第一行是一个数N，表示总内存单元数（即地址范围从0到N-1）
  • 从第二行开始每行描述一个进程的三个整数T、M、P（M<=N）。
  • 数据已按T从小到大排序。
  • 最后一行用三个0表示结束。
  • 输入文件最多10000行，且所有数据都小于10^9。
  • 输入文件中同一行相邻两项之间用一个或多个空格隔开。

输出

  • 包括2行。
  • 第一行是全部进程都运行完毕的时刻。
  • 第二行是被放入过等待队列的进程总数。

样例输入

10
1 3 10
2 4 3
3 4 4
4 1 4
5 3 4
0 0 0

样例输出

12
2

样例示例

时

刻

T

内存占用情况

进程事件

0

1

2

3

4

5

6

7

8

9

进程A申请空间（M=3,P=10）<成功>

1

A

2

A

B

进程B申请空间（M=4,P=3）<成功>

3

A

B

进程C申请空间（M=4,P=4）<失败进入等待队列>

4

A

B

D

进程D申请空间（M=1,P=4）<成功>

5

A

C

D

进程B结束，释放空间

进程C从等待队列取出，分配空间

进程E申请空间（M=3,P=4）<失败进入等待队列>

6

A

C

D

7

A

C

D

8

A

C

E

进程D结束，释放空间

进程E从等待队列取出，分配空间

9

A

E

进程C结束，释放空间

10

A

E

11

E

进程A结束，释放空间

12

进程E结束，释放空间

Maybe you like

]]> http://www.byvoid.com/blog/noi-1999-solution/feed/ 7 POI 1999 积水 Water http://www.byvoid.com/blog/poi-1999-wod/ http://www.byvoid.com/blog/poi-1999-wod/#comments Tue, 16 Dec 2008 14:10:46 +0000 BYVoid http://www.byvoid.com/blog/?p=675 根据木桶原理，水位的高低取决于最低的边界。我们可以从最低的边界入手，向内灌水，使水面于边界齐平。如果灌到了新的边界，而且不低于最低的边界，则这个点一定是不能被灌水的。

每次取边界最小值向内灌水，于是可以用一个最小堆来维护高度。

算法流程如下：

  1. 把所有的边界上的点加入堆，且标记为已使用过。
  2. 取出高度最小的点(x,y)，枚举与(x,y)相邻的未使用过的点(x’,y’)，从(x’,y’)开始Floodfill，边界高度h=(x,y)的高度。
  3. 重复第二步，直到堆为空。
  • Floodfill(x,y)
  1. 标记(x,y)为已使用过。
  2. 如果(x,y)的高度>=h，则该点不能积水，加入堆并返回。
  3. 否则(x,y)的点的积水量为h-(x,y)的高度。
  4. 枚举与(x,y)相邻的未使用过的点(x’,y’)，Floodfill(x’,y’)。

?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

/* 
 * Problem: POI1999 wod
 * Author: Guo Jiabao
 * Time: 2008.12.16 21:44:50
 * State: Solved 
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
 
using namespace std;
 
const int MAX=101;
const int dx[4]={0,0,-1,1},dy[4]={1,-1,0,0};
 
struct point
{
	int x,y;
};
 
int N,M,All;
int Alt[MAX][MAX];
bool vid[MAX][MAX];
int heap_size;
point Heap[MAX*MAX];
 
void heap_ins(int x,int y)
{
	int i;
	for (i=++heap_size;Alt[x][y]<Alt[Heap[i/2].x][Heap[i/2].y];i=i/2)
		Heap[i]=Heap[i/2];
	Heap[i].x=x; Heap[i].y=y;
}
 
point heap_delmin()
{
	point R=Heap[1],M=Heap[heap_size--];
	int i,c;
	for (i=1;i*2<=heap_size;i=c)
	{
		c=i*2;
		if (c!=heap_size && Alt[Heap[c+1].x][Heap[c+1].y]<Alt[Heap[c].x][Heap[c].y])
			c++;
		if (Alt[M.x][M.y] > Alt[Heap[c].x][Heap[c].y])
			Heap[i]=Heap[c];
		else
			break;
	}
	Heap[i]=M;
	return R;
}
 
void init()
{
	freopen("wod.in","r",stdin);
	freopen("wod.out","w",stdout);
	scanf("%d%d",&N,&M);
	for (int i=1;i<=N;i++)
		for (int j=1;j<=M;j++)
			scanf("%d",&Alt[i][j]);
	Alt[0][0]=-0x7FFFFFFF;
	Heap[heap_size=0].x=Heap[0].y=0;
}
 
inline bool inrange(point A)
{
	return A.x>=1 && A.x<=N && A.y>=1 && A.y<=M;
}
 
void floodfill(point A,int h)
{
	point B;
	vid[A.x][A.y]=true;
	if (Alt[A.x][A.y]>=h)
		heap_ins(A.x,A.y);
	else
	{
		All+=h-Alt[A.x][A.y];
		for (int i=0;i<4;i++)
		{
			B.x=A.x+dx[i]; B.y=A.y+dy[i];
			if (inrange(B) && !vid[B.x][B.y])
				floodfill(B,h);
		}
	}
}
 
void solve()
{
	int i,j;
	point A,B;
	for (i=1;i<=N;i++)
	{
		heap_ins(i,1);
		heap_ins(i,M);
		vid[i][1]=vid[i][M]=true;
	}
	for (i=2;i<=M-1;i++)
	{
		heap_ins(1,i);
		heap_ins(N,i);
		vid[1][i]=vid[N][i]=true;
	}
	while (heap_size)
	{
		A=heap_delmin();
		for (i=0;i<4;i++)
		{
			B.x=A.x+dx[i]; B.y=A.y+dy[i];
			if (inrange(B) && !vid[B.x][B.y])
				floodfill(B,Alt[A.x][A.y]);
		}
	}
}
 
int main()
{
	init();
	solve();
	printf("%d",All);
	return 0;
}

积水

问题描述

有这样一块土地，它可以被划分N*M个正方形小块，每块面积是一平方英寸，第i行第j列的小块可以表示成P(i,j)。这块土地高低不平，每一小块地P(i,j)都有自己的高度H(i,j)(单位是英寸)。

一场倾盆大雨后，由于这块地地势高低不同，许多低洼地方都积存了不少降水。假如你已经知道这块土地的详细信息，你能求出它最多能积存多少立方英寸的降水么?

输入格式

输入文件的第一行是两个正整数n和m,1<=n<=100,1<=m<=100,表示土地的尺寸。下面n行，每行m个整数(1..10000);第j行第i个数表示第j行第i列立方体的高。

输出格式

输出文件只有一个数，表示在这个建筑上可以聚合的积水的最大值

输入输出样例

输入

3 6
3 3 4 4 4 2
3 1 3 2 1 4
7 3 1 6 4 1

输出

5

下图是其方案：

Image:Wod.png

Maybe you like

]]> http://www.byvoid.com/blog/poi-1999-wod/feed/ 0 POI 1999 遗传密码 Primitivus http://www.byvoid.com/blog/poi-1999-pie/ http://www.byvoid.com/blog/poi-1999-pie/#comments Mon, 15 Dec 2008 14:16:41 +0000 BYVoid http://www.byvoid.com/blog/?p=671 把特征串看作图中的一条边，建立一个图。我们只需计算，至少增加的边数k，能使图中存在一个欧拉回路，则N+k就是结果。

一个有向图存在欧拉回路的充要条件是图中有且只有一个连通分支且每一点的出度等于入度。假设图中只存在一个连通分支，则至少增加的边数k＝每个点出度入度之差的绝对值之和的二分之一。

如果图中存在多个连通分支，则对于每个连通分支，按一个连通分支的方法求其至少的加边数，再加上本来就存在欧拉回路的连通分支的个数，就是k的值。

求连通分量的方法可以用广搜或者并查集，时间复杂度为O(N)。

?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

/* 
 * Problem: POI1999 pie
 * Author: Guo Jiabao
 * Time: 2008.12.15 22:00:54
 * State: Solved 
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
 
using namespace std;
 
const int MAXN=1001;
 
class tUFS
{
	public:
	int F[MAXN];
	tUFS()
	{
		for (int i=1;i<MAXN;i++)
			F[i]=-i;
	}
	int findroot(int a)
	{
		int r=a,t;
		while (F[r]>0) r=F[r];
		while (F[a]>0) {t=F[a];F[a]=r;a=t;}
		return r;
	}
	void Union(int a,int b)
	{
		F[findroot(a)]=findroot(b);
	}
	bool Judge(int a,int b)
	{
		return F[findroot(a)]==F[findroot(b)];
	}
	int getroot(int a)
	{
		return -F[findroot(a)];
	}
};
 
int M,PC,Ans;
int ind[MAXN],oud[MAXN];
bool app[MAXN],P[MAXN];
int A[MAXN],Q[MAXN];
tUFS U;
 
void init()
{
	int i,a,b;
	freopen("pie.in","r",stdin);
	freopen("pie.out","w",stdout);
	scanf("%d",&M);
	for (i=1;i<=M;i++)
	{
		scanf("%d%d",&a,&b);
		oud[a]++; ind[b]++;
		app[a]=app[b]=true;
		if (!U.Judge(a,b))
			U.Union(a,b);
	}
}
 
void solve()
{
	int i,k,v;
	for (i=1;i<MAXN;i++)
	{
		if (app[i])
		{
			k=U.getroot(i);
			if (!P[k])
			{
				P[k]=true;
				Q[++PC]=k;
			}
			v=ind[i]-oud[i]; if (v<0) v=-v;
			A[k]+=v;
		}
	}
	Ans=M;
	if (PC==(i=1))
	{
		if (A[Q[i]]==0)
			Ans++;
		else
			Ans+=A[Q[i]]/2;
	}
	else
	{
		for (i=1;i<=PC;i++)
		{
			if (A[Q[i]]==0)
				Ans++;
			else
				Ans+=A[Q[i]]/2;
		}
	}
}
 
int main()
{
	init();
	solve();
	printf("%d",Ans);
	return 0;
}

遗传密码

问题描述

一个 primitivus 的 遗传密码 是一串自然数 K= ( a_1,…,a_n ) 。所有在 primitivus 的遗传密码中连续出现的数对 ( l , r ) 被称为一个 primitivus 的 特征 。例如存在一个 i ， l=a_i, r=a_i+1 。在 primitivus 的遗传密码中没有形如 ( p , p ) 的特征。 任务

写一个程序

  • 从输入文件中读入特征的列表
  • 计算 primitivus 的遗传密码的最短长度
  • 将结果写到输出文件

输入格式

在输入文件的第一行有一个正整数 n ，表示 primitivus 的遗传密码的不同的特征。在接下来的 n 行中，每行有一对自然数 l 和 r ，用空格隔开， 1 <= l <= 1000, 1 <= r <= 1000 。数对 ( l , r ) 是 primitivus 的特征。特征不会在输入文件中重复出现。

输出格式

你的程序应当向输出文件输出一个数，表示包含输入文件中所有特征的最短的 primitivus 遗传密码的长度。

输入样例

12
2 3
3 9
9 6
8 5
5 7
7 6
4 5
5 1
1 4
4 2
2 8
8 6

输出样例

15

注释

下面的遗传密码包含了所有特征：

(8, 5, 1, 4, 2, 3, 9, 6, 4, 5, 7, 6, 2, 8, 6)

Maybe you like

]]> http://www.byvoid.com/blog/poi-1999-pie/feed/ 0 POI 1999 地图着色 Map http://www.byvoid.com/blog/poi-1999-map/ http://www.byvoid.com/blog/poi-1999-map/#comments Mon, 15 Dec 2008 13:04:43 +0000 BYVoid http://www.byvoid.com/blog/?p=667 这是一个动态规划的问题。对于题中给定的A(k)的定义，我们可以很容易发现累积误差最小的情况为取A(k)为这组数的中值（不是严格意义上的中位 数，是数列S[i]..S[j]中的S[(i+j+1)/2] /为整除）。于是我们很容易想到要从小到大排序，然后以长度为阶段动态规划。

状态设定

  • F[i,j] 表示前i个地区，然成j种颜色时最小的总误差。
  • P[i,j] 表示排序过后的序列中，第i位到第j位的最小误差。

状态转移方程

  • F[i,j]=Min{ F[k,j-1] + P[k+1,i] | 0<=k<=i-1 }

边界条件

  • F[i,j]=无穷大 (0<=i<=N , 0<=j<=M)
  • F[0,0]=0

P[i,j]有定义式为

  • P[i,j]=Sum{ Abs( S[k]-Mid(i,j) ) | i<=k<=j } (Mid(i,j)为S[i]..S[j]的中值)

但是如果我们直接这样求，时间复杂度高达O(N^3 + N^2*M)，关键在于求P[i,j]时浪费了太多时间。其实我们可以递推求出P[i,j]。

递推式

  • P[i,j]=P[i+1,j] + Mid(i,j) – S[i]

边界

  • P[i,i]=0

这样，我们就可以在O(N^2*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

/* 
 * Problem: POI1999 map
 * Author: Guo Jiabao
 * Time: 2008.12.15 20:43:18
 * State: Solved 
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
 
using namespace std;
 
const int MAXN=3001;
const int MAXM=11;
const int INF=0x7FFFFFF;
 
int N,M,Ans;
int S[MAXN];
int P[MAXN][MAXN],F[MAXN][MAXM];
 
int cmp(const void *a,const void *b)
{
	return *(int *)a-*(int *)b;
}
 
void init()
{
	int i,j;
	freopen("map.in","r",stdin);
	freopen("map.out","w",stdout);
	scanf("%d%d",&N,&M);
	for (i=1;i<=N;i++)
		scanf("%d",&S[i]);
	qsort(S+1,N,sizeof(S[0]),cmp);
	for (i=0;i<=N;i++)
		for (j=0;j<=M;j++)
			F[i][j]=INF;
	F[0][0]=0;
}
 
void dynamic()
{
	int i,j,k;
	for (j=1;j<=N;j++)
	{
		P[j][j]=0;
		for (i=j-1;i>=1;i--)
		{
			P[i][j]=P[i+1][j]+S[(i+j+1)/2]-S[i];
		}
	}
	for (i=1;i<=N;i++)
	{
		for (j=1;j<=M;j++)
		{
			F[i][j]=INF;
			for (k=0;k<=i-1;k++)
			{
				if (F[k][j-1] + P[k+1][i] < F[i][j])
					F[i][j] = F[k][j-1] + P[k+1][i];
			}
		}
	}
	Ans=F[N][M];
}
 
int main()
{
	init();
	dynamic();
	printf("%d",Ans);
	return 0;
}

地图着色

在Byteland新的行政划分以后，制图工作室需要制作国家新的统计地图。因为技术上的原因，仅有很少的颜色能够被使用。地图上有着相同或者相似的人口（居民数）的地区被着为相同的颜色。对于给定的颜色K，让A（k）为数字，意思为：

  1. 至少有一半颜色为k的地区人口不大于A（k）。
  2. 至少有一半颜色为k的地区人口不少于A（k）。

地区的着色误差是指A（k）与地区人口之间的差额的绝对值，累积误差是指所有地区的着色误差之和。我们寻找一种地图的最佳着色方案（即最小的累积误差）

任务

写一个程序：

  1. 从输入文件读取Byteland地区的人口，
  2. 计算最小的累积误差，
  3. 把结果写到文件中。

输入

在输入文件的首行有一个整数n（10< n <3000），它是Byteland的地区数。第二行有数字m（2 <= m <= 10），表示用于着色的颜色数。在接下来的n行中的每一行里有一个非负的整数- Byteland一个地区的人口数。注：人口数不超过2^30。

输出

你的程序应该在输出文件单独的一行里写下一个整数—等于能够完成地图最佳着色的最小累积误差。

样例输入

11
3
21
14
6
18
10
2
15
12
3
2
2

样例输出

15

Maybe you like

]]> http://www.byvoid.com/blog/poi-1999-map/feed/ 0