实验四 贪心算法

桂 林 理 工 大 学
实 验 报 告

实验名称 实验四 日期 2020年 11 月25 日
一、实验目的：
理解贪心算法的思想，并能对给定的问题能设计出分治算法予以解决。
二、实验环境：
Eclipse
三、实验内容：
1.最优服务次序问题。
问题描述：设有n个顾客同时等待一项服务，顾客i需要的服务时间为ti，（1<=i<=n）。应如何安排n个顾客的服务次序才能使平均等待时间达到最小？（平均等待时间是n个顾客等待服务时间总和除以n）
输入：第一行为一个正整数n，表示有n个顾客
第二行为n个正整数，表示n个顾客需要的服务时间
输出：最小平均等待时间。

import java.util.Scanner;
import java.util.Arrays;
public class tanxin {
	public static void main(String[] args) {
		Scanner reader=new Scanner(System.in);
		int n=reader.nextInt();	//等待人数
		int total = 0;//总等待时间
		int arr[]=new int[n+1];
		for(int i=1;i<=n;i++){
			arr[i]=reader.nextInt();
		}
		Arrays.sort(arr); 
		for(int i=1;i<n;i++){
			total+=arr[i];
		}
		System.out.println(total/n);
	}
}

2.}多处最优服务次序问题。
问题描述：设有n个顾客同时等待一项服务，顾客i需要的服务时间为ti，（1<=i<=n）。共有s处可以提供此项服务。应如何安排n个顾客的服务次序才能使平均等待时间达到最小？
输入：第一行为两个正整数n和s
第二行为n个正整数，表示n个顾客需要的服务时间
输出：最小平均等待时间。

import java.util.Scanner;
import java.util.Arrays;
public class tanxin {
	public static double waitMin(int[] arr,int n,int s){
		double total=0D;
		int loop=0;
		if( n/s!= ((double)n)/((double)s) ){
			loop=n/s;
		}else{
			loop=n/s-1;
		}
		for(int i=1;i<=loop*s;i++){
			total+=arr[i];
		}
		return total;
	}

	public static void main(String[] args) {
		Scanner reader=new Scanner(System.in);
		int n=reader.nextInt();	//等待人数
		int s=reader.nextInt();	//服务处数
		int arr[]=new int[n+1];
		for(int i=1;i<=n;i++){
			arr[i]=reader.nextInt();
		}
		Arrays.sort(arr); 
		System.out.println(waitMin(arr,n,s)/n);
	}
}

3.最优分解问题。
问题描述：设n是一个正整数，要求将n分解为若干互不相同的自然数之和，且这些自然数的乘积最大。
输入：正整数n
输出：计算的最大乘积。
如输入10，则输出30.
提示：若a+b=const ，则a-b的绝对值越小，ab值越大。贪心策略：将n分成从2开始的连续自然数之和，如果最后剩下一个数，则将此数在后项优先的方式下均匀地分给前面各项。

public static int disptch(int t) {// 参数t为输入的整数
        int sum = 1;
        int cont = 0;
        int n = t;
        int temp = 0;
        int[] a = new int[t];// 存放被分解的数
        // 赋初始值
        for (int i = 0; i < t; i++) {
            a[i] = 0;
        }
        if (t < 4) {
            System.out.println("不存在最优方案");
        } else {
            a[0] = 2;// 从第一个开始赋值
            t = t - a[0];// 减去已经分解的数值
            int k = 0;
            cont = a[0];
            while (cont < n) {// 比较已经被分解的最后一个数和剩下数的大侠，若为true则进入循环
                k++;// 数组下标+1
                a[k] = a[k - 1] + 1;
                cont = cont + a[k];
                // t = t - a[k];// 减去最新分解的数字
            }
            temp = cont - n;
            if (temp == 1) {
                a[0] = 0;
                a[k] += 1;
            } else if (temp == 0) {

            } else {
                a[temp - 2] = 0;
            }
            System.out.print("最优分解方案是：");
            // 打印出最佳方案
            for (int i = 0; i < a.length; i++) {
                if (a[i] != 0) {
                    sum = sum * a[i];
                    System.out.print(" " + a[i] + " ");
                }
            }
        }
        return sum;
    }

