求一个多元一次方程的所有解？

Question

有什么方法能高效的求出一个多元一次方程的所有解？
例如 X1+X2+......+X26=51;的所有整数解，要求每个解的范围在0-10之间。

Answer 1

X1+X2+......+Xn=M
Xn的取值[0,M]的整数，定义数组X[n-1]存临时X的值，定义一个迭代函数，参数包括：
n——几元，
M——还剩下可以用来分的整数。
函数提前返回的条件：
M=0，此时余下的X都是0，
或n=1，此时Xn=M。M=51，n=26应该不用多久就可以全迭代出来。

Answer 2

借楼提问：一元n次方程，（楼主的是n=26），如果事先不知道n的数值，n为变量。那么怎么写这个循环呢

Answer 3

借楼请问大佬：一元n次方程，（楼主的是n=26），如果事先不知道n的数值，n为变量。意味着需要n个循环，那么怎么写代码呢

Answer 4

借楼请问大佬：一元n次方程，（楼主的是n=26），如果事先不知道n的数值，n为变量。意味着需要n个循环，那么怎么写代码呢

Answer 5

借楼请问大佬：一元n次方程，（楼主的是n=26），如果事先不知道n的数值，n为变量。意味着需要n个循环，那么怎么写代码呢那就用递归，n次递归

Answer 6

谢谢回复~~之前也想过也只有递归的办法了，可是这个用递归可能难以实现吧，感觉递归也就实现A!这种问题。
例如：
已知四元一次方程x1+2x2+3x3+5x4=6，列出所有可能的自然数解
https://ask.csdn.net/questions/766857
#!/usr/bin/python
for x1 in range(0, 7):
    for x2 in range(0, 7):
        for x3 in range(0, 7):
            for x4 in range(0, 7):
                if x1 + 2 * x2 + 3 * x3 + 5 * x4 == 6:
                    print(str(x1) + " " + str(x2) + " " + str(x3) + " " + str(x4) + " " + str(2**x1+3**x2+4**x3+5**x4));
这个用递归就很难写吧，恳求大神指点

Answer 7

借楼请问大佬：一元n次方程，（楼主的是n=26），如果事先不知道n的数值，n为变量。意味着需要n个循环，那么怎么写代码呢那就用递归，n次递归
谢谢回复~~之前也想过也只有递归的办法了，可是这个用递归可能难以实现吧，感觉递归也就实现A!这种问题。
例如：
已知四元一次方程x1+2x2+3x3+5x4=6，列出所有可能的自然数解
https://ask.csdn.net/questions/766857
#!/usr/bin/python
for x1 in range(0, 7):
    for x2 in range(0, 7):
        for x3 in range(0, 7):
            for x4 in range(0, 7):
                if x1 + 2 * x2 + 3 * x3 + 5 * x4 == 6:
                    print(str(x1) + " " + str(x2) + " " + str(x3) + " " + str(x4) + " " + str(2**x1+3**x2+4**x3+5**x4));
这个用递归就很难写吧，恳求大神指点

Answer 8

        List<string> sl = new List<string>();
        /// <summary>
        /// 多元一次方程
        /// </summary>
        /// <param name="n">元数（多少个未知数）</param>
        /// <param name="y">方程式的值</param>
        /// <param name="cn">当前第几元（未知数）取值</param>
        /// <param name="cy">当前取值后的值</param>
        /// <param name="slist">取值数列</param>
        /// <returns></returns>
        public void GetY(int n,int y,int cn,int cy,string slist)
        {
            string s;
            int i, j, k;
            s = slist;
            for(i=0;i<y;i++)
            {
                k = cy + i;
                s = s + i.ToString() + " ";
                if(k<y && cn<n)
                {
                    GetY(n, y, cn + 1, k, s);
                }
                if(cn==n && k==y)
                {
                    sl.Add(s);
                }
            }
        }

Answer 9

