Python 代码到 Java 代码的转换

• 有一段 Python 代码，需要将其转换为 Java 代码。
• Python 代码中使用了一些 Python 特有语法，例如列表推导式和字典，这些语法在 Java 中没有直接对应的语法结构。

2、解决方案：

• 对于列表推导式，可以使用 Java 的 for 循环来替换。
• 对于字典，可以使用 Java 的 HashMap 类来替换。

代码例子：

class FlowNetwork(object):
    def __init__(self):
        self.adj, self.flow, = {},{}

    def add_vertex(self, vertex):
        self.adj[vertex] = []

    def get_edges(self, v):
        return self.adj[v]

    def add_edge(self, u,v,w=0):
        self.adj[u].append((v,w))
        self.adj[v].append((u,0))
        self.flow[(u,v)] = self.flow[(v,u)] = 0

    def find_path(self, source, sink, path):
        if source == sink:
            return path
        for vertex, capacity in self.get_edges(source):
            residual = capacity - self.flow[(source,vertex)]
            edge = (source,vertex,residual)
            if residual > 0 and not edge in path:
                result = self.find_path(vertex, sink, path + [edge])
                if result != None:
                    return result

    def max_flow(self, source, sink):
        path = self.find_path(source, sink, [])
        while path != None:
            flow = min(r for u,v,r in path)
            for u,v,_ in path:
                self.flow[(u,v)] += flow
                self.flow[(v,u)] -= flow
                path = self.find_path(source, sink, [])
        return sum(self.flow[(source, vertex)] for vertex, capacity in self.get_edges(source))

import java.util.*;

public class FlowNetwork {

    private Map<Integer, List<Edge>> adj;
    private Map<Edge, Integer> flow;

    public FlowNetwork() {
        this.adj = new HashMap<>();
        this.flow = new HashMap<>();
    }

    public void addVertex(int vertex) {
        this.adj.put(vertex, new ArrayList<>());
    }

    public List<Edge> getEdges(int v) {
        return this.adj.get(v);
    }

    public void addEdge(int u, int v, int w) {
        Edge edge1 = new Edge(u, v, w);
        Edge edge2 = new Edge(v, u, 0);
        this.adj.get(u).add(edge1);
        this.adj.get(v).add(edge2);
        this.flow.put(edge1, 0);
        this.flow.put(edge2, 0);
    }

    public List<Edge> findPath(int source, int sink, List<Edge> path) {
        if (source == sink) {
            return path;
        }
        for (Edge edge : this.adj.get(source)) {
            int residual = edge.getCapacity() - this.flow.get(edge);
            if (residual > 0 && !path.contains(edge)) {
                List<Edge> newPath = new ArrayList<>(path);
                newPath.add(edge);
                List<Edge> result = findPath(edge.getTo(), sink, newPath);
                if (result != null) {
                    return result;
                }
            }
        }
        return null;
    }

    public int maxFlow(int source, int sink) {
        List<Edge> path = findPath(source, sink, new ArrayList<>());
        while (path != null) {
            int flow = Integer.MAX_VALUE;
            for (Edge edge : path) {
                flow = Math.min(flow, edge.getCapacity() - this.flow.get(edge));
            }
            for (Edge edge : path) {
                this.flow.put(edge, this.flow.get(edge) + flow);
                this.flow.put(new Edge(edge.getTo(), edge.getFrom(), 0), this.flow.get(new Edge(edge.getTo(), edge.getFrom(), 0)) - flow);
            }
            path = findPath(source, sink, new ArrayList<>());
        }
        int maxFlow = 0;
        for (Edge edge : this.adj.get(source)) {
            maxFlow += this.flow.get(edge);
        }
        return maxFlow;
    }

    public static void main(String[] args) {
        FlowNetwork g = new FlowNetwork();
        g.addVertex(0);
        g.addVertex(1);
        g.addVertex(2);
        g.addVertex(3);
        g.addVertex(4);
        g.addVertex(5);
        g.addEdge(0, 1, 3);
        g.addEdge(0, 2, 3);
        g.addEdge(1, 2, 2);
        g.addEdge(1, 3, 3);
        g.addEdge(2, 4, 2);
        g.addEdge(4, 5, 3);
        g.addEdge(3, 4, 4);
        g.addEdge(3, 5, 2);
        System.out.println(g.maxFlow(0, 5));  // 5
    }
}

class Edge {

    private int from;
    private int to;
    private int capacity;

    public Edge(int from, int to, int capacity) {
        this.from = from;
        this.to = to;
        this.capacity = capacity;
    }

    public int getFrom() {
        return from;
    }

    public int getTo() {
        return to;
    }

    public int getCapacity() {
        return capacity;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Edge edge = (Edge) o;
        return from == edge.from &&
                to == edge.to &&
                capacity == edge.capacity;
    }

    @Override
    public int hashCode() {
        return Objects.hash(from, to, capacity);
    }
}