poj 1083 Moving Tables

测试数据

10
10
1 2
3 4
5 6
7 8
9 10
20 22
24 26
28 30
32 34
36 38
10
2 3
4 5
6 7
8 9
10 11
12 13
14 15
16 17
18 19
20 21
10
10 300
20 290
30 280
40 270
50 260
60 250
70 240
80 230
90 220
100 210
40
97 182
316 32
191 62
99 379
246 396
320 298
153 192
211 40
238 139
58 312
285 179
282 39
386 221
297 232
256 313
76 121
114 274
118 227
168 123
178 196
243 167
53 103
15 391
46 152
259 141
222 144
66 247
69 117
349 335
338 359
217 68
262 277
106 43
326 77
170 336
55 71
202 49
208 294
223 138
321 237
50
107 269
221 316
356 357
28 321
363 258
67 121
115 337
215 15
83 9
144 249
209 219
62 330
14 11
152 247
251 367
150 292
159 393
239 45
89 320
349 296
6 168
145 82
74 31
47 64
17 317
240 162
92 246
133 243
386 22
58 5
354 384
383 253
16 141
59 43
79 34
379 368
364 347
60 69
261 295
41 65
38 49
10 305
12 259
44 172
124 8
355 304
204 306
353 200
351 294
95 21
60
243 351
202 272
396 242
199 236
359 18
354 44
209 232
4 155
191 78
204 311
142 280
366 269
283 171
9 86
380 258
52 106
135 282
16 382
302 350
254 98
255 341
95 289
136 21
195 97
212 198
343 139
50 87
47 146
82 175
332 328
165 349
286 233
185 144
131 392
173 71
64 214
126 137
81 89
170 310
333 99
3 206
33 105
141 215
348 122
32 182
151 186
10 362
80 241
259 336
338 63
250 174
228 36
153 290
205 318
41 265
220 292
181 337
334 251
248 177
90 30
70
54 25
288 341
390 264
383 141
231 257
371 175
235 164
118 338
260 360
238 156
188 76
51 278
397 291
393 268
151 34
20 11
221 395
137 53
153 316
38 303
209 62
342 382
206 49
348 337
261 392
387 202
58 119
212 294
305 120
236 36
157 239
208 122
364 270
315 147
224 312
300 252
99 326
7 180
200 131
100 179
366 353
84 77
72 302
344 329
336 372
143 380
136 275
170 262
17 158
250 306
21 227
165 2
388 357
335 304
349 323
340 145
45 111
222 182
280 24
320 123
328 213
10 297
29 286
244 130
253 378
190 31
282 46
66 199
223 104
374 277
80
307 13
382 247
329 97
6 90
348 216
182 133
134 15
131 302
44 109
333 303
153 312
297 308
322 36
352 210
326 105
151 200
8 209
250 117
208 351
244 129
263 240
115 286
374 271
1 338
310 30
350 245
252 358
169 261
95 111
101 191
187 29
12 42
392 147
272 180
258 251
57 152
270 205
313 178
224 223
300 294
309 74
304 239
301 93
321 255
50 397
164 383
370 107
284 10
293 49
339 342
125 160
51 287
353 378
73 369
67 334
393 112
400 398
76 139
60 215
19 116
324 305
174 278
213 256
249 45
71 88
254 150
340 82
138 357
330 336
319 106
142 228
218 154
363 282
217 354
318 229
171 17
226 207
20 384
23 395
290 347
90
275 95
343 386
232 383
152 340
217 202
321 368
147 117
351 13
32 234
76 372
96 272
169 189
70 335
238 269
90 328
119 166
279 284
89 143
62 394
108 292
15 164
298 80
338 264
163 38
63 21
288 91
214 193
240 373
317 223
176 286
157 364
270 384
267 399
161 29
27 162
274 125
11 295
337 150
188 20
94 229
170 248
296 362
366 53
136 17
281 192
256 113
396 141
186 245
320 200
129 127
178 68
291 2
354 83
205 67
220 228
82 57
367 60
142 55
304 236
43 59
361 22
235 318
148 219
356 195
285 345
314 382
77 370
8 24
175 181
100 81
307 105
185 14
215 9
5 64
66 357
4 198
44 75
106 18
16 139
73 226
374 339
282 273
19 88
218 65
121 109
137 69
253 341
306 397
225 158
250 45
100
355 297
201 396
144 53
236 210
369 77
392 12
163 15
51 222
13 374
104 242
351 216
349 130
91 54
281 47
162 246
219 63
60 168
303 317
69 52
300 110
391 385
151 327
342 293
161 301
153 335
126 94
262 185
228 40
220 112
263 241
395 58
170 187
257 105
264 218
197 224
232 207
100 274
379 299
37 78
382 255
79 146
152 302
102 140
33 296
259 167
41 164
316 338
325 143
226 346
273 367
356 336
156 238
186 9
258 1
387 17
158 295
62 229
389 165
288 184
275 298
4 139
214 160
141 315
285 380
287 86
19 234
390 10
250 312
68 375
48 343
206 114
239 119
115 106
341 166
245 240
26 171
360 372
337 116
188 99
64 29
179 134
333 304
22 268
340 11
182 282
38 61
118 27
371 363
328 398
271 364
350 95
243 169
83 319
56 172
249 198
44 283
181 71
203 117
149 111
277 305

table.out
10 
20 
100 
230 
210 
310 
350 
440 
440 
530



code:

#include <iostream>
#include <stdio.h>
#include <cstring>
#include <algorithm>

using namespace std;
int n;
#define MAX_N 401

struct point{
	int s;
	int t;
}POINT[MAX_N];
bool cmp(const point & a,const point &b)
{
	return a.s < b.s;
}

int Move[MAX_N];

int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		int minret = 0;
		memset(Move,0,sizeof(Move));
		cin>>n;
		for(int i=1;i<=n;i++)
		{
			cin>>POINT[i].s>>POINT[i].t;
			POINT[i].s =(POINT[i].s + 1)/2;
			POINT[i].t = (POINT[i].t + 1)/2;

			if(POINT[i].s > POINT[i].t)
			{
				int tmp = POINT[i].s;
				POINT[i].s = POINT[i].t;
				POINT[i].t = tmp;
			}
			//保持线段左端s小于右端坐标t
		}


		sort(POINT+1,POINT+n+1,cmp);

		for(int i=1;i<=n;i++)
		{
			int s=POINT[i].s;
			int t=POINT[i].t;

			int j=0;
			//根据t找第一个不重叠的
			for(;j<MAX_N;j++)
			{
				if(Move[j] < s)
					break;
			}

			//放在第j层
			Move[j] = t;
		}
		
		for(int j=0;j< MAX_N;j++)
		{
			if(Move[j])
				minret++;
			else
				break;
		}
		cout<<minret*10<<endl;
	}
}



评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值