4.多机调度问题
利用贪心法设计算法求解如下问题：
要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。约定，每个作业均可在任何一台机器上加工处理，但未完工前不允许中断处理。作业不能拆分成更小的子作业。
这个问题是一个NP完全问题，到目前为止还没有一个有效的解法。对于这一类问题，用贪心选择策略有时可以设计出较好的近似算法。
可以考虑以下的贪心策略：
（1）最长处理时间作业优先的贪心选择策略。
（2）最短处理时间作业优先的贪心选择策略。
（3）作业到达时间优先的贪心选择策略。
假设7个独立的作业由3台机器加工处理，各作业所需的处理时间为：{2，14，4，6，16，5，3}，写出以上算法求解此问题的结果。

package test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class tanxin {
    // 声明一个作业类 用来对作业进行标记，并继承Comparable接口进 实现对作业的排序
    public static class JobNode implements Comparable {
        int id;// 作业的标号
        int time;// 作业时间

        // 构造方法初始化
        public JobNode(int id, int time) {
            this.id = id;
            this.time = time;
        }

        public int compareTo(Object x) {// 按时间从大到小排列
            int times = ((JobNode) x).time;
            if (time > times)
                return -1;
            if (time == times)
                return 0;
            return 1;
        }
    }

    public static class MachineNode implements Comparable {
        int id;// 机器的标号
        int avail;// 机器空闲的时间（即机器做完某一项工作的时间）

        public MachineNode(int id, int avail) {
            this.id = id;
            this.avail = avail;
        }

        public int compareTo(Object o) {// 升序排序，LinkedList的first为最小的
            int xs = ((MachineNode) o).avail;
            if (avail < xs)
                return -1;
            if (avail == xs)
                return 0;
            return 1;
        }
    }

    public static int greedy(int[] a, int m) {
        int n = a.length - 1;// a的下标从1开始，所以n（作业的数目）=a.length-1
        int sum = 0;
        // 当机器数大于等于作业数
        if (n <= m) {
            sum = a[0];
            for (int i = 0; i < n; i++)
                if (a[i + 1] > a[i]) {
                    sum = a[i + 1];
                }
            // sum += a[i + 1];
            System.out.println("为每个作业分别分配一台机器");
            return sum;
        }
        List<JobNode> d = new ArrayList<JobNode>();// d保存所有的作业
        for (int i = 0; i < n; i++) {// 将所有的作业存入List中，每一项包含标号和时间
            JobNode jb = new JobNode(i + 1, a[i + 1]);
            d.add(jb);// 添加到list
        }
        Collections.sort(d);// 对作业的List进行排序
        LinkedList<MachineNode> h = new LinkedList<MachineNode>();// h保存所有的机器
        for (int i = 1; i <= m; i++) {// 将所有的机器存入LinkedList中
            MachineNode x = new MachineNode(i, 0);// 初始时，每台机器的空闲时间（完成上一个作业的时间）都为0
            h.add(x);
        }
        int test = h.size();// 将机器的大小赋初始值
        for (int i = 0; i < n; i++) {
            Collections.sort(h);// 对机器上正在进行的时间进行排序
            MachineNode x = h.peek(); // 查看栈顶元素 栈顶元素为最小元素。
            System.out.println("将机器" + x.id + "从" + x.avail + "到"
                    + (x.avail + d.get(i).time) + "的时间段分配给作业" + d.get(i).id);
            x.avail += d.get(i).time;
            if (x.avail > sum) {
                sum = x.avail;
            }
        }
        return sum;
    }

    public static void main(String[] args) {
        // 不同的测试数据
        int[] a = { 0, 1, 14, 4, 16, 6, 5, 3 };
        // int[] a = { 0, 2, 14, 4, 16, 6, 5, 3 };
        // int[] a = { 0, 44, 14, 4 };
        int m = 3;// 机器数
        int sum = greedy(a, m);
        System.out.println("总时间为：" + sum);
    }
}

参考文章