Beyond the Void » USACO http://www.byvoid.com/blog Tue, 29 Jun 2010 08:44:46 +0000 en hourly 1 http://wordpress.org/?v=3.0 pku 3255 Roadblocks http://www.byvoid.com/blog/pku-3255/ http://www.byvoid.com/blog/pku-3255/#comments Tue, 14 Apr 2009 06:51:49 +0000 BYVoid http://www.byvoid.com/blog/?p=1216 这道题不同于一般的次短路径问题，因为允许边重走。看似更为复杂了，其实是更简单了一些。方法为先用Heap+Dijkstra求出1和N的单源最短路径，把无向边看成两个有向边，然后枚举每单向条边(u,v)，计算Dist=dis(1,u) + dis(N,v)，看看此时Dist的值是否大于dis(1,N)，如果是的话用它更新次短路径，保留一个最小的值。

USACO 2006 November Gold

?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

/* 
 * Problem: pku3255 Roadblocks
 * Author: Guo Jiabao
 * Time: 2009.4.14 10:32
 * State: Solved
 * Memo: 次短路径 Dijkstra + Heap (特殊)
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=5001,MAXM=200001,INF=0x7FFFFFF;
using namespace std;
struct Minheap
{
	struct HeapElement
	{
		int key,value;
	}H[MAXN];
	int size,Position[MAXN];
	void init(){H[size=0].value=-INF;}
	void shift(int key,int value,int pos)
	{
		int i,f;
		HeapElement p={key,value};
		for (i=pos;p.value < H[f=i>>1].value;i=f)
		{
			H[i]=H[f];
			Position[H[i].key]=i;
		}
		H[i]=p;
		Position[H[i].key]=i;
	}
	void ins(int key,int value){shift(key,value,++size);}
	void decrease(int key,int value){shift(key,value,Position[key]);}
	void delmin()
	{
		int i,c;
		HeapElement p=H[size--];
		for (i=1;(c=i<<1)<=size;i=c)
		{
			if (c+1 <=size && H[c+1].value < H[c].value)
				c++;
			if (H[c].value < p.value)
			{
				H[i]=H[c];
				Position[H[i].key]=i;
			}
			else
				break;
		}
		H[i]=p;
		Position[H[i].key]=i;
	}
}H;
struct edge
{
	edge *next;
	int t,c;
}ES[MAXM],*V[MAXN];
int N,M,EC=-1,Shortest,Ans;
int sp[2][MAXN];
inline void addedge(int a,int b,int c)
{
	ES[++EC].next=V[a];
	V[a]=ES+EC; V[a]->t=b; V[a]->c=c;
	ES[++EC].next=V[b];
	V[b]=ES+EC; V[b]->t=a; V[b]->c=c;
}
void init()
{
	int i,a,b,c;
	freopen("block.in","r",stdin);
	freopen("block.out","w",stdout);
	scanf("%d%d",&N,&M);
	for (i=1;i<=M;i++)
	{
		scanf("%d%d%d",&a,&b,&c);
		addedge(a,b,c);
	}
}
void dijkstra(int S,int *sp)
{
	int i,j;
	H.init();
	for (i=1;i<=N;i++)
		H.ins(i,sp[i]=INF);
	H.decrease(S,sp[S]=0);
	for (i=S;;)
	{
		H.delmin();
		for (edge *e=V[i];e;e=e->next)
		{
			j=e->t;
			if (sp[i] + e->c <sp[j])
				H.decrease(j,sp[j]=sp[i] + e->c);
		}
		if (H.size)
			i=H.H[1].key;
		else
			break;
	}
}
void solve()
{
	int i,c;
	dijkstra(1,sp[0]);
	dijkstra(N,sp[1]);
	Shortest=sp[0][N];
	Ans=INF;
	for (i=0;i<=EC;i+=2)
	{
		edge *e1=ES+i,*e2=ES+i+1;
		int a=e1->t,b=e2->t;
		c=sp[0][a] + sp[1][b] + e1->c;
		if (c < Ans && c>Shortest)
			Ans=c;
		c=sp[1][a] + sp[0][b] + e1->c;
		if (c < Ans && c>Shortest)
			Ans=c;
	}
}
int main()
{
	init();
	solve();
	printf("%dn",Ans);
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/pku-3255/feed/ 0 我叫 Grover Morgan http://www.byvoid.com/blog/grover-morgan/ http://www.byvoid.com/blog/grover-morgan/#comments Wed, 22 Oct 2008 13:37:55 +0000 BYVoid http://www.byvoid.com/blog/?p=402 做USACO月赛遇到一件巨囧的事。今天中午受到Rob的信

Dear CmYkRgB123 CmYkRgB123 [ID: cmykrgb1]:

Your recent entry (as cmykrgb1) to the USACO programming contest has
been rejected because the name that you used to register:

CmYkRgB123 CmYkRgB123

was deemed to be incomplete, inaccurate, inflammatory, wrong,
misleading, suspicious, or confusing — or it doesn’t contain latin
characters like A-Za-z.
……

名字不符合规则，”它被认为是不完整，不准确的，有煽动性的，错误的，有误导性的，可疑的，混淆的”(汗…..)
没想到CmYkRgB123这个名字这么强悍。

然后我给Rob回信，内容如下

Dear Rob

I am a Chinese user. My ID cmykrgb1 contains CmYkRgB123 CmYkRgB123 because I don’t have a English name.This name is from my Chinese name. This is my only ID and I had taken part in the contest by the rules . I was not cheating.

If the name doesn’t match the rules , I ‘ll change it at once.

Sincerely cmykrgb123

没想到他很快就回信了(我还以为他在睡觉)

Why not create a nice english name for yourself?

May I suggest Grover Morgan?

RK

Grover Morgan，汗，他还给我起了名字。不过这名字似乎也不错，就叫我Grover Morgan把，呵呵。

Thank you for creating a nice name for me. Since I could’n come up with a name ,I think you can call me Grover Morgan.

And could you please unlock my ID cmykrgb1 ?

Maybe you like

]]> http://www.byvoid.com/blog/grover-morgan/feed/ 7 USACO FEB07 Silver Silver Lilypad Pond 银色莲花池 http://www.byvoid.com/blog/usaco-feb07-silver-silver-lilypad-pond/ http://www.byvoid.com/blog/usaco-feb07-silver-silver-lilypad-pond/#comments Thu, 09 Oct 2008 14:23:18 +0000 BYVoid http://www.byvoid.com/blog/?p=338
广搜实现动态规划。从起始点开始搜索，只要不是石头的点都可以访问。对于网格中每一个点，维护三个参数：从起始点到当前点所要添加的莲花数lily，总起始点到前点的走过的点数skip，到当前点当前满足条件的路径条数cnt。初始化所有点skip=lily=无穷大，cnt=0。起始点 skip=lily=0，cnt=1。

当位置i时，跳跃有8个方向，最多会访问8个点，对于每个点j，根据当前位置i更新其参数。分以下4种情况：

1. 如果 i.lily < j.lily ，由i点更新点j所有参数，并把点j加入队列
1. j.lily <- i.lily
2. j.skip <- i.skip
3. j.cnt <- i.cnt
2. 如果 i.lily = j.lily 并且 i.skip < j.skip ，由i点更新点j的跳跃次数和路径条数，并把点j加入队列
1. j.skip <- i.skip
2. j.cnt <- i.cnt
3. 如果 i.lily = j.lily 并且 i.skip = j.skip ，j的路径条数满足条件，增加量为i的路径条数，并把点j加入队列
1. j.cnt <- j.cnt + i.cnt
4. 如果不满足以上条件，不更新改点。

最终结果为目标点T的lily,skip,cnt。

?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

#include <iostream>
#define MAX 31
#define INF 0x7ffffff
#define Source 3
#define Destination 4
#define Stone 2
#define Lily 1
#define Water 0
using namespace std;
 
typedef struct
{
	int x,y;
}point;
 
class tQueue
{
public:
	class linklist
	{
	public:
		linklist* next;
		point value;
		linklist()
		{
			next=0;
		}
	};
	linklist *first,*last;
	int size;
	bool inq[MAX][MAX];
	void add(point p)
	{
		if (inq[p.x][p.y])
			return;
		inq[p.x][p.y]=true;
		if (size==0)
			first=last=new linklist;
		else
			last=last->next=new linklist;
		last->value=p;
		size++;
	}
	point del()
	{
		point rtn=first->value;
		inq[rtn.x][rtn.y]=false;
		linklist *tfirst=first;
		first=first->next;
		delete tfirst;
		size--;
		return rtn;
	}
	void reset()
	{
		size=0;
		first=last=0;
	}
	tQueue()
	{
		reset();
	}
};
 
class gird
{
public:
	int m;
	int lily,skip;
	long long cnt;
	gird()
	{
		lily=skip=INF;
		cnt=0;
	}
};
 
int N,M;
gird G[MAX][MAX];
int dx[8]={-2,-1,1,2,2,1,-1,-2},dy[8]={1,2,2,1,-1,-2,-2,-1};
point S,T;
tQueue Q;
 
void init()
{
	int i,j,c;
	freopen("silvlily.in","r",stdin);
	freopen("silvlily.out","w",stdout);
	scanf("%d%d",&N,&M);
	for (i=1;i<=N;i++)
	{
		for (j=1;j<=M;j++)
		{
			scanf("%d",&c);
			G[i][j].m=c;
			if (c==Source)
			{
				S.x=i;S.y=j;
				G[S.x][S.y].cnt=1;
				G[S.x][S.y].lily=G[S.x][S.y].skip=0;
			}
			else if (c==Destination)
			{
				T.x=i;T.y=j;
			}
		}
	}
}
 
inline bool inrange(point p)
{
	return p.x>=1 && p.x<=N && p.y>=1 && p.y<=M;
}
 
void update(point p,int lily,int skip,long long cnt)
{
	if (lily<G[p.x][p.y].lily)
	{
		G[p.x][p.y].lily=lily;
		G[p.x][p.y].skip=skip;
		G[p.x][p.y].cnt=cnt;
		Q.add(p);
	}
	else if (lily==G[p.x][p.y].lily && skip<G[p.x][p.y].skip)
	{
		G[p.x][p.y].skip=skip;
		G[p.x][p.y].cnt=cnt;
		Q.add(p);
	}
	else if (lily==G[p.x][p.y].lily && skip==G[p.x][p.y].skip)
	{
		G[p.x][p.y].cnt+=cnt;
	}
}
 
void bfs()
{
	point i,j;
	int k,sp;
	Q.add(S);
	while (Q.size)
	{
		i=Q.del();
		for (k=0;k<8;k++)
		{
			j.x=i.x+dx[k];j.y=i.y+dy[k];
			if (inrange(j))
			{
				sp=G[i.x][i.y].lily;
				if (G[j.x][j.y].m==Stone) continue;
				if (G[j.x][j.y].m==Water)
					sp++;
				update(j,sp,G[i.x][i.y].skip+1,G[i.x][i.y].cnt);
			}
		}
	}
}
 
 
int main()
{
	init();
	bfs();
	if (G[T.x][T.y].lily==INF)
		cout << -1 << endl;
	else
		cout
			<< G[T.x][T.y].lily << endl
			<< G[T.x][T.y].skip << endl
			<< G[T.x][T.y].cnt << endl;
	return 0;
}

银色莲花池

译 By BYVoid

描述

Farmer John 建造了一个美丽的池塘，用于让他的牛们审美和锻炼。这个长方形的池子被分割成了 M 行和 N 列( 1 ≤ M ≤ 30 ; 1 ≤ N ≤ 30 ) 正方形格子的 。某些格子上有惊人的坚固的莲花，还有一些岩石，其余的只是美丽，纯净，湛蓝的水。

贝茜正在练习芭蕾舞，她从一个莲花跳跃到另一个莲花，当前位于一个莲花。她希望在莲花上一个一个的跳，目标是另一个给定莲花。她能跳既不入水，也不到一个岩石上。

令门外汉惊讶的是，贝茜的每次的跳跃像国际象棋中的骑士一样：横向移动1，纵向移动2，或纵向移动，横向移动2。贝茜有时可能会有多达8个选择的跳跃。

Farmer John 在观察贝茜的芭蕾舞联系，他意识到有时候贝茜有可能跳不到她想去的目的地，因为路上有些地方没有莲花。于是他想要添加几个莲花使贝茜能够完成任务。一贯节俭的Farmer John想添加最少数量的莲花。当然，莲花不能放在石头上。

请帮助Farmer John确定必须要添加的莲花的最少数量。在添加的莲花最少基础上，算出贝茜从起始点跳到目标点需要的最少的步数。最后，还要算出满足添加的莲花的最少数量时，跳跃最少步数的跳跃路径的条数。

输入

* 第 1 行: 两个整数 M , N
* 第 2..M + 1 行:第 i + 1 行，第 i + 1 行 有 N 个整数，表示该位置的状态: 0 为水; 1 为莲花; 2 为岩石; 3 为贝茜开始的位置; 4 为贝茜要去的目标位置.

输出

* 第 1 行: 一个整数: 需要添加的最少的莲花数. 如果无论如何贝茜也无法跳到，输出 -1.
* 第 2 行: 一个整数: 在添加的莲花最少基础上，贝茜从起始点跳到目标点需要的最少的步数。如果第1行输出-1，这行不输出。
* 第 3 行: 一个整数: 添加的莲花的最少数量时，跳跃步数为第2行输出的值的跳跃路径的条数 如果第1行输出-1，这行不输出。

样例输入

4 8
0 0 0 1 0 0 0 0
0 0 0 0 0 2 0 1
0 0 0 0 0 4 0 0
3 0 0 0 0 0 1 0

样例输出

2
6
2

输出说明

至少要添加2朵莲花，放在了’x'的位置。

0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0
0 x 0 0 0 2 0 1 0 0 0 0 0 2 0 1
0 0 0 0 x 4 0 0 0 0 x 0 x 4 0 0
3 0 0 0 0 0 1 0 3 0 0 0 0 0 1 0

贝茜至少要条6步，有以下两种方案

0 0 0 C 0 0 0 0 0 0 0 C 0 0 0 0
0 B 0 0 0 2 0 F 0 0 0 0 0 2 0 F
0 0 0 0 D G 0 0 0 0 B 0 D G 0 0
A 0 0 0 0 0 E 0 A 0 0 0 0 0 E 0

Maybe you like

]]> http://www.byvoid.com/blog/usaco-feb07-silver-silver-lilypad-pond/feed/ 0 USACO FEB07 Bronze Bronze Lilypad Pond 青铜莲花池 http://www.byvoid.com/blog/usaco-feb07-bronze-bronze-lilypad-pond/ http://www.byvoid.com/blog/usaco-feb07-bronze-bronze-lilypad-pond/#comments Thu, 09 Oct 2008 14:20:39 +0000 BYVoid http://www.byvoid.com/blog/?p=336
跳马问题的变化版，广度优先搜索。

从原点开始，每个点搜索8个方向的点，搜索到目标点时的步数最少。

?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

#include <iostream>
#define MAX 31
 
using namespace std;
 
typedef struct
{
	int x,y;
}point;
 
class tQueue
{
public:
	class linklist
	{
	public:
		linklist* next;
		point value;
		linklist()
		{
			next=0;
		}
	};
	linklist *first,*last;
	int size;
	void add(point p)
	{
		if (size==0)
			first=last=new linklist;
		else
			last=last->next=new linklist;
		last->value=p;
		size++;
	}
	point del()
	{
		point rtn=first->value;
		linklist *tfirst=first;
		first=first->next;
		delete tfirst;
		size--;
		return rtn;
	}
	void reset()
	{
		size=0;
		first=last=0;
	}
	tQueue()
	{
		reset();
	}
};
 
int N,M,X,Y,Ans;
int dx[8],dy[8];
bool map[MAX][MAX];
int step[MAX][MAX];
point S,T;
tQueue Q;
 
void init()
{
	int i,j,c;
	freopen("bronlily.in","r",stdin);
	freopen("bronlily.out","w",stdout);
	cin >> N >> M >> X >> Y;
	for (i=1;i<=N;i++)
	{
		for (j=1;j<=M;j++)
		{
			cin >> c;
			if (c==1 || c==4)
				map[i][j]=true;
			if (c==3)
				S.x=i,S.y=j;
			if (c==4)
				T.x=i,T.y=j;
		}
	}
	dx[0]=-X; dy[0]=-Y;
	dx[1]=-X; dy[1]= Y;
	dx[2]= X; dy[2]=-Y;
	dx[3]= X; dy[3]= Y;
	dx[4]=-Y; dy[4]=-X;
	dx[5]=-Y; dy[5]= X;
	dx[6]= Y; dy[6]=-X;
	dx[7]= Y; dy[7]= X;
}
 
inline bool inrange(point p)
{
	return p.x>=1 && p.x <=N && p.y >=1 && p.y<=M;
}
 
int bfs()
{
	int k;
	point i,j;
	Q.add(S);
	while (Q.size)
	{
		i=Q.del();
		for (k=0;k<8;k++)
		{
			j.x=i.x+dx[k];
			j.y=i.y+dy[k];
			if (inrange(j) && map[j.x][j.y] && step[j.x][j.y]==0)
			{
				step[j.x][j.y]=step[i.x][i.y] + 1;
				if (j.x==T.x && j.y==T.y)
					return step[j.x][j.y];
				Q.add(j);
			}
		}
	}
}
 
int main()
{
	init();
	Ans=bfs();
	cout << Ans << endl;
	return 0;
}

青铜莲花池

译 By BYVoid

描述

Farmer John 建造了一个美丽的池塘，用于让他的牛们审美和锻炼。这个长方形的池子被分割成了 M 行和 N 列( 1 ≤ M ≤ 30 ; 1 ≤ N ≤ 30 ) 正方形格子的 。某些格子上有惊人的坚固的莲花，还有一些岩石，其余的只是美丽，纯净，湛蓝的水。

贝茜正在练习芭蕾舞，她从一个莲花跳跃到另一个莲花，当前位于一个莲花。她希望在莲花上一个一个的跳，目标是另一个给定莲花。她能跳既不入水，也不到一个岩石上。

令门外汉惊讶的是，贝茜的每次的跳跃像国际象棋中的骑士一样：横向移动M1(1 ≤M1 ≤ 30 )，纵向移动然后量M2 (1 ≤M2 ≤ 30 ;M1 ≠ M2 ) ，或纵向移动然后量M1，横向移动M2。贝茜有时可能会有多达8个选择的跳跃。

给定池塘的布局和贝茜的跳跃格式，请确定贝茜从从她的出发位置，到最终目的地，最小的跳跃次数，贝茜在给出测试数据一定可以跳到目的地。

输入

* 第 1 行: 四个用空格隔开的整数: M, N, M1, M2
* 第 2..M + 1 行: 第 i + 1 行 有 N 个整数，表示该位置的状态: 0 为水; 1 为莲花; 2 为岩石; 3 为贝茜开始的位置; 4 为贝茜要去的目标位置.

输出

* 第 1 行: 一个整数，从起始点到要去的位置，贝茜最小的跳跃次数。

样例输入

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

样例输出

2

输入解释

贝茜从第2行第1个位置开始，她的目标在第2行最右边。几个

输出解释

贝茜聪明地跳跃到了第1行第3个位置，然后就到了目的地。

Maybe you like

]]> http://www.byvoid.com/blog/usaco-feb07-bronze-bronze-lilypad-pond/feed/ 0