二分图算法

二分图

// 阿姨派单

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.*;

/**
 * 请在此类中完成解决方案，实现process完成数据的处理逻辑。
 *
 * @author zhaoyiwei
 * @date 2021年12月15日 上午11:18:32
 */
public class Solution {
    List<OrderDetail>   orderList    = new ArrayList<>();
    List<Cleaner>       cleaners     = new ArrayList<>();
    List<PackageDetail> packages     = new ArrayList<>();
    int                 packageCount = 0;
    int                 cleanerCount = 0;
    int                 orderCount   = 0;
    // 邻接表存阿姨与打包订单之间的关系
    List<List<Edge>>    cleanerWithPackages;
    List<List<Edge>>    packageWithCleaner;

    /**
     * 主体逻辑实现demo，实现代码时请注意逻辑严谨性，涉及到操作文件时，保证文件有开有闭等。
     *
     * @param auntFile  阿姨信息文件
     * @param orderFile 订单信息文件
     */
    public void process(String auntFile, String orderFile) throws Exception {
        getOrderList(orderFile);
        // 按服务分排序
        getCleanerList(auntFile);

        // 已匹配的order
        boolean[] matchOrder = new boolean[orderCount];
        // 选择打包的第一个订单，如果被选中，选择下一个订单
        for (int n = 0; n < orderCount; n++) {
            if (matchOrder[n])
                continue;
            PackageDetail currentPackage = new PackageDetail();
            currentPackage.list.add(n);
            matchOrder[n] = true;
            for (int i = n; i < orderCount; i++) {
                // 选择下一个完成时间最小的点
                double finishTime = Double.MAX_VALUE, waitTime = 0, distance = 0;
                // 上一单的pos
                int lastOrderPos = currentPackage.list.get(currentPackage.list.size() - 1);
                int nextPos      = -1;
                for (int j = n + 1; j < orderCount; j++) {
                    if (matchOrder[j])
                        continue;

                    Pair finishInfo = getFinishTimeByPoint(orderList.get(lastOrderPos), orderList.get(j));
                    if (finishInfo.endTime < 0)
                        continue;

                    if (finishInfo.endTime < finishTime) {
                        nextPos = j;
                        finishTime = finishInfo.endTime;
                        waitTime = finishInfo.waitTime;
                        distance = finishInfo.distance;
                    }
                }

                // 将选中的点加入列表中
                if (nextPos != -1) {
                    currentPackage.list.add(nextPos);
                    currentPackage.waitTime += waitTime;
                    currentPackage.totalDistance += distance;
                    matchOrder[nextPos] = true;
                }
            }
            packages.add(currentPackage);
        }
        packageCount = packages.size();
        packageWithCleaner = new ArrayList<>(packageCount);
        for (int i = 0; i < orderCount; i++) {
            if (!matchOrder[i])
                System.out.println(i);
        }

        // 存在问题， 如果打包数量 大于 阿姨数量 会存在部分订单不匹配的问题？
        // 初始化二分图
        initBipartiteGraph();
        // hungarian();
        KM();

    }

    public void KM() throws Exception {
        double    maxValue  = Double.MAX_VALUE;
        double[]  lx        = new double[packageCount], ly = new double[cleanerCount], slack = new double[cleanerCount];
        boolean[] visx      = new boolean[packageCount], visy = new boolean[cleanerCount];
        int[]     matchList = new int[cleanerCount];
        int[]     fa        = new int[packageCount + cleanerCount];
        Arrays.fill(lx, 0);
        Arrays.fill(matchList, -1);
        // 初始化与cleaner的最大权值
        for (int i = 0; i < packageCount; i++) {
            for (Edge edge : packageWithCleaner.get(i))
                lx[i] = Math.max(lx[i], edge.weight);
        }
        for (int i = 0; i < packageCount; i++) {
            Arrays.fill(slack, maxValue);
            Arrays.fill(fa, -1);
            Arrays.fill(visx, false);
            Arrays.fill(visy, false);
            int     leaf = -1;
            boolean fir  = true;
            while (true) {
                // System.out.println("匹配节点：第 " + i + "个cleaner，匹配的order Pos：" + leaf);
                if (fir) {
                    leaf = findPath(i, matchList, fa, visx, visy, lx, ly, slack);
                    // System.out.println("if fir 匹配节点：第 " + i + " 个cleaner，匹配的order Pos：" + leaf);
                    fir = false;
                } else {
                    for (int j = 0; j < packageCount; j++) {
                        if (slack[j]  <= 0.000001 && slack[j] >= 0 ) {
                            slack[j] = maxValue;
                            leaf = findPath(j, matchList, fa, visx, visy, lx, ly, slack);
                            if (leaf > 0) break;
                        }
                    }
                }

                if (leaf > 0) {
                    int p = leaf;
                    while (p > 0) {
                        matchList[p - packageCount] = fa[p];
                        p = fa[fa[p]];
                    }
                    break;
                } else {
                    double delta = maxValue;
                    for (int j = 0; j < packageCount; j++)
                        if (visx[j] && delta > slack[j])
                            delta = slack[j];
                    for (int j = 0; j < packageCount; j++)
                        if (visx[j]) {
                            lx[j] -= delta;
                            slack[j] -= delta;
                        }
                    for (int j = 0; j < cleanerCount; j++)
                        if (visy[j])
                            ly[j] += delta;
                }
            }
        }

        getResult(matchList);

    }

