PAT 1065 A+B and C (64bit) (20)

1065. A+B and C (64bit) (20)

时间限制 100 ms

内存限制 65536 kB

代码长度限制 16000 B

判题程序 Standard

作者 HOU, Qiming

Given three integers A, B and C in [-2⁶³, 2⁶³], you are supposed to tell whether A+B > C.

Input Specification:

The first line of the input gives the positive number of test cases, T (<=10). Then T test cases follow, each consists of a single line containing three integers A, B and C, separated by single spaces.

Output Specification:

For each test case, output in one line "Case #X: true" if A+B>C, or "Case #X: false" otherwise, where X is the case number (starting from 1).

Sample Input:

3
1 2 3
2 3 4
9223372036854775807 -9223372036854775808 0

Sample Output:

Case #1: false
Case #2: true
Case #3: false

 

思路及分析：

此题简单来说就是一个简单的寻味 a+b>c 是否成立的问题，唯一的坑点就是范围上线是 2^63 超过了计算机 long long 或  __int64 的上限( 2^63-1 )。所以无论在输入方面和计算方面都产生了一些障碍。

 

本弱的基础思想是用字符串读入所有数据，然后判断是否上溢出（这里指的是 long long 的上溢出，下文中亦如此），如果上溢出则进行特殊处理，否则正常处理。下面略具体的说下思路：（思路有可能会显得有些乱，但是绝对正确）

首先如果 a 和 b 都没有上溢出，那么求 a+b。如果上溢出必然 true，如果是下溢出必然 false，如果没有溢出则判断 c 是否上溢出，如果 c 上溢出则必然 false，否则正常比较处理即可。

如果 a 和 b 中有一个出现了上溢出，首先将上溢出的那一项挪至 a，方便后续处理。然后判断 c 是否上溢出，如果 c 上溢出则通过 b 的符号即可知 a+b>c 是否成立。如果 c 没有上溢出则通过 a*b 的符号判断，如果异号必然 a+b<=c，否则计算下 a+b 即可（具体小技巧看程序）。

另：本弱处理的不是特别优美，导致我需要单独特殊处理下 a 和 b 都是 -2^63 的情况。

 

特别注意！！！！！！！！！！！！！

 

网上很多很多的解题报告都是错的！！！！错在 2^63 + 2^63 > 1 这组数据上，然而该题的官方数据中没有此类数据，导致许多错误的程序都可以通过。

 

提供一组数据：

8
1 2 3
2 3 4
10 -10 0
101 -100 0
9223372036854775807 -9223372036854775808 0
9223372036854775808 9223372036854775808 1
9223372036854775808 -9223372036854775808 1
-9223372036854775808 -9223372036854775808 -1

ans:

Case #1: false
Case #2: true
Case #3: false
Case #4: true
Case #5: false
Case #6: true
Case #7: false
Case #8: false

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL INF = 0x7FFFFFFFFFFFFFFF;
const int MAXN = 30;
const char str[MAXN] = "9223372036854775808";
const char st[MAXN] = "-9223372036854775808";

char a[MAXN], b[MAXN], c[MAXN];
LL na, nb, nc, nd;

int check( LL x ) { return x > 0 ? 1 : x < 0 ? -1 : 0; }

int main() {
    int t, cnt = 0;
    int ta, tb, tc, td;
    bool fa, fb, fc;
    scanf( "%d", &t );
    while( t-- ) {
        printf( "Case #%d: ", ++cnt );
        scanf( "%s%s%s", a, b, c );
        if( !strcmp( a, st ) && !strcmp( b, st ) ) {
            puts( "false" ); continue;
        }
        fa = !strcmp( a, str );
        fb = !strcmp( b, str );
        fc = !strcmp( c, str );
        if( !fa && !fb ) {
            sscanf( a, "%I64d", &na ); ta = check( na );
            sscanf( b, "%I64d", &nb ); tb = check( nb );
            if( !fc ) { sscanf( c, "%I64d", &nc ); tc = check( nc ); }
            nd = na + nb; td = check( nd );
            if( ( ta * tb ) > 0 && ( ta * td ) < 0 ) {
                if( ta > 0 ) puts( "true" );
                else puts( "false" );
            } else {
                if( fc ) puts( "false" );
                else puts( nd > nc ? "true" : "false" );
            }
        } else {
            ta = a[0] == '-' ? -1 : a[0] == '0' ? 0 : 1;
            tb = b[0] == '-' ? -1 : b[0] == '0' ? 0 : 1;
            if( fc ) {
                if( !fa ) { swap( a, b ); swap( ta, tb ); swap( fa, fb ); }
                if( tb <= 0 ) puts( "false" );
                else puts( "true" );
            } else {
                sscanf( c, "%I64d", &nc ); tc = check( nc );
                if( ta ^ tb ) {
                    if( !fa ) { swap( a, b ); swap( ta, tb ); swap( fa, fb ); }
                    sscanf( b, "%I64d", &nb );
                    nd = INF + nb + 1;
                    puts( nd > nc ? "true" : "false" );
                } else puts( "true" );
            }
        }
    }
    return 0;
}