OJ Board

[cpp]int seqIndex;
// left to right increase order
for(seqIndex=0;seqIndex<size;seqIndex++){
incOrder[seqIndex]=1;
for(int i=seqIndex-1;i>=0;i--){
if(seq == seq[seqIndex]-1 && incOrder[seqIndex] < incOrder+1){
incOrder[seqIndex]=incOrder+1;
break;
}
if(seq < seq[seqIndex] && incOrder[seqIndex] < incOrder+1){
incOrder[seqIndex]=incOrder+1;
}
}
}
// right to left increase order (namely decrease order)
int max=INT_MIN;
for(seqIndex=size-1;seqIndex>=0;seqIndex--){
decOrder[seqIndex]=1;
for(int i=seqIndex+1;i<size;i++){
if(seq == seq[seqIndex]-1 && decOrder[seqIndex] < decOrder+1){
decOrder[seqIndex]=decOrder+1;
break;
}
if(seq < seq[seqIndex] && decOrder[seqIndex] < decOrder[i]+1){
decOrder[seqIndex]=decOrder[i]+1;
}
}
// find max value.
if(decOrder[seqIndex]==incOrder[seqIndex] && max<decOrder[seqIndex]){
max=decOrder[seqIndex];
}
}[/cpp]


It's my core code. But it is O(n^2). So I can't escape from TLE.

I have to think more...

I'm opening a new thread, because the previous one dealt mainly with runtime. That is not my point, runtime is fine, but getting tons of WA.
So either I'm stupid (which of course I am...) or I don't understand the question. Am I right that:

1. The wavio sequence can be the whole sequence, so WAVIO({1,2,1})={1,2,1}, with length 3?

2. The length of the sequence is always odd, so WAVIO({1,2,3,1})={1,2,1} (or {1,3,1}) with length 3?

3. If there's only one element, the length is always one (WAVIO({1}={1})?

4. There are no empty sequences to process (N>0, as given in the description)?

5. All numbers fit into an SINT32 (no long long or int64 needed)?

Please help me. I've hand checked hundreds of randomly generated sequences, and I cannot find my error. Can anyone publish some tricky cases?

-little joey

according to what i know, all of your assumtion are correct. i think there is no trickies input. i just run LIS twice, and got AC.

regards
titid

Thank you!
Knowing that my assumptions were right, I could closer examine my algorithm.
I found an off by one error in my binary search , but that only became manifest after scanning some 100 numbers in the sequence...
The most elementary algorithms are the hardest to code error free.
Programming in Pascal has curses and blessings: there are no built in functions for routine tasks , but you C/C++ guys will never know what binary search is realy all about !

I run twice Longest Increasing sequence during O(n * log(n)),
but get WA!
Is there any tricks? Or where is my mistake?

program p10534;
const
max = 10010;
var
n,i,j,mx,counter:integer;
b,e,middle:integer;
left,right,m,l,r:array[1..max] of integer;
begin
while not eof do
begin
readln(n);
FillChar(m,SizeOf(m),0);
for i:=1 to n do read(m[i]); readln;

counter := 2;
l[1] := m[1]; left[1] := 1;
for i:=2 to n do
begin
if m[i] > l[counter-1] then
begin
l[counter] := m[i];
left[i] := counter;
Inc(counter);
continue;
end;

b := 0; e := counter - 1;
while (e - b > 1) do
begin
middle := (b + e) div 2;
if m[i] > l[middle] then b := middle
else e := middle;
end;
l[e] := m[i];
left[i] := e;
end;

counter := n-1;
r[n] := m[n]; right[n] := 1;
for i:=n-1 downto 1 do
begin
if m[i] > r[counter+1] then
begin
r[counter] := m[i];
right[i] := n - counter + 1;
Dec(counter);
continue;
end;

b := counter+1; e := n+1;
while (e - b > 1) do
begin
middle := (b + e) div 2;
if m[i] > r[middle] then e := middle
else b := middle;
end;
r[b] := m[i];
right[i] := n + 1 - b;
end;


mx := 0;
for i:=1 to n do
if ((left[i] = right[i]) and (left[i] > mx)) then mx := left[i];
writeln(2*mx-1);
end;
end.

I did a O(n*m) where m is the largest increasing subsequence size. And it passed time okay, but I'm getting WA.

Is there any trick input ? Could somebody throw in some INPUTs with correct OUTPUTs ?

Thanks !

Ok, let me start with the INPUT / OUTPUT for this problem.

For the following Input :

My *WA* program answers the following :

What sould be the " accepted " output ?

thanks ![/code]

Output from AC program: Wish you good luck, and get AC soon!

Fixed and ACCEPTED =P

thanks junjieliang !!!!!!!!!

but , this brought some curiosity to me ... the only thing I changed was :

j = (min(f, t)*2) - 1;

into :

j = min(f, t);

and after all calculations ..

j = j*2-1

what possible difference can it make ?

I don't know what your min function returns, but assuming j's an int .. if min returns like a short, the original might overflow while doing the calculations, where as the second one won't .. just a hunch .. i dunno what else it could be though

Could be that also, but the values in question are around 10 (like 7 and 5). My min function is the following :

You must have a () around your whole define:

#define min(a,b) ((a)<(b)?(a):(b))

Otherwise it will expand to (a)<(b)?(a):(b)*2-1
which is evaluated a<b?a:(b*2-1)

The () around (a)<(b) ain't necessary

junjieliang wrote:I solved this problem with an O(N^2) algo, but I believe that only happens in the worst case (or maybe not, if I did a better analysis of the complexity).

Another way would be to use the O(n log n) algo for LIS, which is just modifying a loop in the original algorithm to use binary search. Does anybody need the code? It can be obtained from the USACO training gateway, or I can post it here...

Please post it here or pm to me.
Thanks very much!

try this input:
20
13 7 5 7 6 7 2 7 3 20 9 9 15 20 9 10 12 12 4 13
The answer is 7.

I think you should add something before

l[e] := m;
left := e;

My solution (in C) is to modify like this:

if(m<=l)
{
l=m;
left=b;
}
else
{
l[e] = m;
left = e;
}

I have read all the posts about 10534, and used double LIS of O(nlogn) version, the bi_search also have been tested. But it still got WA, can someone tell me what's wrong with my code?
[cpp]
code deleted
[/cpp]