    public int findPath(int packagePos, int[] match, int[] fa, boolean[] visx, boolean[] visy, double[] lx, double[] ly, double[] slack) {
        double tmpDelta;
        visx[packagePos] = true;
        List<Edge> edges = packageWithCleaner.get(packagePos);
        for (Edge edge : edges) {
            if (visy[edge.cleanerPos])
                continue;
            tmpDelta = lx[packagePos] + ly[edge.cleanerPos] - edge.weight;
            if (tmpDelta <= 0.000001 && tmpDelta >= 0) {
                visy[edge.cleanerPos] = true;
                fa[edge.cleanerPos + packageCount] = packagePos;
                if (match[edge.cleanerPos] == -1) {
                    return edge.cleanerPos + packageCount;
                }
                fa[match[edge.cleanerPos]] = edge.cleanerPos + packageCount;
                int res = findPath(match[edge.cleanerPos], match, fa, visx, visy, lx, ly, slack);
                if (res > 0)
                    return res;
            } else if (slack[packagePos] > tmpDelta) {
                slack[packagePos] = tmpDelta;
            }
        }
        return -1;
    }


    public void hungarian() throws Exception {
        boolean[] pathMark  = new boolean[cleanerCount];
        int[]     matchList = new int[cleanerCount];
        Arrays.fill(matchList, -1);

        for (int i = 0; i < packageCount; i++) {
            Arrays.fill(pathMark, false);
            findArgumentPath(i, pathMark, matchList);
        }
        // for (int i = 0; i < packageCount; i++) {
        //     if (matchList[i] == -1) {
        //         for (Integer integer : packages.get(i).list) {
        //             System.out.println(integer);
        //         }
        //     }
        // }

        getResult(matchList);
    }

    public boolean findArgumentPath(int packagePos, boolean[] pathMark, int[] matchList) {
        List<Edge> packages = packageWithCleaner.get(packagePos); // 阿姨对应的任务订单
        for (Edge edge : packages) {
            // 只匹配不存在于路径中的任务包 from 为阿姨下标
            int cleanerPos = edge.cleanerPos;
            if (!pathMark[cleanerPos]) {
                pathMark[cleanerPos] = true;
                if (matchList[cleanerPos] == -1 || findArgumentPath(matchList[cleanerPos], pathMark, matchList)) {
                    matchList[cleanerPos] = packagePos;
                    return true;
                }
            }
        }
        return false;
    }



    public void getResult(int[] matchList) {
        boolean[] resultPos = new boolean[packageCount];
        for (int i = 0; i < cleanerCount; i++) {
            if (matchList[i] != -1) {
                resultPos[matchList[i]] = true;
                String        cleanerId = cleaners.get(i).id.toString();
                List<Integer> orderIds  = packages.get(matchList[i]).list;
                for (Integer id : orderIds) {
                    String orderId = orderList.get(id).id.toString();
                    try {
                        MainFrame.addSet(orderId, cleanerId);
                    } catch (Exception e) {
                        System.out.println(e);
                    }
                }
            }
        }

        for (int i = 0; i < packageCount; i++) {
            if (!resultPos[i])
                System.out.println(i);
        }
    }

    // 二分图初始化
    public void initBipartiteGraph() {
        for (int i = 0; i < packageCount; i++) {
            List<Edge> cleanerList = new ArrayList<>();
            for (int j = 0; j < cleanerCount; j++) {
                Edge edge = judgeReachable(i, j);
                if (edge.canArrive)
                    cleanerList.add(edge);
            }
            packageWithCleaner.add(cleanerList);
        }
    }

    // i为第i个 package 列表，j为第j个阿姨，
    public Edge judgeReachable(int i, int j) {
        PackageDetail packageDetail = packages.get(i);
        Cleaner       cleaner       = cleaners.get(j);
        OrderDetail   orderDetail   = orderList.get(packageDetail.list.get(0));
        double        distance      = getDistanceByPoint(cleaner.x, cleaner.y, orderDetail.x, orderDetail.y);
        double        time          = distance / 15.0;
        if (time + 0.5 > orderDetail.beginTime) {
            return new Edge(j, 0, false);
        }
        double cleanerScore = cleaner.score * packageDetail.list.size() / orderCount;
        double distanceScore = 0.5 * (packageDetail.totalDistance / (orderCount * 15.0));
        double weightTimeScore = 0.25 * (time + 0.5 + packageDetail.waitTime) / orderCount;
        double weight = cleanerScore - distanceScore - weightTimeScore;
        return new Edge(j, weight, true);
    }


    public Pair getFinishTimeByPoint(OrderDetail a, OrderDetail b) {
        double distance = getDistanceByPoint(a.x, a.y, b.x, b.y);
        double time     = a.beginTime + a.unitTime + distance / 15.0;
        if (time >= b.beginTime)
            return new Pair(-1.0, -1.0, 0.0);
        return new Pair(b.beginTime + b.unitTime, b.beginTime - time, distance);
    }

    public Double getDistanceByPoint(Long x1, Long y1, Long x2, Long y2) {
        return Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)) / 1000;
    }

    public String[] readFile(String filePath) {
        File   file        = new File(filePath);
        long   fileLength  = file.length(); // 获取文件长度
        byte[] fileContent = new byte[(int) fileLength];
        try (FileInputStream in = new FileInputStream(file)) {
            int read = in.read(fileContent);
        } catch (IOException e) {
            System.out.println(e);
        }
        return new String(fileContent).split("\n");
    }

    public void getOrderList(String filePath) {
        String[] strings = readFile(filePath);
        for (String lineInfo : strings) {
            String[] split = lineInfo.split(",");
            orderList.add(new OrderDetail(Integer.valueOf(split[0]), Long.valueOf(split[1]), Integer.valueOf(split[2]), Long.valueOf(split[3]), Long.valueOf(split[4])));
        }
        Collections.sort(orderList);
        orderCount = orderList.size();
    }

    public void getCleanerList(String filePath) {

        String[] strings = readFile(filePath);
        for (String lineInfo : strings) {
            String[] split = lineInfo.split(",");
            cleaners.add(new Cleaner(Integer.valueOf(split[0]), Double.valueOf(split[1]), Long.valueOf(split[2]), Long.valueOf(split[3])));
        }
        Collections.sort(cleaners);
        cleanerCount = cleaners.size();
        cleanerWithPackages = new ArrayList<>(cleanerCount);
    }
}

class PackageDetail {
    public List<Integer> list          = new ArrayList<>();
    public Double        waitTime      = 0.0;
    public Double        totalDistance = 0.0;
}

class Pair {
    public Double endTime;
    public Double waitTime;
    public Double distance;

    public Pair(Double endTime, Double waitTime, Double distance) {
        this.endTime = endTime;
        this.waitTime = waitTime;
        this.distance = distance;
    }
}


class OrderDetail implements Comparable<OrderDetail> {
    public Integer id;
    public Double  beginTime;
    public Double  unitTime; // 服务时长
    public Double  endTime; // 结束时间，对时间 * 2 处理，避免出现小数
    public Long    x;
    public Long    y;

    public OrderDetail(Integer id, Long beginTime, Integer unitTime, Long x, Long y) {
        this.id = id;
        this.x = x;
        this.y = y;
        beginTime *= 1000;
        // LocalDateTime date    = LocalDateTime.parse(beginTime.toString());
        Date date    = new Date(beginTime);
        int  hour    = date.getHours();
        int  minutes = date.getMinutes();
        this.beginTime = hour + (minutes / 60.0);
        this.unitTime = unitTime / 60.0;
        // System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date));
        this.endTime = this.beginTime + this.unitTime;
    }

    @Override
    public int compareTo(OrderDetail o) {
        if ((this.beginTime + this.unitTime) - (o.beginTime + o.unitTime) > 0)
            return 1;
        if ((this.beginTime + this.unitTime) - (o.beginTime + o.unitTime) == 0)
            return 0;
        return -1;
    }
}

// 按分数排序
class Cleaner implements Comparable<Cleaner> {
    public Integer id;
    public Double  score;
    public Long    x;
    public Long    y;

    public Cleaner(Integer id, Double score, Long x, Long y) {
        this.id = id;
        this.score = score;
        this.x = x;
        this.y = y;
    }

    @Override
    public int compareTo(Cleaner cleaner) {
        if (cleaner.score > this.score) {
            return 1;
        } else if (cleaner.score.equals(this.score)) {
            return 0;
        } else {
            return -1;
        }
    }
}

class Edge {
    public int     cleanerPos; // 与阿姨相连的package包的下标
    public double  weight;
    public boolean canArrive = false;

    public Edge(int to, double weight, boolean canArrive) {
        this.cleanerPos = to;
        this.weight = weight;
        this.canArrive = canArrive;
    }
}