在给定的约束条件下交替移动加权秤

给定一个权重尺度和一组不同的正权重，其中每个权重的供应量都是无限的。我们的任务是将砝码一个一个地放在秤的左右秤盘上，使秤盘移动到放置砝码的那一侧，即每次秤盘移动到另一侧。

我们得到另一个整数“步数”，即我们需要执行此操作的时间。

另一个限制是我们不能连续放置相同的重量，即如果重量 w 被取走，那么在下一步将重量放在对面的平底锅上时，我们不能再取 w。

例子：

Let weight array is [7, 11]  and steps = 3 
then 7, 11, 7 is the sequence in which 
weights should be kept in order to move
scale alternatively.

Let another weight array is [2, 3, 5, 6] 
and steps = 10 then, 3, 2, 3, 5, 6, 5, 3, 
2, 3 is the sequence in which weights should
be kept in order to move scale alternatively.

这个问题可以通过在尺度状态之间做 DFS 来解决。

我们在各种 DFS 状态之间进行遍历以获得解决方案，其中每个 DFS 状态将对应于左右平移之间的实际差值和当前步数。
我们不存储两个平底锅的重量，而是只存储差值残差值，并且每次选择的重量值都应该大于这个差值，并且不应该等于之前选择的重量值。
如果是，那么我们用新的差值和多一步递归调用 DFS 方法。

请参阅下面的代码以更好地理解，

C++

// C++ program to print weights for alternating
// the weighting scale
#include 
using namespace std;
  
// DFS method to traverse among states of weighting scales
bool dfs(int residue, int curStep, int wt[], int arr[],
         int N, int steps)
{
    // If we reach to more than required steps,
    // return true
    if (curStep > steps)
        return true;
  
    // Try all possible weights and choose one which
    // returns 1 afterwards
    for (int i = 0; i < N; i++)
    {
        /* Try this weight only if it is greater than
           current residueand not same as previous chosen
           weight */
        if (arr[i] > residue && arr[i] != wt[curStep - 1])
        {
            // assign this weight to array and recur for
            // next state
            wt[curStep] = arr[i];
            if (dfs(arr[i] - residue, curStep + 1, wt,
                    arr, N, steps))
                return true;
        }
    }
  
    //    if any weight is not possible, return false
    return false;
}
  
// method prints weights for alternating scale and if
// not possible prints 'not possible'
void printWeightsOnScale(int arr[], int N, int steps)
{
    int wt[steps];
  
    // call dfs with current residue as 0 and current
    // steps as 0
    if (dfs(0, 0, wt, arr, N, steps))
    {
        for (int i = 0; i < steps; i++)
            cout << wt[i] << " ";
        cout << endl;
    }
    else
        cout << "Not possible\n";
}
  
//    Driver code to test above methods
int main()
{
    int arr[] = {2, 3, 5, 6};
    int N = sizeof(arr) / sizeof(int);
  
    int steps = 10;
    printWeightsOnScale(arr, N, steps);
    return 0;
}

Java

// Java program to print weights for alternating 
// the weighting scale
class GFG 
{
  
    // DFS method to traverse among 
    // states of weighting scales
    static boolean dfs(int residue, int curStep, 
                       int[] wt, int[] arr,
                       int N, int steps) 
    {
  
        // If we reach to more than required steps,
        // return true
        if (curStep >= steps)
            return true;
  
        // Try all possible weights and 
        // choose one which returns 1 afterwards
        for (int i = 0; i < N; i++) 
        {
  
            /*
            * Try this weight only if it is 
            * greater than current residue 
            * and not same as previous chosen weight
            */
            if (curStep - 1 < 0 || 
               (arr[i] > residue &&
                arr[i] != wt[curStep - 1]))
            {
  
                // assign this weight to array and 
                // recur for next state
                wt[curStep] = arr[i];
                if (dfs(arr[i] - residue, curStep + 1,
                                   wt, arr, N, steps))
                    return true;
            }
        }
  
        // if any weight is not possible,
        // return false
        return false;
    }
  
    // method prints weights for alternating scale 
    // and if not possible prints 'not possible'
    static void printWeightOnScale(int[] arr, 
                                   int N, int steps) 
    {
        int[] wt = new int[steps];
  
        // call dfs with current residue as 0 
        // and current steps as 0
        if (dfs(0, 0, wt, arr, N, steps)) 
        {
            for (int i = 0; i < steps; i++)
                System.out.print(wt[i] + " ");
            System.out.println();
        } 
        else
            System.out.println("Not Possible");
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        int[] arr = { 2, 3, 5, 6 };
        int N = arr.length;
        int steps = 10;
        printWeightOnScale(arr, N, steps);
    }
}
  
// This code is contributed by
// sanjeev2552

Python3

# Python3 program to print weights for  
# alternating the weighting scale 
  
# DFS method to traverse among states 
# of weighting scales 
def dfs(residue, curStep, wt, arr, N, steps):
      
    # If we reach to more than required 
    # steps, return true 
    if (curStep >= steps): 
        return True
  
    # Try all possible weights and choose 
    # one which returns 1 afterwards
    for i in range(N):
          
        # Try this weight only if it is greater 
        # than current residueand not same as 
        # previous chosen weight 
        if (arr[i] > residue and 
            arr[i] != wt[curStep - 1]):
              
            # assign this weight to array and 
            # recur for next state 
            wt[curStep] = arr[i] 
            if (dfs(arr[i] - residue, curStep + 1,
                              wt, arr, N, steps)): 
                return True
  
    # if any weight is not possible,
    # return false 
    return False
  
# method prints weights for alternating scale 
# and if not possible prints 'not possible' 
def printWeightsOnScale(arr, N, steps):
    wt = [0] * (steps) 
  
    # call dfs with current residue as 0 
    # and current steps as 0 
    if (dfs(0, 0, wt, arr, N, steps)):
        for i in range(steps):
            print(wt[i], end = " ")
    else:
        print("Not possible")
  
# Driver Code
if __name__ == '__main__':
  
    arr = [2, 3, 5, 6] 
    N = len(arr)
  
    steps = 10
    printWeightsOnScale(arr, N, steps)
  
# This code is contributed by PranchalK

输出：

2 3 2 3 5 6 5 3 2 3