java最优服务次序问题,多处最优服务次序问题java代码

本文介绍了一种解决多处最优服务次序问题的方法,通过给定n个顾客的服务时间和s个服务点,采用冒泡排序和动态规划策略,设计算法以找到使得n个顾客平均等待时间最小的服务次序。算法通过计算每个顾客的等待时间并更新,最后输出最小平均等待时间。
摘要由CSDN通过智能技术生成

多处最优服务次序问题

问题描述:

设有n个顾客同时等待一项服务,顾客i需要的服务时间为t[i]。共有s处可以提供此项服务。应如何安排n个顾客的服务次序才能使平均等待时间达到最小?平均等待时间是n个顾客等待服务时间的总和除n。

算法设计:

对于给定的n个顾客需要的服务时间和s的值,计算最有服务次序。

数据输入:

由文件input.txt给出输入数据。第一行有2个正整数n和s,表示有n个顾客且有s处提供顾客需要的服务。接下来

的一行中,有n个正整数,表示n个顾客需要的服务时间。

结果输出:

将计算的最小平均等待时间输出到文件output.txt.

package TanXin;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

public class DuoChuZuiYouPaiXu {

public static void main(String[] args) {

try {

BufferedReader reader = new BufferedReader(new FileReader("./input.txt"));

BufferedWriter writer = new BufferedWriter(new FileWriter("./output.txt"));

//从文件中读出信息

String info = reader.readLine();

String[] infos = info.split(" ");

int n = Integer.parseInt(infos[0]);// 顾客数

int s = Integer.parseInt(infos[1]);// 提供的服务数

//System.out.println(n + " " + s);

info = reader.readLine();

//System.out.println(info);

infos = info.split(" ");

int[] time = new int[n]; // 每个顾客需要的服务时间

for (int i = 0; i < infos.length; i++) {

time[i] = Integer.parseInt(infos[i]);

}

// 冒泡排序(按时间进行排序)

for (int i = 0; i < time.length; i++) {

int temp = 0;

for (int j = i + 1; j < time.length; j++) {

if (time[i] > time[j]) {

temp = time[i];

time[i] = time[j];

time[j] = temp;

}

}

}

// 进行排放

int sum = 0;// 用来存放所有顾客的等待时间

sum = sum + time[0] + time[1];// 先把第一二个人的时间加在上面

int[] waitTime = new int[n];

waitTime[0] = time[0];

waitTime[1] = time[1];

for(int i = 2; i < n; i++) {

if(waitTime[i-2] < waitTime[i-1]){

waitTime[i] = waitTime[i-2] + time[i];

}else {

waitTime[i] = waitTime[i-1] + time[i];

}

sum = sum + waitTime[i];

}

// 写入文件中

int x = sum/n;

// 可以用一下三种方式先把整数转化为string,再进行存储

//writer.write(x + "");

//writer.write(String.valueOf(x));

writer.write(Integer.toString(x));

writer.flush();

} catch (FileNotFoundException e) {

// TODO 自动生成的 catch 块

e.printStackTrace();

} catch (IOException e) {

// TODO 自动生成的 catch 块

e.printStackTrace();

}

}

}

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
可以使用动态规划算法来解决这个问题。具体步骤如下: 1. 定义一个二维数组m,其中m[i][j]表示从第i个矩阵到第j个矩阵的最优计算次序所需的最小乘法次数。 2. 初始化m数组的对角线元素为0,即m[i][i]=0。 3. 通过递推公式计算m数组的其它元素。递推公式如下: m[i][j] = min{m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j]},其中i<=k<j,p为矩阵的维度数组。 4. 最终结果为m[1][n-1],其中n为矩阵的个数。 以下是Java代码实现: public class MatrixChainMultiplication { public static void main(String[] args) { int[] p = {10, 100, 5, 50, 1}; // 矩阵维度数组 int n = p.length - 1; // 矩阵个数 int[][] m = new int[n][n]; // 最优计算次序所需的最小乘法次数 int[][] s = new int[n][n]; // 最优计算次序 // 初始化对角线元素 for (int i = 0; i < n; i++) { m[i][i] = 0; } // 计算m和s数组 for (int len = 2; len <= n; len++) { for (int i = 0; i <= n - len; i++) { int j = i + len - 1; m[i][j] = Integer.MAX_VALUE; for (int k = i; k < j; k++) { int q = m[i][k] + m[k+1][j] + p[i]*p[k+1]*p[j+1]; if (q < m[i][j]) { m[i][j] = q; s[i][j] = k; } } } } // 输出最优计算次序 printOptimalParenthesis(s, 0, n-1); } // 输出最优计算次序 private static void printOptimalParenthesis(int[][] s, int i, int j) { if (i == j) { System.out.print("A" + i); } else { System.out.print("("); printOptimalParenthesis(s, i, s[i][j]); printOptimalParenthesis(s, s[i][j]+1, j); System.out.print(")"); } } }
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值