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

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

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

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

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

    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）或之后的第一步（因为该行与导致它的行不同）时发生。从目前为止，算法将类似于：

根据需要对高度进行排序（O（NlogN））
初始化你的4个和（M（k）中的两个和M（k + 1）中引入的两个额外的和）（O（N））
迭代你的高度（O（N））找到最小值：

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

- 通过改变i值增加k，并查看这是否代表新的最小值
打印出答案。

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

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

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

Answer 3

我最近遇到了一个类似的问题，不同的是，在我的问题中，只能在建筑物中添加地板，你无法将其删除。但这个想法应该是相似的。请随时给我任何意见或问题。

我认为解决这个问题的一个好方法是：首先对输入进行排序，通常可以使用语言内置的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 question

如何找到最低成本？

3 个答案: