通过包含两个值的元素的列表进行迭代，并仅对连接的值求和（Java）

我需要帮助解决以下问题。 当我有一个包含两个值的元素列表时，它表示桥的起点和终点。 这些值表示“桥”。例如，[0,1]表示一个网桥连接island0和island1

我如何迭代从0开始的列表，只对连接的值求和，而忽略其他值

示例1-每个岛都是间接连接的

[0,1]
[1,2]
[2,3]
[3,4]

解决方案应为：0+1+2+3+4=10

示例2

[0,1]
[1,2]
[3,4] !!! NOT CONNECTED

解决方案应为：0+1+2=3

---

谢谢

试试这个简单的解决方案

import java.util.ArrayList;
import java.util.List;

public class TestBridge {

    public static final class Bridge {
        int start;

        int end;

        Bridge(int start, int end) {
            this.start = start;
            this.end = end;
        }
    }

    private static int getSum(List<Bridge> bridges) {
        int sum = 0;
        int prevEnd = -1;
        for (Bridge bridge : bridges) {
            int actualStart = bridge.start;
            int actualEnd = bridge.end;
            if (actualStart == 0 || prevEnd == actualStart) {
                prevEnd = actualEnd;
                sum += actualEnd;
            }
        }
        return sum;
    }

    private static List<Bridge> getFirstExample() {
        List<Bridge> bridges = new ArrayList<>();
        bridges.add(new Bridge(0, 1));
        bridges.add(new Bridge(1, 2));
        bridges.add(new Bridge(2, 3));
        bridges.add(new Bridge(3, 4));
        return bridges;
    }

    private static List<Bridge> getSecondExample() {
        List<Bridge> bridges = new ArrayList<>();
        bridges.add(new Bridge(0, 1));
        bridges.add(new Bridge(1, 2));
        bridges.add(new Bridge(3, 4));
        return bridges;
    }

    public static void main(String[] args) {
        System.out.println(getSum(getFirstExample()));
        System.out.println(getSum(getSecondExample()));
    }
}

import java.util.ArrayList；
导入java.util.List；
公共类测试桥{
公共静态终级桥{
int启动；
内端；
桥接器（int开始，int结束）{
this.start=start；
this.end=end；
}
}
私有静态int getSum（列表桥）{
整数和=0；
int prevEnd=-1；
用于（桥梁：桥梁）{
int actualStart=bridge.start；
int=bridge.end；
如果（实际开始==0 | |前结束==实际开始）{
prevEnd=实际贷款；
总和+=实际贷款；
}
}
回报金额；
}
私有静态列表getFirstExample（）{
List bridges=new ArrayList（）；
添加（新桥（0,1））；
桥梁。增加（新桥梁（1,2））；
桥梁。增加（新桥梁（2,3））；
增加（新桥梁（3,4））；
返回桥；
}
私有静态列表getSecondExample（）{
List bridges=new ArrayList（）；
添加（新桥（0,1））；
桥梁。增加（新桥梁（1,2））；
增加（新桥梁（3,4））；
返回桥；
}
公共静态void main（字符串[]args）{
System.out.println（getSum（getFirstExample（））；
System.out.println（getSum（getSecondExample（））；
}
}

哈根

有了一些约束条件，事情可能会变得简单，没有约束条件，事情可能会变得更复杂。有了约束，我的意思是第一座桥应该是真理的源泉。想想这些案例：

[0,1]
[1,2]
[3,4]
[4,5]

（内部连接相同长度的两个部件）

（第一座桥不包括在内）

如果桥接器1+2连接，3+4连接，但不是两部分都连接在一起，会发生什么情况？我是说

[0,1]
[2,3]
[3,4]
[4,5]

假设第一个桥是thruth的来源，您可以尝试以下方法：

public class IslandConnector {
    private final List<Bridge> includedBridges = new ArrayList<>();
    private List<Bridge> excludedBridges;

    public IslandConnector(List<Bridge> bridges) {
        this.excludedBridges = new ArrayList<>();
        for(Bridge bridge : bridges) {
            if(includedBridges.isEmpty()) {
                includedBridges.add(bridge);
            }
            else {
                if(!tryIncludeBridge(bridge)) {
                    excludedBridges.add(bridge);
                }
            }           
        }
    }

