/**
 * 深度優(yōu)先搜索示例
 */
public class DFSExample {
    // 定義圖的節(jié)點(diǎn)類
    static class Node {
        int value;
        List< Node> neighbors;

        public Node(int value) {
            this.value = value;
            this.neighbors = new ArrayList<>();
        }

        // 添加鄰接節(jié)點(diǎn)
        public void addNeighbor( Node neighbor) {
            this.neighbors.add(neighbor);
        }
    }

    /**
     * 方式一 ：棧實(shí)現(xiàn)
     * dfs 函數(shù)
     * @param startNode
     */
    public static void dfs( Node startNode) {

        if(startNode == null ) return;
        // 使用隊(duì)列存儲(chǔ)待訪問的節(jié)點(diǎn)
        Stack<Node> stack = new Stack<>();

        // 使用HashSet記錄已訪問的節(jié)點(diǎn)
        Set<Node> visited = new HashSet<>();
        // 將起點(diǎn)加入棧并標(biāo)記為已訪問
        stack.push(startNode);
        visited.add(startNode);
        // 遍歷棧
        while (!stack.isEmpty()){
             Node currentNode = stack.pop();
            System.out.println(currentNode.value);
            // 遍歷當(dāng)前節(jié)點(diǎn)的所有鄰接節(jié)點(diǎn)
            for (Node neighbor : currentNode.neighbors) {
                // 如果鄰接節(jié)點(diǎn)未被訪問，則加入棧并標(biāo)記為已訪問
                if (!visited.contains(neighbor)) {
                    stack.add(neighbor);
                    visited.add(neighbor);
                }
            }
        }

    }
    //方式二：遞歸實(shí)現(xiàn)
    public static void sec( Node currentNode,Set<Node> visited) {

        // 標(biāo)記當(dāng)前節(jié)點(diǎn)為已訪問
        visited.add(currentNode);
        System.out.println(currentNode.value);
        // 遞歸訪問所有未訪問的鄰居節(jié)點(diǎn)
        for (Node neighbor : currentNode.neighbors) {
            if (!visited.contains(neighbor))
                sec(neighbor, visited);
        }
    }

    /**
     *
     * @param args
     */
    public static void main(String[] args) {
        Node node1 = new  Node(1);
        Node node2 = new  Node(2);
        Node node3 = new  Node(3);
        Node node4 = new  Node(4);
        Node node5 = new  Node(5);
        Node node6 = new  Node(6);


        node1.addNeighbor(node2);
        node1.addNeighbor(node3);
        node1.addNeighbor(node5);

        node2.addNeighbor(node1);
        node2.addNeighbor(node3);
        node2.addNeighbor(node5);

        node3.addNeighbor(node1);
        node3.addNeighbor(node2);
        node3.addNeighbor(node4);
        node3.addNeighbor(node6);

        node4.addNeighbor(node3);
        node4.addNeighbor(node6);

        node5.addNeighbor(node2);
        node5.addNeighbor(node6);

        node6.addNeighbor(node3);
        node6.addNeighbor(node4);
        node6.addNeighbor(node5);
        //棧實(shí)現(xiàn)
        dfs(node1);
        System.out.println("+++++++++遞歸實(shí)現(xiàn)++++++++++++");
        //遞歸實(shí)現(xiàn)
        Set< Node> visited = new HashSet<>();
        sec(node1,visited);
    }
}

public class DFSServer {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String[] firstLine = scanner.nextLine().split(" ");
        int n = firstLine.length;
        //初始化二維數(shù)組
        int[][] matrix = new int[n][n];
        for (int i = 0; i < n; i++) {
            String[] line = i==0 ? firstLine:scanner.nextLine().split(" ");
            for (int j = 0; j < n; j++) {
                matrix[i][j] = Integer.parseInt(line[j]);
            }
        }
        //初始化標(biāo)記數(shù)組
        int[] check = new int[n];
        //需要廣播的服務(wù)器的數(shù)量
        int ans = 0;
        Stack<Integer> stack = new Stack<>();
        // 遍歷每個(gè)服務(wù)器
        for (int i = 0; i < n; i++) {
            // 如果服務(wù)器 i 沒有被訪問過，就以它為起點(diǎn)進(jìn)行 DFS
            if (check[i] == 0) {
                ans++; // 新的連通分量，計(jì)數(shù)器加 1
                stack.add(i); // 將當(dāng)前服務(wù)器加入棧
                check[i] = 1; // 標(biāo)記為已訪問

                // 開始 DFS
                while (!stack.isEmpty()) {
                    // 彈出當(dāng)前服務(wù)器
                    int cur = stack.pop();
                    // 遍歷所有服務(wù)器，找到與 cur 相連且未訪問的服務(wù)器
                    for (int j = 0; j < n; j++) {
                        if (j != cur && matrix[cur][j] == 1 && check[j] == 0) {
                            // 將未訪問的服務(wù)器加入棧
                            stack.push(j);
                            // 將未訪問的服務(wù)器加入棧
                            check[j] = 1;
                        }
                    }
                }
            }
        }

        System.out.println(ans);

    }
}