编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

#include

#include

using namespace std;

int main()

{

char b[26],a[200];

string c[1010];

string y[1010];

int i,j,n,sn;

gets(b);

for (i=0;i c[i];

y[i]=c[i];

for(j=0;j

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

虽然不是秒杀

但是用了选择排序 还是一次AC啊

纪念下啊

program p1500;

var i,j,n,p:longint;

a:array[0..1005] of string;

st:string;

procedure swap(i,j:longint);

var l,k:longint;

s1,s2:string;

begin

k:=0;

s1:=a[i]; s2:=a[j];

l:=length(s1);

if l>length(s2) then l:=length(s2);

repeat

inc(k);

if pos(s1[k],st)>pos(s2[k],st) then

begin

a[j]:=s1; a[i]:=s2;

exit;

end;

if pos(s1[k],st)length(s2) then

begin

a[j]:=s1; a[i]:=s2;

end;

end;

begin

readln(st);

readln(n);

for i:=1 to n do readln(a[i]);

for i:=1 to n-1 do

for j:=i to n do

swap(i,j);

readln(p);

if p=1 then for i:=1 to n do writeln(a[i])

else if p=0 then for i:=n downto 1 do writeln(a[i]);

end.

选择排序都是秒杀- -.

#include

unsigned sort[26], N, T;

char kp[1000][256], *pj[1000];

main()

{

unsigned i,t,p,j;

char *k;

for(i=0; i

program vj1500;

var

a:array[1..1001]of string;

s:array[1..26]of char;

f,n,j,i,k,len:longint;

procedure change(j,i:longint);

begin

a[1001]:=a[j];

a[j]:=a[i];

a[i]:=a[1001];

end;

function find(ch:char):longint;

var

i:longint;

begin

for i:=1 to 26 do

if s[i]=ch then exit(i);

end;

function bang(x,y:longint):boolean;

var j,i,k:longint;

begin

len:=length(a[x]);

if length(a[x])>length(a[y]) then len:=length(a[y]);

for j:=1 to len do

if find(a[x,j])find(a[y,j]) then if find(a[x,j])>find(a[y,j]) then begin exit(true)end else begin exit(false); end;

if length(a[x])>length(a[y]) then begin exit(true);end else begin

exit(false); end

end;

begin

for j:=1 to 26 do

read(s[j]);

readln(n);

for j:=1 to n do

readln(a[j]);

read(f);

for j:=1 to n do

for i:=j+1 to n do

begin

if bang(j,i)=true then begin change(j,i);

end;

end;

if f=1 then

for j:=1 to n do

writeln(a[j]) else for j:=n downto 1 do writeln(a[j]);

end.

请教大家.这个程序有什么问题?

编译通过...

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

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

├ 测试数据 03：答案错误...　

├ 标准行输出 qkbr...

　├ 错误行输出 wuyc...

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

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

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

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

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

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

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

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

Unaccepted 有效得分：90

#include

#include

using namespace std;

int w[28];

int word(char x)

{

int y=x-96;

return w[y];

}

int main()

{

char s[1009][300],a[300],c;

int i,b,ss,j,n,t,k;

for(i=1;i>c;

b=c-96;

w[ b ]=i;

}

cin>>n;

for(i=1;i>a;

ss=strlen(a);

for(j=0;j>t;

for(i=n;i>=1;i--)

for(j=1;j=word(s[j+1][k]) && s[j][k]!=0)

{

if(word(s[j][k])>word(s[j+1][k]) || s[j+1][k]==0)

{

int l=k,t1=1,t2=1;

while(t1!=0 || t2!=0)

{

if(s[j][l]==0)

t1=0;

if(s[j+1][l]==0)

t2=0;

c=s[j][l];

s[j][l]=s[j+1][l];

s[j+1][l]=c;

l++;

}

break;

}

k++;

}

}

if(t==1)

for(i=1;i

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

program vj1500;

var

a:array[1..1001]of string;

s:array[1..26]of char;

f,n,j,i,k,len:longint;

procedure change(j,i:longint);

begin

a[1001]:=a[j];

a[j]:=a[i];

a[i]:=a[1001];

end;

function find(ch:char):longint;

var

i:longint;

begin

for i:=1 to 26 do

if s[i]=ch then exit(i);

end;

function bang(x,y:longint):boolean;

var j,i,k:longint;

begin

len:=length(a[x]);

if length(a[x])>length(a[y]) then len:=length(a[y]);

for j:=1 to len do

if find(a[x,j])find(a[y,j]) then if find(a[x,j])>find(a[y,j]) then begin exit(true)end else begin exit(false); end;

if length(a[x])>length(a[y]) then begin exit(true);end else begin

exit(false); end

end;

begin

for j:=1 to 26 do

read(s[j]);

readln(n);

for j:=1 to n do

readln(a[j]);

read(f);

for j:=1 to n do

for i:=j+1 to n do

begin

if bang(j,i)=true then begin change(j,i);

end;

end;

if f=1 then

for j:=1 to n do

writeln(a[j]) else for j:=n downto 1 do writeln(a[j]);

end.

var ch:char;

i,j,p,l,m,n:Longint;

a:array[0..1000] of string;

t:array['a'..'z'] of longint;

function com(s1,s2:string):boolean;

var i:longint;

begin

i:=0;

while true do begin

inc(i);

if t[s1[i]]>t[s2[i]] then exit(false)

else if t[s1[i]]

话说q_sort可以过的样子……试试

很好……其实普通的N^2排序也是可以的……就是不是秒杀而已……

var

n,t,i,j:integer;

wor:array [1..1000] of string;

dic,temp:string;

function biggerstr(a,b:string):boolean;

function biggercha(a,b:char):boolean;

　　begin

　　 if pos(a,dic)>pos(b,dic) then biggercha:=true else biggercha:=false;

　　end;

var

　　i:integer;

begin

　　i:=0;

　　repeat

　　 i:=i+1;

　　until (a[i]b[i]) or (i=length(a)) or (i=length(b));

　　if i=length(a) then biggerstr:=false;

　　if i=length(b) then biggerstr:=true;

　　if a[i]b[i] then biggerstr:=biggercha(a[i],b[i]);

end;

begin

randomize;

readln(dic);

readln(n);

for i:=1 to n do readln(wor[i]);

readln(t);

for i:=1 to n do for j:=i+1 to n do if biggerstr(wor[i],wor[j]) then

　　begin

　　 temp:=wor[i];

　　 wor[i]:=wor[j];

　　 wor[j]:=temp;

　　end;

if t=0 then for i:=n downto 1 do writeln(wor[i]);

if t=1 then for i:=1 to n do writeln(wor[i]);

end.

var

n,t,i,j:integer;

wor:array [1..1000] of string;

dic,temp:string;

function biggerstr(a,b:string):boolean;

function biggercha(a,b:char):boolean;

begin

if pos(a,dic)>pos(b,dic) then biggercha:=true else biggercha:=false;

end;

var

i:integer;

begin

i:=0;

repeat

i:=i+1;

until (a[i]b[i]) or (i=length(a)) or (i=length(b));

if i=length(a) then biggerstr:=false;

if i=length(b) then biggerstr:=true;

if a[i]b[i] then biggerstr:=biggercha(a[i],b[i]);

end;

begin

readln(dic);

readln(n);

for i:=1 to n do readln(wor[i]);

readln(t);

for i:=1 to n do for j:=i+1 to n do if biggerstr(wor[i],wor[j]) then

begin

temp:=wor[i];

wor[i]:=wor[j];

wor[j]:=temp;

end;

if t=0 then for i:=n downto 1 do writeln(wor[i]);

if t=1 then for i:=1 to n do writeln(wor[i]);

end.

冒泡秒杀...

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

for i:=1 to 26 do

read(b[i]);

for i:=1 to 26 do

a[b[i]]:=chr(96+i);

readln;

readln(n);

for i:=1 to n do

begin

readln(c[i]);

d[i]:=c[i];

for j:=1 to length(c[i]) do

c[i][j]:=a[c[i][j]];

end;

快排秒杀...

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

用一个数组记录字母的顺序（下标为字母'a'..'z'）

var h:array['a'..'z']of integer;

a:array[1..1000]of string;

n,i,o:integer;

z,zz:string;

c:char;

function sm(x,y:string):boolean;

var i,l:integer;

begin

if length(x)

输入字典序a[i](i:=1~26)后，记录一个数组b(s='a'...'z')，使b=i,a[i]=s，把单词里的每个字母t换成char(ord('a')-1+b[t])。

说白了就是把字母改变，让笨笨的字典序成为电脑的'a'...'z'字典序，然后直接排序

举例：笨笨的字典序：dcba（只举三个）

单词：add,bca

转变成：daa,cba(a->d,b->c,c->b,d->a)这样电脑就可以直接比较，排序得到的顺序与按笨笨的字典序排出来一样

当然，记录原来的单词，在排序时与改变后的单词同时移动

没想到会一次AC

以前我遇到这种题都会害怕的.....

泡泡排序就够了

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

var i,j,k,m,n:longint;

st,s:string;

a:array[1..1000] of string;

function now(ch:char):integer;

var i1,j1,k1:longint;

begin

for i1:=1 to 26 do if st[i1]=ch then now:=i1;

end;

function check:boolean;

var i1,j1,k1:longint;

boo:boolean;

begin

boo:=true;

i1:=0;

if a[i]=a[j] then exit(false);

while boo do begin

inc(i1);

if (i1>length(a[i])) and(i1now(a[j][i1]) then exit(true) else if now(a[i][i1])

编译通过...

├ 测试数据 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

ss,s:array[1..1000]of ansistring;

c:array['a'..'z']of longint;

m,n,o,p,q:longint;

i:char;

procedure pai(l,r:longint);

var

mid,tt:ansistring;

i,j:longint;

begin

i:=l;

j:=r;

mid:=s[(i+j)div 2];

repeat

while s[i]mid do dec(j);

if ij;

if i

为了方便起见，建个hash表f(x)

f(字母表的第i个字母) = i

然后判字典序的时候改为比较f(s[i])

其他的工作和普通的排序一样。

qsort 判断大小自己写

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

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

输入一个比一次

#include

#include

char dic[27];

int chrcmp(char ch1,char ch2){

if(ch1==ch2)return 0;

if(ch1==0)return 1;

if(ch2==0)return -1;

for(int i=0;i

这道题按范围似乎快排+暴力比较是过得了的……

有点懒得写trie了。我先试试

update: 确实快排可以过。

晕啊 WA了4次

第5次重打一遍就秒了

不要用快排，因为数据规模小，用快排反而慢。

不要用pos，这玩意看着不好看（太长），效率也不好

第101个过的

题目的通过率降了3个千分点……