    private boolean tryIncludeBridge(Bridge bridge) {
        for(Bridge includedBridge: includedBridges) {
            if(bridge.hasSameS(includedBridge)) {
                includeBridge(bridge);
                return true;
            }
        }

        return false;
    }

    private void includeBridge(Bridge bridge) {
        includedBridges.add(bridge);

        for(Bridge excludedBridge: excludedBridges) {
            if(bridge.hasSameS(excludedBridge)) {
                excludedBridges.remove(excludedBridge);
                includeBridge(excludedBridge);
            }
        }
    }

    public List<Bridge> getIncludedBridges() {
        return includedBridges;
    }

    public static void main(String... args) {
        System.out.println(new IslandConnector(Arrays.asList(
            new Bridge(0, 1),
            new Bridge(1, 2),
            new Bridge(2, 3),
            new Bridge(3, 4)
        )).getIncludedBridges());

        System.out.println(new IslandConnector(Arrays.asList(
            new Bridge(0, 1),
            new Bridge(1, 2),
            new Bridge(3, 4)
        )).getIncludedBridges());

        System.out.println(new IslandConnector(Arrays.asList(
            new Bridge(0, 1),
            new Bridge(2, 3),
            new Bridge(3, 4)
        )).getIncludedBridges());
    }
}

---

使用HashMap尝试此解决方案

public class BridgeSolution {

    public static void main(String[] args) {

        Map<Integer, Integer> bridgeMap = new HashMap<>();

        List<Integer[]> bridges = new ArrayList<>();
        bridges.add(new Integer[]{0, 1});
        bridges.add(new Integer[]{1, 2});
        bridges.add(new Integer[]{2, 3});
        bridges.add(new Integer[]{3, 4});


        for (int i = 0; i < bridges.size(); i++) {
            bridgeMap.put(bridges.get(i)[0], bridges.get(i)[1]);
        }

        Integer start = bridges.get(0)[0];

        Integer value = null;
        Integer sum = start;
        while ((value = bridgeMap.get(start)) != null) {
            sum += value;
            start = value;
        }

        System.out.println(sum);
    }
}

