如何找到最低成本？

Question

我试图解决一个问题，包括找到最低成本。问题可以说是：给定n个建筑物和每个建筑物的高度和成本。现在的任务是找到最低成本，使所有建筑物变得平等每个建筑都可以被认为是一堆垂直的砖块，每块砖都可以加入或移除，并与建筑物相关。

例如：假设有n = 3栋建筑，其高度分别为1,2,3和10,100,1000。

在这里，最低成本将等于120。

以下是问题的链接：

http://www.spoj.pl/problems/KOPC12A/

一个明显的答案是找到与所有建筑物的每个高度相关的成本，然后从它们作为输出给出最小成本。这是O（n ^ 2）。

为了寻找更好的解决方案，我尝试用高度/成本比率的最小值来找到高度。然后所有建筑物必须等于这个高度并计算成本并给出输出。但这给了我错误的答案。 这是我的实现：

根据以下答案，我使用加权平均值更新了我的代码，但仍然没有工作。它给了我错误的答案。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>

using namespace std;

long long fun(int h[],int c[],int optimal_h,int n){
    long long res=0;
    for(int i=0;i<n;i++){
        res += (abs(h[i]-optimal_h))*c[i];
    }   
    return res;
}

int main()
{
    int t;
    cin>>t;
    for(int w=0;w<t;w++){
        int n;
        cin>>n;
        int h[n];
        int c[n];
        int a[n];
        int hh[n];
        for(int i=0;i<n;i++){
            cin>>h[i];
            hh[i]=h[i]; 
        }
        sort(hh,hh+n);
        for(int i=0;i<n;i++)
            cin>>c[i];

        long long w_sum=0;  
        long long cost=0;

        for(int i=0;i<n;i++){
            w_sum += h[i]*c[i];
            cost += c[i];   
        }

        int optimal_h;
        if(cost!=0){
            optimal_h=(int)((double)w_sum/cost + 0.5);
            if(!binary_search(hh,hh+n,optimal_h)){
                int idx=lower_bound(hh,hh+n,optimal_h)-hh;
                int optimal_h1=hh[idx];
                int optimal_h2=hh[idx-1];
                long long res1=fun(h,c,optimal_h1,n);
                long long res2=fun(h,c,optimal_h2,n);
                if(res1<res2)
                    cout<<res1<<"\n";   
                else
                    cout<<res2<<"\n";
            }
            else{
                long long res=fun(h,c,optimal_h,n);
                cout<<res<<"\n";
            }

        }
        else
            cout<<"0\n";
    }

    return 0;
}

不知道怎么解决这个问题？

Answer 1

尝试将高度视为价值和成本作为确定性和重要性。

简单的加权平均值应该在这里诀窍：

costsum=0;
weightedsum=0;
for(int i=0; i<n; ++i)
{
   costsum += c[i];
   weightedsum += h[i]*c[i];
}

optimalheight = round(double(weightedsum)/costsum);

然后计算知道最佳高度的成本：

cost=0;
for(int i=0; i<n; ++i)
   cost += c[i] * abs(h[i] - optimalheight);

Answer 2

我最近遇到了一个类似的问题，不同的是，在我的问题中，它只能添加到建筑物的楼层，你不能删除它。 但这个想法应该是相似的。 请随时给我任何评论或问题。

我认为解决这个问题的一个好方法是：首先对输入进行排序，通常可以使用语言内置的API调用来完成，在Java中，我使用了Arrays.sort（）。 这通常是nLog（n）时间复杂度。 排序后，我们可以在窗口内维护一个大小为m的窗口，我们可以计算每个窗口的最低成本，同时我们将窗口从开始移动到结束，我们计算并更新全局最小成本。 这是实施：

    static long minFloors(long[] buildings, int m) {
        //sort buildings
        Arrays.sort(buildings);
        //maintain a window of size m, compute the minCost of each window, update minCost along the way as the final result
        long minCost = Long.MAX_VALUE;
        for(int i = 0; i <= buildings.length-m; i++){
            long heightToMatch = buildings[i+m-1];
            if(heightToMatch == buildings[i]) return 0;//if the last building's height equals the first one, that means the whole window if of the same size, we can directly return 0
            long thisCost = 0; 
            for(int j = i+m-1; j >= i; j--){
                thisCost += heightToMatch - buildings[j];
            }
            minCost = Math.min(minCost, thisCost);
        }
        return minCost;
    }

我也在这里分享了我的解决方案： Space Rock问题

Answer 3

这是一个解决方案，需要对建筑物高度进行排序（我将假设从最短到最高）。 如果数据已经排序，那么这应该在O（N）时间内运行。

设k为所有建筑物的高度，因此我们希望找到最佳k。 调整所有这些建筑物的成本由下式给出：

    M = Sum(|k-hj|cj, j from 0 to N).

现在因为它们被排序，我们可以找到索引i，使得对于所有j <= i，hj <= k并且对于所有j> i，hj> k。 这意味着我们可以将我们的成本等式重写为：

    M = Sum((k-hj)cj, j = 0 to i) + Sum((hj-k)cj, j = i+1 to N).

现在我们将迭代最短和最高建筑之间的k值，直到我们找到成本最低的那个（我们将进一步看到我们不必检查每一个）计算每次迭代的成本是N操作，所以我们将找到我们的成本函数的递归定义：

    M(k+1) = Sum((k+1-hj)cj, j = 0 to p) + Sum((hj-k-1)cj, j = p+1 to N).

我们可以将“1”项从总和中移出来得到：

    M(k+1) = Sum((k-hj)cj, j = 0 to p) + Sum((hj-k)cj, j = p+1 to N) + Sum(cj, j = 0 to p) - Sum(cj, j = p+1 to N).

现在p是新的i，有两种可能的情况：p = i或p = i + 1。 如果p = i：

    M(k+1) = M(k) + Sum(cj, j = 0 to p) - Sum(cj, j = p+1 to N)

如果p = i + 1

    M(k+1) = M(k) + Sum(cj, j = 0 to p) - Sum(cj, j = p+1 to N) + 2(k+1 - h(i+1))c(i+1).

在p = i的情况下，我们实际上可以直接从M（k）找到M（k + m），因为在每次迭代时我们只添加一个常数项（就k而言是常数），所以如果p = i：

    M(k+m) = M(k) + m(Sum(cj, j = 0 to p) - Sum(cj, j = p+1 to N)).

这意味着我们的函数在迭代之间形成一条直线，其中i是常数。 由于我们对函数从递减到递增感兴趣，因此在所有这些迭代的中间不会发生这种情况。 它只能在i递增（p = i + 1）或之后的第一步（因为该行与导致它的行不同）时发生。 到目前为止，算法将会是这样的：

1. 必要时对高度排序（O（NlogN））
2. 初始化你的4个和（M（k）中的两个和M（k + 1）中引入的两个额外的和）（O（N））

3. 迭代这样的高度（O（N））找到最小值：

   - 将k增加到下一个最高建筑物的高度减去一个（使用M（k + m））并查看这是否代表新的最小值

   - 将k增加1，改变i值，看看这是否代表新的最小值

4. 打印出答案。

还有其他一些可能的优化，我还没有想太多。 显而易见的是，每当我改变时都不会重新计算你的金额。

如果数学很难读，我很抱歉，我是StackOverflow的新手并且没有想出所有可能的格式。

我没有任何代码来支持这一点，所以我希望这已经足够了。