<p>In a town, there are <code>n</code> people labeled from <code>1</code> to <code>n</code>. There is a rumor that one of these people is secretly the town judge.</p>

<p>If the town judge exists, then:</p>

<ol>
	<li>The town judge trusts nobody.</li>
	<li>Everybody (except for the town judge) trusts the town judge.</li>
	<li>There is exactly one person that satisfies properties <strong>1</strong> and <strong>2</strong>.</li>
</ol>

<p>You are given an array <code>trust</code> where <code>trust[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> representing that the person labeled <code>a<sub>i</sub></code> trusts the person labeled <code>b<sub>i</sub></code>. If a trust relationship does not exist in <code>trust</code> array, then such a trust relationship does not exist.</p>

<p>Return <em>the label of the town judge if the town judge exists and can be identified, or return </em><code>-1</code><em> otherwise</em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> n = 2, trust = [[1,2]]
<strong>Output:</strong> 2
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> n = 3, trust = [[1,3],[2,3]]
<strong>Output:</strong> 3
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> n = 3, trust = [[1,3],[2,3],[3,1]]
<strong>Output:</strong> -1
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= n &lt;= 1000</code></li>
	<li><code>0 &lt;= trust.length &lt;= 10<sup>4</sup></code></li>
	<li><code>trust[i].length == 2</code></li>
	<li>All the pairs of <code>trust</code> are <strong>unique</strong>.</li>
	<li><code>a<sub>i</sub> != b<sub>i</sub></code></li>
	<li><code>1 &lt;= a<sub>i</sub>, b<sub>i</sub> &lt;= n</code></li>
</ul>

class Solution {
public:
    int DFS(int n , vector<vector<int>>& graph , vector<bool>& visited , vector<int>& hash , int i ){
        if( graph[ i ].size() == 0 ){
          visited[ i ] = true ;   
          if( hash[ i ] == n - 1 ) return 0 ;
          if( hash[ i ] < n - 2 ) hash[ i ] ++ ;  
          else 
          {
            hash[ i ]++;
            return i+1 ;
          }
        }
        if( visited[ i ] == true ) return 0 ;
        visited[ i ] = true ;
        int ans = 0 ;
        for( int j = 0 ; j < graph[ i ].size() ; j++ ) ans += DFS( n , graph , visited , hash , graph[ i ][ j ] - 1 ) ;
        return ans ;
    }
    int findJudge(int n, vector<vector<int>>& trust) {
        if( n == 1 ) return 1 ;
        if( trust.size() == 0 ) return -1 ;
        vector<vector<int>> graph( n ) ;
        vector<int> hash( n , 0 ) ;
        vector<bool> visited( n , 0 ) ; 
        for( int i = 0 ; i < trust.size() ; i++  ) graph[ trust[ i ][ 0 ] - 1 ].push_back( trust[ i ][ 1 ] ) ;
        for( int i = 0 ; i < n ; i++ )
        if( !visited[ i ] )
        {
            int ans = DFS( n , graph , visited , hash , i ) ;
            if( ans ) return ans ;
        }
        return -1 ;
    }
};
60111