公共类桥接解决方案{
公共静态void main（字符串[]args）{
Map bridgeMap=newhashmap（）；
List bridges=new ArrayList（）；
add（新整数[]{0，1}）；
add（新整数[]{1,2}）；
add（新整数[]{2,3}）；
add（新的整数[]{3,4}）；
对于（int i=0；i

具有以下类别：

public class Graph<V> {
    private static class Edge<VV> {
        private final VV from;
        private final VV to;

        private Edge(VV from, VV to) {
            this.from = from;
            this.to = to;
        }
    }

    private final Set<V> vertices = new HashSet<>();
    private final Collection<Edge<V>> edges = new ArrayList<>();

    public void addEdge(V from, V to) {
        vertices.add(from);
        vertices.add(to);
        edges.add(new Edge(from, to));
    }


    public Set<V> closure(V start) {
        Set<V> result = new HashSet<>();
        closure(start, result);
        return result;
    }

    private void closure(V start, Set<V> seen) {
        if (vertices.contains(start) && !seen.contains(start)) {
            seen.add(start);
            for (Edge<V> e: edges) {
                if (start.equals(e.from)) {
                    closure(e.to, seen);
                }
            }
        }
    }
}

---

试试下面的方法。更改

Bridge

对象以满足您的需求

public class Bridge {
    int start;
    int end;

    public Bridge(int start, int end) {
        this.start = start;
        this.end = end;
    }

    public int getStart() {
        return start;
    }

    public int getEnd() {
        return end;
    }
}

计算总数

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class BridgeSum {
    public static void main(String... args) throws IOException {
        Bridge B1 = new Bridge(0, 1);
        Bridge B2 = new Bridge(1, 2);
        Bridge B3 = new Bridge(2, 4);
        Bridge B4 = new Bridge(4, 8);
        Bridge B5 = new Bridge(8, 9);

        List<Bridge> list = new ArrayList<>();
        list.add(B5);
        list.add(B2);
        list.add(B3);
        list.add(B1);
        list.add(B4);

        list.sort((a, b) -> a.getStart() > b.getStart() ? 0 : -1);

        int sum = 0;
        for (int i = 0; i < list.size(); i++) {
            if (i == 0) {
                sum = sum + list.get(i).getStart() + list.get(i).getEnd();
            } else {
                if (list.get(i).getStart() == list.get(i - 1).getEnd()) {
                    sum = sum + list.get(i).getEnd();
                } else {
                    break;
                }
            }
        }

        System.out.println(sum);
    }
}

import java.io.IOException；
导入java.util.ArrayList；
导入java.util.List；
公共类桥和{
公共静态void main（字符串…参数）引发IOException{
桥B1=新桥（0,1）；
桥梁B2=新桥梁（1,2）；
桥B3=新桥（2,4）；
桥梁B4=新桥梁（4,8）；
桥梁B5=新桥梁（8,9）；
列表=新的ArrayList（）；
列表。添加（B5）；
列表。添加（B2）；
列表。添加（B3）；
列表。添加（B1）；
列表。添加（B4）；
list.sort（（a，b）->a.getStart（）>b.getStart（）？0:-1）；
整数和=0；
对于（int i=0；i

到目前为止，您尝试了什么？我相信这就是所谓的a。有几种算法可以做到这一点。你的问题与循环和列表有点关系，你必须在一个单向图中找到所有连接的节点，然后进行求和，或者它也可以被视为一个通量问题，假设在一条边上，我们用连接的节点的值的和来分配权重（例如[2,3]我们指定了一个权重2+3），您希望在其中找到所有（？）路径及其成本@莫里斯·佩里，观点很好。看看下面沃尔夫的解决方案：这些元素是有序的还是无序的。即[2,3][0,1][3,4][1,2]给出的是10还是5？[2,3][0,1][1,2][3,4]预期结果是什么？5.或者10？只是一个注释：“实际”与“当前”的意思不一样，尽管人们可能会认为，当来自德语单词“aktuell”时。这就是为什么变量名

actualStart

和

actuallend

的用法有点混乱。谢谢！“bridge.hasSameS（…）”方法到底是做什么的？？？你是怎么知道黑根的=DI做了同样的项目（我想大概是2年前），听起来很熟悉（我知道它现在又是课程的主题）。hasSameS（）只检查两座桥是否有一个相同的岛。它会检查s1-s2的任何组合。s1-s1，s2-s1，s2-s2 PS：我有一个完全不同的方法，我永远不会需要像上面的代码这样的东西。但我很高兴，只要

    Graph<Integer> graph = new Graph<>();
    graph.addEdge(0,1);
    graph.addEdge(1,2);
    graph.addEdge(3,4);
    int sum = 0;
    for (int v: graph.closure(0)) {
        System.out.println("Vertex: " + v);
        sum += v;
    }
    System.out.println("Sum: " + sum);

Vertex: 0
Vertex: 1
Vertex: 2
Sum: 3

public class Bridge {
    int start;
    int end;

    public Bridge(int start, int end) {
        this.start = start;
        this.end = end;
    }

    public int getStart() {
        return start;
    }

    public int getEnd() {
        return end;
    }
}

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class BridgeSum {
    public static void main(String... args) throws IOException {
        Bridge B1 = new Bridge(0, 1);
        Bridge B2 = new Bridge(1, 2);
        Bridge B3 = new Bridge(2, 4);
        Bridge B4 = new Bridge(4, 8);
        Bridge B5 = new Bridge(8, 9);

        List<Bridge> list = new ArrayList<>();
        list.add(B5);
        list.add(B2);
        list.add(B3);
        list.add(B1);
        list.add(B4);

        list.sort((a, b) -> a.getStart() > b.getStart() ? 0 : -1);

        int sum = 0;
        for (int i = 0; i < list.size(); i++) {
            if (i == 0) {
                sum = sum + list.get(i).getStart() + list.get(i).getEnd();
            } else {
                if (list.get(i).getStart() == list.get(i - 1).getEnd()) {
                    sum = sum + list.get(i).getEnd();
                } else {
                    break;
                }
            }
        }

        System.out.println(sum);
    }
}