oj：平方差数（||）（ hnust）

题目描述

定义: 如果一个正整数能表示为两个正整数 m, n 的平方差（m-n>1),则称这个正整数为 "平方差数"。 例如, 第1个平方差数是8=32-12，第2个平方差数是12=42-22。 给定正整数a和b，问区间[a,b]内有多少个平方差数？

输入

两个由空格分开的正整数a和b。（1<=a<=b<=1000000000, b-a<=10000000)

输出

输出区间[a,b]中平方差数的个数。

样例输入 Copy

1 12

样例输出 Copy

2

代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdbool.h>

void sieve(int limit, bool is_prime[]) {
    for (int i = 2; i <= limit; i++) {
        is_prime[i] = true;
    }
    is_prime[0] = is_prime[1] = false;
    for (int i = 2; i * i <= limit; i++) {
        if (is_prime[i]) {
            for (int j = i * i; j <= limit; j += i) {
                is_prime[j] = false;
            }
        }
    }
}

int sieve_list(int limit, int primes[]) {
    bool *is_prime = (bool *)malloc((limit + 1) * sizeof(bool));
    sieve(limit, is_prime);
    int count = 0;
    for (int i = 2; i <= limit; i++) {
        if (is_prime[i]) {
            primes[count++] = i;
        }
    }
    free(is_prime);
    return count;
}

int count_odd_primes_in_interval(long long a, long long b) {
    if (a > b) return 0;
    int sqrt_b = (int)sqrt(b);
    int primes_size = sqrt_b + 1;
    int *primes = (int *)malloc(primes_size * sizeof(int));
    int num_primes = sieve_list(sqrt_b, primes);

    int segment_size = b - a + 1;
    bool *is_prime_segment = (bool *)malloc(segment_size * sizeof(bool));
    for (int i = 0; i < segment_size; i++) {
        is_prime_segment[i] = true;
    }

    for (int i = 0; i < num_primes; i++) {
        int p = primes[i];
        long long start = (a + p - 1) / p * p;
        start = start < p * 2 ? p * 2 : start;
        for (long long j = start; j <= b; j += p) {
            is_prime_segment[j - a] = false;
        }
    }

    if (a <= 1 && 1 <= b) {
        is_prime_segment[1 - a] = false;
    }

    int count = 0;
    long long start_x = a % 2 == 1 ? a : a + 1;
    for (long long x = start_x; x <= b; x += 2) {
        if (x < 2) continue;
        if (is_prime_segment[x - a]) {
            count++;
        }
    }

    free(primes);
    free(is_prime_segment);
    return count;
}

int count_odd_prime_squares(long long a, long long b) {
    long long sqrt_a = (long long)ceil(sqrt(a));
    long long sqrt_b = (long long)floor(sqrt(b));
    if (sqrt_a > sqrt_b) return 0;

    int high_p = (int)sqrt_b;
    bool *is_prime = (bool *)malloc((high_p + 1) * sizeof(bool));
    sieve(high_p, is_prime);

    int count = 0;
    for (long long p = sqrt_a; p <= sqrt_b; p++) {
        if (p < 2) continue;
        if (is_prime[p] && p % 2 == 1) {
            count++;
        }
    }

    free(is_prime);
    return count;
}

int main() {
    long long a, b;
    scanf("%lld %lld", &a, &b);

    long long count_4 = b / 4 - (a - 1) / 4;
    int count_4_less8 = (a <= 4 && 4 <= b) ? 1 : 0;
    long long A = count_4 - count_4_less8;
    if (A < 0) A = 0;

    long long odd_count = ((b + 1) / 2) - (a / 2);

    int odd_prime_count = count_odd_primes_in_interval(a, b);

    int count_1 = (a <= 1 && 1 <= b) ? 1 : 0;
    long long odd_composite_count = odd_count - odd_prime_count - count_1;
    if (odd_composite_count < 0) odd_composite_count = 0;

    int count_p_square = count_odd_prime_squares(a, b);
    long long B = odd_composite_count - count_p_square;
    if (B < 0) B = 0;

    long long total = A + B;
    printf("%lld\n", total);

    return 0;
}

代码较长，但耗时很少。