借楼请问大佬：一元n次方程，（楼主的是n=26），如果事先不知道n的数值，n为变量。意味着需要n个循环，那么怎么写代码呢那就用递归，n次递归
谢谢回复~~之前也想过也只有递归的办法了，可是这个用递归可能难以实现吧，感觉递归也就实现A!这种问题。
例如：
已知四元一次方程x1+2x2+3x3+5x4=6，列出所有可能的自然数解
https://ask.csdn.net/questions/766857
#!/usr/bin/python
for x1 in range(0, 7):
    for x2 in range(0, 7):
        for x3 in range(0, 7):
            for x4 in range(0, 7):
                if x1 + 2 * x2 + 3 * x3 + 5 * x4 == 6:
                    print(str(x1) + " " + str(x2) + " " + str(x3) + " " + str(x4) + " " + str(2**x1+3**x2+4**x3+5**x4));
这个用递归就很难写吧，恳求大神指点
def equation(x):
    if x==0:
        print(pow(x,1),'+2*',pow(x,2),'+3*',pow(x,3),'+5*',pow(x,4),'!=6')
        return
    elif (pow(x,1)+2*pow(x,2)+3*pow(x,3)+5*pow(x,4))==6:
        print(pow(x,1),'+2*',pow(x,2),'+3*',pow(x,3),'+5*',pow(x,4),'=6')
    else:
        print(pow(x,1),'+2*',pow(x,2),'+3*',pow(x,3),'+5*',pow(x,4),'!=6')
        equation((x-1))i=6
equation(int(i))
"""
输出结果:
6 +2* 36 +3* 216 +5* 1296 !=6
5 +2* 25 +3* 125 +5* 625 !=6
4 +2* 16 +3* 64 +5* 256 !=6
3 +2* 9 +3* 27 +5* 81 !=6
2 +2* 4 +3* 8 +5* 16 !=6
1 +2* 1 +3* 1 +5* 1 !=6
0 +2* 0 +3* 0 +5* 0 !=6
"""

Answer 10

先说明，这段程序是用枚举的方式求解，所以非常耗时！    internal class Cacu
    {
        //a1X1+a2X2+......+anXn=M;
        //a1到an为各元系数        /// <summary>
        /// 方程的解的列表
        /// </summary>
        /// <param name="iRatios">各元系数an</param>
        /// <param name="iM">总和</param>
        /// <param name="iXLower">各元的下限</param>
        /// <param name="iXUpper">各元的上限</param>
        internal System.Collections.Generic.List<int[]> CacuIt(int[] iRatios, int iM, int iXLower, int iXUpper)
        {
            System.Collections.Generic.List<int[]> lAnswers = new List<int[]>();
            if (iXLower * iRatios.Length <= iM)//有解
            {
                int[] iXs = new int[iRatios.Length];
                for (int I = 0; I < iXs.Length; I++) iXs[I] = iXLower;
                bool blNotEnd = true;
                while (blNotEnd)
                {
                    if (GetCacuState(iRatios, iXs, iM))
                    {
                        int[] iXt = new int[iRatios.Length];
                        for (int I = 0; I < iXt.Length; I++) iXt[I] = iXs[I];
                        lAnswers.Add(iXt);
                    }
                    int iIndex = 0;
                    bool blOverflow = true;
                    while (blOverflow && iIndex < iXs.Length)
                    {
                        int iT = iXs[iIndex] + 1;
                        if (iT > iXUpper)
                        {
                            iXs[iIndex] = iXLower;
                            iIndex++;
                        }
                        else
                        {
                            iXs[iIndex] = iT;
                            blOverflow = false;
                        }
                    }
                    blNotEnd = iIndex < iXs.Length;
                }
            }
            return lAnswers;
        }
                /// <summary>
        /// 算下是不是解
        /// </summary>
        /// <param name="iRatios">系数表</param>
        /// <param name="iXs">当前解</param>
        /// <param name="iM">和</param>
        /// <returns>计算结果</returns>
        internal bool GetCacuState(int[] iRatios, int[] iXs, int iM)
        {
            int iSum = 0;
            for (int I = 0; I < iRatios.Length; I++)
                iSum += iRatios[I] * iXs[I];            //if (iSum == iM)
            //{
            //    for (int I = 0; I < iXs.Length; I++)
            //        Console.Write(string.Format("{0}\t", iXs[I]));
            //    Console.WriteLine();
            //}            return iSum == iM;
        }
    }