C++ 仅使用其他两个数字达到目标数字

我有两个数字L和R，L表示左，R表示右。 我必须用L和R得到某个数（F）。 每次我都要从零开始

例如： L:1 R:2 F:3

所以到达F所需的最小步数是3。 答：第一个右，第二个右，第三个左

这样我就需要找到最少的方法来做

My approach:

Quo = F/R;
Remain : F%R;

x*R-Y*L = Remain
==> (x*R - Remain)/L = Y
this equation is break when (x*R - Remain)%L = 0, so we find x and y from the equation above.
So final Steps would be Quo + x(No. of right steps) + y( no. of left steps).

For Above Example :
Quo = 3/2 = 1;
Remain = 3%2 =1;

Y = (x*2 -1)/1
(x*2 -1)%1 is zero for x=1;
Now increase x from zero,

So x is 1, y is 1

Final Ans = Quo (1) + x (1) + y(1) = 3.

我的代码：

#include <iostream>
using namespace  std;

int main()
{
        int F,R,L;
        cin >> F;
        cin >> R;
        cin >> L;

        int remain = F%R;
        int quo = F/R;

        int Right = 0;
        int left = 0;
        int mode = 1;
        while( mode !=0)
        {
            Right++;
         mode = (R*Right - remain)%L;
         left = (R*Right - remain)/L;

        }
        int final = quo + Right + left;
        cout << final;
}

#包括
使用名称空间std；
int main（）
{
int F，R，L；
cin>>F；
cin>>R；
cin>>L；
int剩余=F%R；
int quo=F/R；
int Right=0；
int左=0；
int模式=1；
while（模式！=0）
{
右++；
模式=（R*右-保持）%L；
左=（R*右-保持）/L；
}
int final=quo+右+左；
cout在下面给出的等式中

 x*R - Remain = 0modL
 where R, L and Remain are fixed.

它可以写成

((x*R)mod L - Remain mod L) mod L = 0

如果保持模式L=0，那么x*R应该是L的倍数，这使得x为0modL。
意味着x可以是0，nR，其中n是整数

简单地说，你可以在0和L-1之间尝试x来找到x

因此，循环可以从0运行到L-1，这将保持循环的有限性

请注意，此模式与%。
-1模式L=L-1
不同，而
-1%L=-1

还有另一种方法

x*R mod L - Remain mod L = 0 mod L

导致

x*R mod L = Remain mod L
(x* (R mod L)) mod L = (Remain mod L)

您可以计算L字段中R的倒数（比如
Rinv
），并计算
x=（reserve*Rinv）modL
。
若逆不存在，则表示方程不能满足

注：我不是数学专家。所以，如果有任何错误，请给出您的意见

请参阅：
堆栈溢出用于编程问题。您的程序在哪里？这个问题似乎与主题无关，因为它与逻辑和数学有关。不，这是一个关于算法的非常好的问题。这是一个编程问题。OP-您正确地估计了这个问题，因为需要计算x和x的线性组合y（ax+by，其中a和b是未知的）。如果“步骤”是加法，则需要找到a和b的唯一（如果存在！）值，这两个值都是正的，并且（a+b）是最小值。对于大x，可以使用欧几里德算法更快地解决此问题。请阅读：-4.6是如何与此问题联系在一起的。@JonathanPotter我已添加了我的代码。请建议您是否为上述问题找到一些好的算法。carey可能是它不符合主题，但应该有一个算法。（但是，听起来这是一个C++类的介绍，而不是一个算法类，所以除非你已经了解了EA，这可能是严格的“额外的学分”）计算逆用途-你猜对了，欧几里德算法。直接使用它更快。基本上是相同的方法。逆运算失败，EA将用非单位GCD终止，最后你会做一个额外的乘法运算。但是我不确定C++中是否有一个模块化的反作用实现，就像java中的那样。所以OP无论如何都可能要实现EA。如果你想让我去NITP。不管怎样，我会告诉你，你计算逆的组不一定是一个域