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分啦！<*-*>