banker

---

代码的输入内容，不想看不用看，也不是什么重要的，我写的时候偷了懒，需求的那个我直接要求输入了，如果想要标准的，可以输入目前有的，一个循环减去相应的就是需求的，我只不过用输入省去了这个步骤

package 实验二_banker;

import java.util.Arrays;

/**
 * The type Create.
 */
public class Create {
    private  Sc sc = new Sc();
    /**
     * The Max need process. 最大资源需求矩阵
     */
    private int[][] maxNeedProcess;
    /**
     * The Need. 需求矩阵
     */
    private int[][] need;
    /**
     * The Avaliable. 资源向量
     */
    private int[] available;
    /**
     * 进程数目
     */
    private int process;

    /**
     * Instantiates a new Create.
     */
    Create(){
        System.out.println("请输入进程数量:");
        process = sc.getEnterInt();
        System.out.println("请输入系统资源数量:");
        int r = sc.getEnterInt();

        //最大资源需求矩阵
        maxNeedProcess = new int[process][r];
        //需求矩阵
        need = new int[process][r];
        //资源向量
        available = new int[r];

        enter(maxNeedProcess,need,available);
    }

    /**
     * Enter.
     *
     * @param maxNeedProcess the max need process
     * @param need           the need
     * @param avaliable      the avaliable
     */
//这里的代码可以进行抽象
    public void enter(int[][] maxNeedProcess,int[][] need ,int[] avaliable){
        System.out.println("请输入每个进程最大资源需求量:");
        for (int i = 0; i < maxNeedProcess.length; i++) {
            for (int j = 0; j < maxNeedProcess[i].length; j++) {
                System.out.println("第"+i+"个进程最多需要的资源是:");
                maxNeedProcess[i][j] = sc.getEnterInt();
            }
        }

        System.out.println("请输入每个进程目前需求资源量:");
        for (int i = 0; i < need.length; i++) {
            for (int j = 0; j < need[i].length; j++) {
                System.out.println("第"+i+"个进程目前需要的资源是:");
                need[i][j] = sc.getEnterInt();
            }
        }

        System.out.println("请输入剩余每个资源的数量");
        for (int i = 0; i < avaliable.length ; i++) {
            avaliable[i] = sc.getEnterInt();
        }
    }


    /**
     * Get max need process int [ ] [ ].
     *
     * @return the int [ ] [ ]
     */
    public int[][] getMaxNeedProcess() {
        return maxNeedProcess;
    }

    /**
     * Sets max need process.
     *
     * @param maxNeedProcess the max need process
     */
    public void setMaxNeedProcess(int[][] maxNeedProcess) {
        this.maxNeedProcess = maxNeedProcess;
    }

    /**
     * Get need int [ ] [ ].
     *
     * @return the int [ ] [ ]
     */
    public int[][] getNeed() {
        return need;
    }

    /**
     * Sets need.
     *
     * @param need the need
     */
    public void setNeed(int[][] need) {
        this.need = need;
    }

    /**
     * Get available int [ ].
     *
     * @return the int [ ]
     */
    public int[] getAvailable() {
        return available;
    }

    /**
     * Sets available.
     *
     * @param available the available
     */
    public void setAvailable(int[] available) {
        this.available = available;
    }

    /**
     * Gets process.
     *
     * @return the process
     */
    public int getProcess() {
        return process;
    }

    /**
     * Sets process.
     *
     * @param process the process
     */
    public void setProcess(int process) {
        this.process = process;
    }
}

---

代码实现

注：应为突发奇想，将Scanner写道一个类去了，但是发现好麻烦，我就不粘了，手动将sc方法改为scanner方法就行

package 实验二_banker;

/**
 * The type Solve.
 */
public class Solve {
    /**
     * The Max need process. 最大资源需求矩阵
     */
    private int[][] maxNeedProcess;
    /**
     * The Need. 需求矩阵
     */
    private int[][] need;
    /**
     * The available. 资源向量
     */
    private int[] available;

    private Boolean[] aBoolean;

    /**
     * The Create.
     */
    Create create = new Create();

    /**
     * Instantiates a new Solve.
     */
    Solve(){
        solve();
    }

    private void solve(){
        aBoolean = new Boolean[create.getProcess()];
        for (int i = 0; i < aBoolean.length; i++) {
            aBoolean[i] = false;
        }
        maxNeedProcess = create.getMaxNeedProcess();
        need = create.getNeed();
        available = create.getAvailable();
        if (needEstablished(maxNeedProcess,need)) {
            while (true) {
                int x = availableEstablished(need, available,aBoolean);

                if (x == -1){
                    System.out.println("REEOR:无解");
                    break;
                }else{
                    aBoolean[x] = true;
                    for (int i = 0; i < available.length; i++) {
                        available[i] = available[i] - need[x][i] + maxNeedProcess[x][i];
                        need[x][i] = 0;
                    }
                    System.out.println("-----------------");
                    for (int i = 0; i < need.length; i++) {
                        for (int j = 0; j < need[i].length; j++) {
                            System.out.print(need[i][j] + " - ");
                        }
                        System.out.println();
                    }
                    System.out.println("-----------------");
                    if (Judge(aBoolean) ){
                        System.out.println("结束");
                        break;
                    }
                }

            }
        }
    }

//    private int[] shenyu(Boolean[] aBoolean){
//        int[] x = new int[aBoolean.length];
//        for (int i = 0; i < aBoolean.length; i++) {
//            if (aBoolean[i] == true){
//                x[i] =
//            }
//        }
//    }
    private  int aBooleanFalse(Boolean[] aBoolean){
        int x = 0;
        for (int i = 0; i < aBoolean.length; i++) {
            if(aBoolean[i] == false){
                x++;
            }
        }
        return x;
    }

    /**
     * 判断当前情况有没有解
     * @param request
     * @param available
     * @return
     */
    private int availableEstablished(int[][] request ,int[] available ,Boolean[] aBoolean){
        Boolean flag = true;
        int x = 0;
        for (int i = 0; i < aBoolean.length; i++) {
            if (aBoolean[i] == false){
                x++;
            }
        }
        for (int i = 0; i < aBoolean.length; i++) {
            if (aBoolean[i] == false){
                for (int j = 0; j < request[i].length; j++) {
                    if (request[i][j] > available[j] ){
                        flag = false;
                    }
                }
                if (flag == true){
                    return i;
                }
            }
            flag = true;
        }

        return -1;
    }

    /**
     * 判断需求资源是否大于最大资源，第一步筛查
     * @param maxNeedProcess 最大需求
     * @param request 需求
     * @return 返回false为停止，真为没有问题
     */
    private Boolean needEstablished(int[][] maxNeedProcess,int[][] request){
        for (int i = 0; i < maxNeedProcess.length; i++) {
            for (int j = 0; j < maxNeedProcess[i].length; j++) {
                if (maxNeedProcess[i][j] < request[i][j]){
                    System.out.println("ERROR:第" + (i + 1)+ "个进程的第" + (j + 1) + "给资源目标需求大于实际需求，程序停止");
                    return false;
                }
            }
        }
        return true;
    }

    private Boolean Judge(Boolean[] aBoolean){

        for (Boolean i :
                aBoolean) {
                if (i == false) {
                    return false;
                }

            }
        return true;
    }
}

---

测试类：

package 实验二_banker;

public class text {
    public static void main(String[] args) {
//        Create create = new Create();
        Solve solve = new Solve();
    }
}

---