I shocked... when I input/output like this
...
scanf("%I64d%I64d%I64d%I64d%I64d%I64d%I64d%I64d", &x01, &y01, &x1, &y1, &x02, &y02, &x2, &y2);
...
printf("%I64d", intersect);
...

I got WA#17, and when I instead of that wrote this
...
cin>>x01>>y01>>x1>>y1>>x02>>y02>>x2>>y2;
...
cout<<intersect;
...

I got AC! Why? Doesn't the "scanf" correctly read __int64 numbers?
P.S. Sorry for my english.

I also got WA#17
I don't know what to do
Give me some tests please or tell what in my code is wrong

#include <iostream>
using namespace std;

struct Coord
{
    __int64 x;
    __int64 y;
};

bool Sign(__int64 x, __int64 y)
{
    if(x > y)
        return 1;
    return 0;
}

void Sort(Coord* arr)
{
    for(int i = 0; i < 4; i++)
    {
        for(int j = i; j < 4; j++)
        {
            if((arr[j].x < arr[i].x) || (arr[j].x == arr[i].x && arr[j].y > arr[i].y))
            {
                Coord tmp = arr[j];
                arr[j] = arr[i];
                arr[i] = tmp;
            }
        }
    }
}

int main()
{
    Coord crd[4];

    for(int i = 0; i < 4; i++)
    {
        cin >> crd[i].x >> crd[i].y;
    }

    bool sign1 = Sign(crd[0].x, crd[1].x) ^ Sign(crd[0].y, crd[1].y);
    bool sign2 = Sign(crd[2].x, crd[3].x) ^ Sign(crd[2].y, crd[3].y);
    __int64 a = -1, b = -1;

    Coord arr[4];
    for(int i = 0; i < 4; i++)
    {
        arr[i].x = crd[i].x;
        if(i < 2)
            arr[i].y = 0;
        else
            arr[i].y = 1;
        if(i % 2 == 1)
        {
            if(arr[i].x < arr[i-1].x)
            {
                __int64 tmp = arr[i].x;
                arr[i].x = arr[i-1].x;
                arr[i-1].x = tmp;
            }
        }
    }
    Sort(arr);
    if(arr[2].y == arr[0].y || arr[2].y == arr[1].y || arr[2].x == arr[0].x || arr[3].x == arr[1].x)
        a = arr[2].x - arr[1].x;


    for(int i = 0; i < 4; i++)
    {
        arr[i].x = crd[i].y;
        if(i < 2)
            arr[i].y = 0;
        else
            arr[i].y = 1;
        if(i % 2 == 1)
        {
            if(arr[i].x < arr[i-1].x)
            {
                __int64 tmp = arr[i].x;
                arr[i].x = arr[i-1].x;
                arr[i-1].x = tmp;
            }
        }
    }
    Sort(arr);
    if(arr[2].y == arr[0].y || arr[2].y == arr[1].y || arr[2].x == arr[0].x || arr[3].x == arr[1].x)
        b = arr[2].x - arr[1].x;



    if(sign1 == sign2)
    {
        cout << a + b << endl;
    }
    else
    {
        if(a == -1 || b == -1)
            cout << 0 << endl;
        if(a > b)
            cout << a << endl;
        else
            cout << b << endl;
    }

    return 0;
}

  Letter 'l' in "labs" stands for "long" = "int" (not "long long").
  So in the first case two summands are converted from "long long" to "int" and the summation causes overflow.
  In the second and the third cases one of the summands has type "long long" so the sum is in type "long long" too.

Edited by author 12.04.2010 22:11

Try to use __int64

> each street stretches through the whole city either from west to east or from north to south.

Do these directions have any influence?