这题难么，很朴素的都能秒杀：

附程序：

program p1165(input,output);

var

a,b:array[1..100000] of longint;

i,j,n,y:longint;

t:qword;

procedure kp(h,t:longint);

var

i,j,x,y:longint;

begin

i:=h;

j:=t;

x:=a[h];

y:=b[h];

while i

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

program huoshaochebi;

var ai,bi,fi:array[0..20000]of longint;

i,j,k,n,m,sum,max:longint;

procedure sort(r,l:longint);

var i,j,x,t:longint;

begin

i:=r;

j:=l;

x:=ai[(i+j) div 2];

repeat

while ai[i]x do dec(j);

if ij;

if ir then sort(r,j);

end;

procedure init;

var i:longint;

begin

readln(n);

for i:=1 to n do

begin

readln(ai[i],bi[i]);

end;

end;

begin

init;

sort(1,n);

sum:=bi[1]-ai[1];

max:=bi[1];

for i:=2 to n do

begin

if (ai[i]max) then

begin

inc(sum,bi[i]-max);

max:=bi[i];

end

else if (ai[i]>max) then

begin

inc(sum,bi[i]-ai[i]);

max:=bi[i];

end;

end;

writeln(sum);

end.

AC.....终于AC....庆祝....

随机化快排，一次AC

我用long用的好好的，未有溢出一说

二维的数组怎么就超时？我明明快排啊？

program pp;

var

i,j,k,m,n,tot,x,y:longint;

a:array[0..200000,0..1] of longint;

function max(x,y:longint):longint;

begin

if x>y then exit(x)else exit(y);

end;

procedure quick(x,y:longint);

var

i,j,p:longint;

t:array[0..1] of longint;

begin

i:=x;j:=y;p:=random(j-i)+i;t:=a[p];a[p]:=a[i];

repeat

while (i

2009/1/28/9/32

AC百题

Accepted 有效得分：100 有效耗时：0ms 奇水的题交了3次……

核心代码：

begin

readln(n);ans:=0;

for i:=1 to n do

readln(x[i],y[i]);

qsort(1,n);

for i:=1 to n-1 do

if y[i]>x then

begin x:=y[i];

if x>y then y:=x end;（第一次交这里写成了x:=y……）

for i:=1 to n do

inc(ans,y[i]-x[i]);

writeln(ans);

end.

第二次交├ 测试数据 07：运行时错误...| 错误号: 202 | 堆栈溢出错

…… 囧死 发现vj上很多题（很多很多）给的数据范围都是错的……害人不浅

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

一次AC.

var l,r:array[0..20001] of longint;

n,x,y,t:longint;

procedure init;

var i,k,j:longint;

begin

readln(n);

for i:=1 to n do readln(l[i],r[i]);

end;

procedure qsort(top,wei:longint);

var i,k:longint;

begin

i:=top; k:=wei; t:=random(k-i)+i; x:=l[t]; y:=r[t]; l[t]:=l[i]; r[t]:=r[i];

while ix) or ((l[k]=x) and (r[k]>y))) and (i

http://kappaoi.5d6d.com/viewthread.php?tid=188&extra=page%3D1

前面不要发伪AC代码

program ex;

var i,n,z,d,x,j:longint;

a,b,c:array[1..1000000] of longint;

begin

readln(n);z:=0;d:=0;x:=0;

for i:=1 to n do

begin

readln(a[i],b[i]);

if (a[i]>b[i]) and (a[i]>=d) then d:=a[i]

else if (b[i]>a[i]) and (b[i]>=d) then d:=b[i];

if (b[i]

汗！快排写错了，提交总是通不过……

Type

Segment = record

x,y : integer;

end;

var

sum,x,y,n,i,tmp : integer;

a : array[1..20000] of Segment;

procedure qsort(l,r:integer);

var

i,j,x:integer;

tmp : Segment;

begin

i:=l;j:=r;

x:=a[random(r-l+1)+l].x;

repeat

while (a[i].x < x) do inc(i);

while (a[j].x > x) do dec(j);

if (i j;

if (i < r) then qsort(i,r);

if (l < j) then qsort(l,j);

end;

begin

readln(n);

sum:=0;

for i := 1 to n do

begin

readln(a[i].x, a[i].y);

if (a[i].x > a[i].y) then

begin

tmp := a[i].x;

a[i].x := a[i].y;

a[i].y := tmp;

end;

end;

qsort(1,n);

//for i := 1 to n do

// writeln(a[i].x,a[i].y);

x:=a[1].x;

y:=a[1].y;

for i := 2 to n do

if (a[i].x y)

then

y := a[i].y

else

begin

sum:=sum + y - x;

x := a[i].x;

y := a[i].y;

end;

sum := sum + y - x;

writeln(sum);

end.

用栈模拟：碰到左端点则入栈，碰到右端点出栈，使栈空的出栈操作是关键的，因为是在这里记录这一段着火的船的长度。

第一次用long得90分，改成long long才a

#include

#define maxn 50000

typedef long long Type;

Type n,start[maxn+10],end[maxn+10],ans,stack[maxn+10],top,INF;

void quicksort(Type* a,Type low,Type high)

{

Type l=low,r=high,x=a[low];

while(l

编译通过...

├ 测试数据 01：答案正确... 150ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 212ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：362ms

汗死

#include

using namespace std;

int num=0;

struct ship{

__int64 start;

__int64 end;

}ships[20000],current;

struct ship Unite(struct ship,struct ship);

void QuickSort(int first,int end);

int Partition(int first,int end);

int main()

{

int N;

cin >> N;

__int64 a,b;

for(int i=0;i> a >> b;

if(a!=b)

{

ships[num].start=a;

ships[num].end=b;

num++;

}

}

QuickSort(0,num-1);

/*for(int i=0;i

纯粹的马路上的树

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

区间原程序交过来..AC..

首先以区间上界为关键字Qsort.

然后处理重叠的区间.

处理区间时分2种情况.

一是到该区间为止.

另一种是还可以继续扩大当前区间.

然后求和(下界-上界).

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

QSORT+区间重叠处理...

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

water

开始时，用冒泡排序，无论怎样优化提交了23次，30---|--80分，（超时）

改成快速排序后，：一次性：

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms