Well, I guess there is some sneaky thing. Someone can give me test 4 please. Thanks

import java.util.Scanner;
public class problem1197 {

    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        int I = in.nextInt();
        int J = in.nextInt();

        if (I == 1) {
            System.out.println(1);
            return;
        }
        if (I == J) {
            System.out.println(I);
            return;
        }
        int deyer[] = new int[100001];
        int idx = 0;
        int min = 10000;
        int mineded = 0;

        for (int i = J; i >= I; i--) {

            for (int j = i / 2; j >= 1; j--) {

                if (i % j == 0) {
                    if (j < min) {
                        min = j;
                        mineded = i;
                        if (j == 1) {
                            System.out.println(i);
                            return;
                        }
                    }

                    break;
                }
            }
        }
        System.out.println(mineded);

    }
}

var a,b,u:longint;
begin readln(a,b);
for u:=1 to b do inc(a);
writeln(a);
end.

AC 0.015s 86k

any good test case, thanks

    abcd
    aaaa

  The answer is obvious.
  Good luck!

import java.util.Scanner;


public class Test {

    public static void main(String[] args) {

Scanner in = new Scanner(System.in);
float b = 0;
float a = in.nextInt();

in.close();


if ( a >= 1) {

    b =  ((a + 1) /2) * a;



    System.out.println((int)b);}

else


{
    b = ((-a + 1) /2) * -a;

System.out.println((int)-b+1);}

}}

Edited by author 28.12.2013 05:22

this is a shape of sample#1: ('B'=Black, '.'=white)
B...B
.B...
..B..

you must count all the streak which not belong to the streak with size more than current streak, therefor the cell's (1,2) & (2,1) & (3,2) must'nt count because they are belong to streak (1,2)->(1,4) & (2,1)->(2,2) & (3,1)->(3,2).

here some test for problem:
//////////////////////////
input:
5 5 2
1 2
3 3

output:
12
//////////////////////////
input:
5 5 4
1 2
5 3
3 1
4 4

output:
12
//////////////////////////
input:
1 1 0

output:
1
//////////////////////////
input:
1 1 1
1 1

output:
0
/////////////////////////
input:
5 5 12
1 2
1 4
2 1
2 3
2 5
3 2
3 4
4 1
4 3
4 5
5 2
5 4

output:
13
//////////////////////////////
I hope can help you.
GOOD LUCK!

My method of making graph connected works nearly by O(N^2). Are there any classic algorithmes for such problem?

I have submit my solution, where I have used the system of disjoint sets. But it has WA 1 :))
What is another way to solve this problem???

type t=record
     x,y:real;
     end;

function dlina(x1,y1,x2,y2:real): real;
begin
 dlina:=sqrt( (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) );
end;


var n,i:integer; x,y,p,cos,r:real; mas:array[1..103] of t;
Begin
readln(n,r);
p:=0;
for i:=1 to n do begin
  readln(mas[i].x,mas[i].y);
  if i>1 then p:=p+dlina(mas[i-1].x,mas[i-1].y,mas[i].x,mas[i].y);
end;
p:=p+dlina(mas[1].x,mas[1].y,mas[n].x,mas[n].y);



p:=p+2*3.14159*r;
writeln(p:1:2);

end.

#include <stdio.h>
int main()
{
   long int k,a,n;
   scanf("%ld",&n);
   while(n--)
   {


   scanf("%ld",&k);
   a=1;
   while(k-a>0)
    k=k-(a++);
   if(k==1)
    printf("1\n");
   else
    printf("0\n");
   }
}






Edited by author 27.12.2013 01:54

if((8*(input) - 7) -> integer)
 cout << 1;
else
 cout << 0;

help!I need the test data.

For this problem,when I used G++,I got AC,but when I used GCC,I got WA so many times.
Why?
#include<stdio.h>
#include<math.h>
int main()
{
     double b[3000000];
     int n=0;
     double temp;
     while(scanf("%lf",&temp)!=EOF)
          b[n++]=sqrt(temp);
     for(int i=n-1;i>=0;i--)
          printf("%.4lf\n",b[i]);
     return 0;
}

Edited by author 26.12.2013 18:14

Taking hints from the forum I am using dynamic programming with bitmasking. But I cannot understand how to memoize the results as the number of subproblems are very large. ie.
2^n * m
that is 2^20 * 120.
I am getting Memory limit exceeded. Is there a better way to define the states of the dp?

It is very easy problem, i think complexity estimation 192 is overestimation.
Very simple search was accepted:

        static bool Solve(IEnumerable<Tuple<int, int>> limitations, int[] proposedOrder)
        {
            foreach (Tuple<int, int> limitation in limitations)
            {
                int less = limitation.Item1;
                int greater = limitation.Item2;
                if (less == greater)
                    return false; // wrong rule

                foreach (int currentSubj in proposedOrder)
                {
                    if (currentSubj == greater)
                        return false; // first is greater, so rule is contradicted
                    if (currentSubj == less)
                        break; // first is smaller, so rule is satisfied, go to next one
                }
            }
            return true; // all rules was satisfied
        }

program ytr;
var n,i,p,d,t,min:longint; a:array[1..100000] of longint; b:boolean;
begin
readln(n); t:=-1; b:=true; p:=1;
for i:=1 to n do
     begin
     read(a[i]); if b then begin min:=a[i]; b:=false; end;
     inc(t);
     if a[i]<min then begin p:=i-t; d:=t; t:=0; min:=a[i]; end;
     if (i=n) and (t>d) then p:=i-t;
     end;
write(p);
end.

I have solved this problem using heap:)
Please, give me advise, how to solve this problem without structures and etc.