Algorithm 给定函数的反函数

我有一个函数，有两个输入

x

和

y

，根据某些条件返回

z

（取决于

x

和

y

的值）。类似于下面的伪代码

f(x, y)
    if x < a && y < b
        return z=x+y;
    else if x >= a && x < c && y >= b && y < d
        return z=x-y;
    else x >= c && y >= d
        return z=x*y;

假设

f

非常简单，仅基于几个条件，返回值与一些算术语句一样简单（与上面提供的内容完全类似）。你怎么写

g

？您是否只需存储

f

中的边界和相应的返回值，然后使用给定的

z

在它们之间进行遍历以找到合适的边界？我想看看其他人是如何破解的。注意，

f

也是你自己写的，你对它了如指掌

---

注意：假设返回值在任何时候都是不同的，并且在任何情况下都没有任何重叠

您可以从查看每个条件开始。如果x和y要满足条件的最小值，那么它们的值是多少。例如，如果x和y仅仅分别小于a和b，那么方程x+y能满足z吗。也就是说，x+y将大于z。如果没有，那么就不可能排除任何小于当前x和y的数字。然后可以转到下一个条件，依此类推。如果x和y的值可以满足条件，那么您可以从下边界开始，迭代该范围内的可能值，或者使用代数来解决它

您的职能

double f(double x,double y) // z=f(x,y)
 {
       if ((x<a)&&(y<b))                return x+y;
 else if ((x>=a)&&(x<c)&&(y>=b)&&(y<d)) return x-y;
 else if ((x>=c)&&(y>=d))               return x*y;
                                        return ???;
 }

此外，这3个定义的

x，y

间隔可以给出相同的

z

值

反函数

double f(double x,double y) // z=f(x,y)
 {
       if ((x<a)&&(y<b))                return x+y;
 else if ((x>=a)&&(x<c)&&(y>=b)&&(y<d)) return x-y;
 else if ((x>=c)&&(y>=d))               return x*y;
                                        return ???;
 }

返回

x，y

的间隔不是一个好主意，你可以使用

g（）

a2D函数，比如

x=g2d（y，z）

或者

y=g2d（x，z）

或者返回所有有效

x，y

对的列表，而不是间隔！！！这也可以通过2D

g（）

函数完成

2D

g

功能的示例：

double g2d(double x,double z) // y=g(x,z)
 {
      if (x<a) return z-x;
 else if (x<c) return x-z;
 else          return z/x;
 }

void g(double *x,double *y,int &n,double z) // x[n],y[n]=g(z)   ... x,y should be allocated big enough or use some list/vector template
 {
 double xx;
 const double min =-1e+3;
 const double max =+1e+3;
 const double step=+1e-3;
 n=0; // reset found solution count
 for (xx=min;xx<=max;xx+=step) // go through valid x axis
  {      
  x[n]=xx;
  y[n]=g2d(xx,z);
  // here add check if solution valid and continue if not
  // also can add check for max n to avoid overrun of arrays x[],y[]
  n++; // add new valid solution to list
  }
 }

[notes]

---

所有代码都是C++

为什么它会返回两对（x，y）？这个问题似乎离题了，因为它是关于数学的，从外观上看，f是一个多对一映射。我怀疑它会有少量的反转@RachelGallen在SO中有数学和算法部分和标记@我非常简化了我的问题。这就是为什么我想知道人们是如何为这些类型的问题找到一个通用的解决方案的。我对细节不是很仔细，因为我假设读者会做出一些合理的假设。另外，你的回答只是我所说的另一种详细说明的方式，在我的问题的末尾添加

你是否只需要存储边界和来自f的相应返回值，然后用给定的z在它们之间遍历以找到合适的边界
void g(double *x,double *y,int &n,double z) // x[n],y[n]=g(z)   ... x,y should be allocated big enough or use some list/vector template
 {
 double xx;
 const double min =-1e+3;
 const double max =+1e+3;
 const double step=+1e-3;
 n=0; // reset found solution count
 for (xx=min;xx<=max;xx+=step) // go through valid x axis
  {      
  x[n]=xx;
  y[n]=g2d(xx,z);
  // here add check if solution valid and continue if not
  // also can add check for max n to avoid overrun of arrays x[],y[]
  n++; // add new valid solution to list
  }
 }