贪心类问题

排队打水

题解：

$t_1,t_2,t_3,...,t_{n-1},t_n$
等待时间计算的公式为：$t_1\ast (n-1)+t_2\ast (n-2)+...+t_{n-1}\ast 1$
当$t_1,t_2,t_3,...,t_{n-1},t_n$为单调递增数列时，等待时间最小。
证明：
利用反证法，设排队顺序中存在$t_i>t_{i+1}$
那么花在排在第$i$个人上的等待时间为$t_i\ast (n-i-1)$
花在排在第$i+1$个人上的等待时间为$t_{i+1}\ast (n-i-2)$
那么$t_i\ast (n-i-1)+t_{i+1}\ast (n-i-2)$为这两个人打水的等待成本
若将排在第$i+1$个人和第$i$个人交换位置。
那么$t_i\ast (n-i-2)+t_{i+1}\ast (n-i-1)$为这两个人交换位置后的等待成本
未交换位置和交换位置后的等待时间成本作差，可得$t_i-t_{i+1}$因为$t_i>t_{i+1}$所以，交换位置前的等待时间成本大于交换位置后的，所以排队顺序中不应该存在排在前方的人的打水时间大于排在后方的人的打水时间的非单调递增的情况。

import java.io.*;
import java.util.*;

public class Main{
    static int N=100010;
    public static void main(String[] args)throws IOException{
        BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
        int n=Integer.parseInt(in.readLine());
        String[] strs=in.readLine().split(" ");
        int[] t=new int[N];
        for(int i=0;i<n;i++)
            t[i]=Integer.parseInt(strs[i]);
        Arrays.sort(t,0,n);
        long sum=0;
        for(int i=0;i<n;i++){
            sum+=t[i]*(n-i-1);
        }
        System.out.println(sum);
    }
}

货仓选址

import java.io.*;
import java.util.*;

public class Main{
    static int N=100010;
    static int[] loc=new int[N];
    public static void main(String[] args)throws IOException{
        BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
        int n=Integer.parseInt(in.readLine());
        String[] strs=in.readLine().split(" ");
        for(int i=0;i<n;i++)
            loc[i]=Integer.parseInt(strs[i]);
        Arrays.sort(loc,0,n);
        int d=loc[n/2];
        int res=0;
        for(int i=0;i<n;i++)
            res+=Math.abs(d-loc[i]);
        System.out.println(res);
    }
}

耍杂技的牛

题解

按照$w_i+s_i$从小到大的顺序排，最大的危险系数一定是最小的
假设存在$w_i+s_i>w_{i+1}+s_{i+1}$
则有：

	第$i$个位置上的牛	第$i+1$个位置上的牛
交换前	$w_1+w_2+...+w_{i-1}-s_i$	$w_1+w_2+...+w_{i-1}+w_i-s_{i+1}$
交换后	$w_1+w_2+...+w_{i-1}-s_{i+1}$	$w_1+w_2+...+w_{i-1}+w_{i+1}-s_i$

同时去掉$w_1+w_2+...+w_{i-1}$

	第$i$个位置上的牛	第$i+1$个位置上的牛
交换前	$-s_i$	$w_i-s_{i+1}$
交换后	$-s_{i+1}$	$w_{i+1}-s_i$

同时加上$s_i+s_{i+1}$

	第$i$个位置上的牛	第$i+1$个位置上的牛
交换前	$s_{i+1}$	$w_i+s_i$
交换后	$s_i$	$w_{i+1}+s_{i+1}$

因为$w_i>1$，所以$w_i+s_i>s_i$，
因为假设的$w_i+s_i>w_{i+1}+s_{i+1}$，所以综上$max(s_{i+1},w_i+s_i)>max(s_i,w_{i+1}+s_{i+1})$
交换前第$i$个位置上的牛和第$i+1$个位置上的牛的最大风险值要大于交换后的第$i$个位置上的牛和第$i+1$个位置上的牛的最大风险值。
所以综上来说，让$w_i+s_i$小的排上面这两头牛最大风险值更小，总体的排序也同理。

import java.io.*;
import java.util.*;

class Cow implements Comparable<Cow>{
    int w;
    int s;
    public Cow(int w,int s){
        this.w=w;
        this.s=s;
    }
    public int compareTo(Cow o){
        return Integer.compare(w+s,o.w+o.s);
    }
}

public class Main{
    static int N=50010;
    static Cow[] cow=new Cow[N];
    public static void main(String[] args)throws IOException{
        BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
        int n=Integer.parseInt(in.readLine());
        String[] strs;
        for(int i=0;i<n;i++){
            strs=in.readLine().split(" ");
            int w=Integer.parseInt(strs[0]);
            int s=Integer.parseInt(strs[1]);
            cow[i]=new Cow(w,s);
        }
        Arrays.sort(cow,0,n);
        int risk=-cow[0].s;
        int tw=cow[0].w;
        for(int i=1;i<n;i++){
            int res=tw-cow[i].s;
            tw+=cow[i].w;
            if(res>risk)risk=res;
        }
        System.out.println(risk);
    }
}