Algorithm 开发算法

我在大学里参加了一个编程比赛。除了这个问题，我解决了所有的问题。现在我在练习这个问题来提高我的技能。但我搞不懂算法。如果有任何算法存在，请更新我。或者存在任何类似的算法，那么请告诉我，我将根据这个问题对其进行更改

这就是我想做的

• 输入的第一行是两点之间的距离
• 之后，每个后续行都包含一对数字，指示电缆的长度和数量。这些电缆用于连接两点
• 输入被0终止

输出：

• 输出应包含一个整数，表示建造所需索道长度所可能的最小接头数。如果没有解决方案，则打印“没有解决方案”

样本输入

444
16 2
3 2
2 2
30 3
50 10
45 12
8 12
0 0

10

样本输出

444
16 2
3 2
2 2
30 3
50 10
45 12
8 12
0 0

10

---

谢谢各位。我从“完美子集和”问题中找到了一个解决方案，然后对它做了一些修改。这是密码

#include <bits/stdc++.h>
using namespace std;

bool dp[100][100];
int sizeOfJoints = -1;
void display(const vector<int>& v)
{
    if (sizeOfJoints == -1)
    {
        sizeOfJoints = v.size() - 1;
    }

    else if (v.size()< sizeOfJoints)
    {
        sizeOfJoints = v.size() - 1;
    }
}

// A recursive function to print all subsets with the
// help of dp[][]. Vector p[] stores current subset.
void printSubsetsRec(int arr[], int i, int sum, vector<int>& p)
{

    // If sum becomes 0
    if (sum == 0)
    {
        display(p);
        return;
    }

    if(i<=0 || sum<0)
        return;

    // If given sum can be achieved after ignoring
    // current element.
    if (dp[i-1][sum])
    {
        // Create a new vector to store path
        //vector<int> b = p;
        printSubsetsRec(arr, i-1, sum, p);
    }

    // If given sum can be achieved after considering
    // current element.
    if (sum >= arr[i-1] && dp[i-1][sum-arr[i-1]])
    {
        p.push_back(arr[i-1]);
        printSubsetsRec(arr, i-1, sum-arr[i-1], p);
        p.pop_back();
    }
}

// all subsets of arr[0..n-1] with sum 0.
void printAllSubsets(int arr[], int n, int sum)
{
    if (n == 0 || sum < 0)
        return;

    // If sum is 0, then answer is true
    for (int i = 0; i <= n; i++)
        dp[i][0] = true;

    // If sum is not 0 and set is empty, then answer is false
    for (int i = 1; i <= sum; i++)
        dp[0][i] = false;

    // Fill the subset table in botton up manner
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= sum; j++)
        {
            if(j<arr[i-1])
                dp[i][j] = dp[i-1][j];
            if (j >= arr[i-1])
                dp[i][j] = dp[i-1][j] ||
                           dp[i - 1][j-arr[i-1]];
        }
    }

    if (dp[n][sum] == false)
    {

        return;
    }

    // Now recursively traverse dp[][] to find all
    // paths from dp[n-1][sum]
    vector<int> p;
    printSubsetsRec(arr, n, sum, p);
}

// Driver code
int main()
{



    int input[2000];
    int inputIndex = 0;
    int i = 0;
    int distance = 0;

    cout<< "Enter Input: " <<endl;
    cin>> distance;
    while(true)
    {
        int temp1 = 0;
        int temp2 = 0;
        cin>> temp1;
        cin>> temp2;
        if (temp1 == 0 && temp2 == 0)
        {
            break;
        }

        for (i = 0; i < temp2; i++)
            input[inputIndex++] = temp1;
    }
    cout<< "Processing output. Please wait: " <<endl;
    printAllSubsets(input, inputIndex, distance);
    if(sizeOfJoints != -1)
        cout<<sizeOfJoints;
    else
        cout<<"No Solution Possible";
    return 0;
}

#包括
使用名称空间std；
bool-dp[100][100]；
int sizeOfJoints=-1；
无效显示（常量向量和v）
{
if（sizeOfJoints==-1）
{
sizeOfJoints=v.size（）-1；
}
否则如果（v.size（）如果这个问题更适合，你可以用动态规划或网络流来解决。前者更能直观地处理每条电缆的最大数量，我会参考背包问题。（目标是444，“分支值”是[sum，nb cable take]，并将最大重量应用于每种电缆类型，而不是所取电缆的总nb（“通常”是这样做的）。我将使用9个50长度的电缆，在8个接头周围打结，以消除应变：最好明确说明需要精确匹配的长度总和。