CCF-CSP 201709-4通讯网络

问题描述
　　某国的军队由N个部门组成，为了提升安全性，部门之间创建了M条通路，每条通路只能单向传递信息，即一条从部门a到部门b的通路只能由a向b传递信息。信息能够经过中转的方式进行传递，即若是a能将信息传递到b，b又能将信息传递到c，则a能将信息传递到c。一条信息可能经过屡次中转最终到达目的地。
　　因为保密工做作得很好，并非全部部门之间都互相知道彼此的存在。只有当两个部门之间能够直接或间接传递信息时，他们才彼此知道对方的存在。部门之间不会把本身知道哪些部门告诉其余部门。

　　上图中给了一个4个部门的例子，图中的单向边表示通路。部门1能够将消息发送给全部部门，部门4能够接收全部部门的消息，因此部门1和部门4知道全部其余部门的存在。部门2和部门3之间没有任何方式能够发送消息，因此部门2和部门3互相不知道彼此的存在。
　　如今请问，有多少个部门知道全部N个部门的存在。或者说，有多少个部门所知道的部门数量（包括本身）正好是N。
输入格式
　　输入的第一行包含两个整数N, M，分别表示部门的数量和单向通路的数量。全部部门从1到N标号。
　　接下来M行，每行两个整数a, b，表示部门a到部门b有一条单向通路。
输出格式
　　输出一行，包含一个整数，表示答案。
样例输入
4 4
1 2
1 3
2 4
3 4
样例输出
2
样例说明
　　部门1和部门4知道全部其余部门的存在。
评测用例规模与约定
　　对于30%的评测用例，1 ≤ N ≤ 10，1 ≤ M ≤ 20；
　　对于60%的评测用例，1 ≤ N ≤ 100，1 ≤ M ≤ 1000；
　　对于100%的评测用例，1 ≤ N ≤ 1000，1 ≤ M ≤ 10000。

解题思路：

      用一个isconnect二维数组来存储两边是否可以相互到达，能为1，不能为0，而后用dfs遍历全部的点，

首先声明，dfs必定会便利全部的和它互通的点的 是吧！<*-*>

代码以下：

import java.util.Scanner;

public class communication1 {
 
     static int isconnect[][] = new int [1001][1001];
     
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
    Scanner sc = new Scanner(System.in);
    int result=0;
    int n = sc.nextInt();
    int m = sc.nextInt();
    int a[][] = new int[m][2];
    for(int i= 0 ; i < m ; i++){
        a[i][0]=sc.nextInt();
        a[i][1]=sc.nextInt();
    }
    
    for(int v = 1 ;v<=n ; v++){
         int book[] = new int [n+1];
         dfs(v,a,n,v,book,m);
    }
    for(int i = 1;i<=n;i++){
        for(int j = 1;j<=n;j++){
            if(isconnect[i][j]==0)
                break;    
            if(j==n)          //在矩阵中找到与其余全部点都相连的点
                result++;
        }
   
    }
    System.out.println(result);
    
    }

    private static void dfs(int v, int[][] a, int n, int cur, int book[],int m) {
        // TODO Auto-generated method stub
        isconnect[v][cur]=isconnect[cur][v]=1;
        for(int j = 0; j<m ; j++){
            if(a[j][0]==cur&&book[a[j][1]]==0){
                book[cur]=1;         //标记
                cur=a[j][1];            //点的移动
                isconnect[v][cur]=isconnect[cur][v]=1;
                dfs(v,a,n,cur,book,m);         //这里能够取消标记也能够不取消标记的
                cur=a[j][0];            //回到上一次的出发点
            }
        }
    }
}
可是很遗憾，这样作复杂度过高了，只能拿到60分

解法二：

解题思路：运用邻接表的思想，不了解的能够先了解一下邻接表的基本概念<*-*>,邻接表对于稀疏图仍是有优点的，而后一样用dfs遍历。

代码以下：

import java.util.Scanner;
import java.util.ArrayList;

public class communication{

    static int [][]isconnect = new int[1024][1024];
    @SuppressWarnings("rawtypes")
    static ArrayList[]arraylist= new ArrayList[1024];
    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int result=0;
        int n = sc.nextInt();
        int m = sc.nextInt();
        for(int i = 1; i<=n ;i++ ){
            arraylist[i]=new ArrayList<Integer>();
        }
        for(int i=0; i<m ; i++){
            int s,e;
            s=sc.nextInt();
            e=sc.nextInt();
            arraylist[s].add(e);        //该图为有向图，数组下标为起始点，对应集合中的元素为和它相连的终点
        }
        for(int i = 1;i<=n;i++){        //对每一个点做为出发点进行遍历
            int[] book = new int [n+1];       
            dfs(book,i,i,i);
        }
        for(int i = 1; i<=n ; i++){
            int j ;
            for(j = 1;j<=n;j++){
               if(isconnect[i][j]==0){
                break;  
               }
            if(j==n){
               result++;
             }   
            }
        }
        System.out.println(result);
    }
    
        public static void dfs(int book[],int cur,int v,int mid){
            book[cur]=1;
            isconnect[v][cur]=isconnect[cur][v]=1;
            for(int i = 0 ; i<arraylist[cur].size() ; i++){
                if(book[Integer.parseInt(String.valueOf(arraylist[cur].get(i)))]==0){
                    mid = cur;          
                    cur=Integer.parseInt(String.valueOf(arraylist[cur].get(i)));
                    dfs(book,cur,v,mid);              //这里不必要取消标记，由于咱们是要
                    cur=mid;                    
                }
            }
        }
    }

这样就下降了算法复杂度，就拿到100分啦！<*-*>