主页 / 问题 / 1184453
Accepted
A_Hatake
Asked:2020-09-30 23:15:01 +0800 CST2020-09-30 23:15:01 +0800 CST

区间内的级数

  • 772

该文件包含三个整数𝐿、𝑅和𝐾。需要 找到在 𝐿 到 𝑅 范围内恰好具有 𝐾 元素的递增等差数列数。 在这个问题中，我们只需要考虑所有元素都是整数的级数。人们相信算术级数有第一个元素，但没有最后一个元素：它是无限的。如果两个进程以不同的元素开始，那么它们必须被认为是不同的。我一直在为代码苦苦挣扎，但结果证明是某种废话......请建议可以做什么/更正：)

#include<stdio.h>
#include<math.h>
int main(){
    int L, R, K, N, i, a, b;
    N=0;
    scanf("%d %d %d", &L, &R, &K);
    if(K==1){
        N=R-L;
    }
    else if (K>1){
        b=ceil((R-L)/(K-1));
        for(i=0; i<=(R-L); i+=b){
            if((i>=L)&&((i+(K-1)*b)<L))
                N++;
        }
        
        
    }
    printf("%d", N);
}
c

4 个回答

  1. 没有答案！但我不能发表评论:(

    好吧，让我们想想。那么什么是进步呢？这些是数字

    a, a+b, a+2b ... a+(K-1)b ...

    （这里正好显示了 K 个成员）任务施加了哪些条件？第一个和最后一个元素必须在范围内，第一个之前和最后一个元素之后必须在范围外。

    那些。

    a >= L
a +(K-1)b <= R
a-b < L
a+Kb > R
b > 0

    现在考虑如何找到所有可能的整数解，或者至少计算有多少......

    顺便说一下，为了简单起见，在不改变一般性的情况下，我们可以假设我们正在寻找一个从 0 到 RL 范围内的量。

    从上面的方程，我们得到

    (R-L)/(K-1) >= b > (R-L)/(K+1)

    出色地

    0 <= a <= R-L-(K-1)*b
a > R - K*b

    如此随手

    int Count(int L, int R, int K)
{
    R-=L;
    int count = 0;
    for(int b = R/(K-1); b > R/(K+1); --b)
    {
        int a = R-K*b;
        if (a < 0) a = 0;
        int aa = R - (K-1)*b;
        if (aa-a > 0) count += aa-a;
    }
    return count;
}

    试试看，也许你没有考虑到...

    • 4
  2. Best Answer

    简而言之，这是正确的解决方案

    #include <stdio.h>
int main()
{
int L, R, K, i, d, j, k, a1, a2;
scanf ("%d %d %d", &L, &R, &K);
a1=a2=d=k=0;
d=R-L;
for (j=1; j<=d; j++)
{
    for (i=L; i<R; i++)
    {
     a1 = i+j*(K-1);
     a2 = i+j*K;
     if ((a1<=R) && (a2>R) )
     k=k+1;
    }
}
printf ("%d", k);
    return 0;
}
    • 1

  3. 首先，不要

    如果两个进程以不同的元素开始，那么它们必须被认为是不同的。

    如果它们开始的这些不同元素是互质的。

    否则，如果至少有一个级数，就会立即有无穷多个，因为：

    a, a + b, a + 2b, ...
a - b, a, a + b, a + 2b, ...
a - 2b, a - b, a, a + b, a + 2b, ...
⋮

    “通过”相同的元素。

    其次，@Harry 显然正确地写了所有内容。我得到它是这样的：

    int Count(int L, int R, int K)
{
    R -= L;
    int count = 0;
    for(int b = R / (K - 1); R / b < K + 1; --b)
    {
        if (R / b < K)
            count += 1 + R % b; // учитываем прогрессию + её все возможные "сдвиги"
        else
            // максимально сдвинуть прогрессию можно на b - 1 (иначе в диапазон залезет элемент слева)
            // минимально прогрессию необходимо сдвинуть на R % b + 1, чтобы сдвинуть K + 1 'ый элемент за правую границу диапазона
            // итого, b - 1 - (R % b + 1) сдвигов
            // так как включительно, +1
            count += b - 1 - (R % b + 1) + 1;
    }
    return count;
}
    • 0

  4. 考虑到现在的情况，感谢评论：

    int Count(int L, int R, int K)
{
    R -= L;
    int count = 0;
    while (R > 0)
    {
        count += R / (K - 1) - R / K;
        --R;
    }
    return count;
}
    • 0

相关问题