题目

思路和解题方法

这段代码的目标是计算给定点集的最小总移动成本，使得所有点都在同一直线上。它通过计算每个点左边和右边的移动成本，然后在所有可能的分割点中选择最小成本。具体步骤如下：

1. 读取输入的点集，每个点表示为 (y, x)，其中 y 是点的权重，x 是点的位置。
2. 对点集按照 x 坐标进行排序。
3. 计算每个点左边和右边的移动成本。
4. 遍历每个可能的分割点，计算总成本，并记录最小成本。
5. 输出最小成本。

复杂度

        时间复杂度:O(nlogn)

                

时间复杂度: 排序所需的时间复杂度为 O(nlogn)，计算移动成本的过程需要线性时间，因此总体时间复杂度为 O(nlogn)。

        空间复杂度:O(n)

空间复杂度: 程序的空间复杂度主要取决于数组 p[]，pre[]，nex[] 和其他常量，因此为 O(n)。

c++ 代码

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+9;
#define x first
#define y second
typedef long long ll;
pair<int,int>p[N];
ll pre[N],nex[N];
int main() {
    int n;
    cin>>n;
    // 读入点集，每个点的坐标为 (y, x)
    for(int i=1;i<=n;i++)
        cin>>p[i].y>>p[i].x;
    // 按照 x 坐标对点集进行排序
    sort(p+1,p+1+n);
    ll s=0;
    // 计算每个点左边的移动成本
    for(int i=1;i<=n;i++){
        pre[i]=pre[i-1];
        pre[i]+=s*(p[i].x-p[i-1].x);
        s+=p[i].y;
    }
    s=0;
    // 计算每个点右边的移动成本
    for(int i=n;i>=1;i--){
        nex[i]=nex[i+1];
        nex[i]+=s*(p[i+1].x-p[i].x);
        s+=p[i].y;
    }
    ll ans=1e18;
    // 遍历每个可能的分割点，计算总成本，并记录最小成本
    for(int i=1;i<=n;i++){
        ans=min(ans,pre[i]+nex[i]);
    }
    // 输出最小成本
    cout<<ans<<endl;
    return 0;
}

Java 版本（仅供参考）

import java.util.*;

public class Main {
    static final int N = 100009;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        Pair[] p = new Pair[N];
        long[] pre = new long[N];
        long[] nex = new long[N];

        for (int i = 1; i <= n; i++)
            p[i] = new Pair(scanner.nextInt(), scanner.nextInt());

        Arrays.sort(p, 1, n + 1);

        long s = 0;
        for (int i = 1; i <= n; i++) {
            pre[i] = pre[i - 1];
            pre[i] += s * (p[i].x - p[i - 1].x);
            s += p[i].y;
        }
        s = 0;
        for (int i = n; i >= 1; i--) {
            nex[i] = nex[i + 1];
            nex[i] += s * (p[i + 1].x - p[i].x);
            s += p[i].y;
        }

        long ans = Long.MAX_VALUE;
        for (int i = 1; i <= n; i++) {
            ans = Math.min(ans, pre[i] + nex[i]);
        }

        System.out.println(ans);
    }

    static class Pair implements Comparable<Pair> {
        int y, x;

        Pair(int y, int x) {
            this.y = y;
            this.x = x;
        }

        public int compareTo(Pair other) {
            return Integer.compare(this.x, other.x);
        }
    }
}

Python 版本（仅供参考）

n = int(input())
p = [(0, 0)] * (n + 1)
pre = [0] * (n + 1)
nex = [0] * (n + 1)

for i in range(1, n + 1):
    p[i] = tuple(map(int, input().split()))

p.sort(key=lambda x: x[1])

s = 0
for i in range(1, n + 1):
    pre[i] = pre[i - 1]
    pre[i] += s * (p[i][1] - p[i - 1][1])
    s += p[i][0]

s = 0
for i in range(n, 0, -1):
    nex[i] = nex[i + 1]
    nex[i] += s * (p[i + 1][1] - p[i][1])
    s += p[i][0]

ans = float('inf')
for i in range(1, n + 1):
    ans = min(ans, pre[i] + nex[i])

print(ans)

觉得有用的话可以点点赞，支持一下。

如果愿意的话关注一下。会对你有更多的帮助。

每天都会不定时更新哦  >人<  。