From 262a300d0d7eedef11f999ac0d2b8bdf0d1762e2 Mon Sep 17 00:00:00 2001
From: "i-dhanyasri.grandhi" <dhanyasri.grandhi@webileapps.com>
Date: Sun, 21 Sep 2025 15:13:53 +0530
Subject: [PATCH] Completed

---
 Problem1.java | 25 +++++++++++++++++++++++++
 Problem2.java | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 74 insertions(+)
 create mode 100644 Problem1.java
 create mode 100644 Problem2.java

diff --git a/Problem1.java b/Problem1.java
new file mode 100644
index 0000000..2a1091f
--- /dev/null
+++ b/Problem1.java
@@ -0,0 +1,25 @@
+
+//Time Complexity: O(n)
+//Space Complexity: O(n)    
+
+//when we visualize it is a graph problem and the judge will have n-1 indegree and 0 outdegree
+//so we can use an array to keep track of the trust count for each person
+//if a person trusts someone we decrement their count and if they are trusted by someone we increment their count
+//at the end we check if any person has a count of n-1, if yes we return that person's label
+//otherwise we return -1
+
+class Solution {
+    public int findJudge(int n, int[][] trust) {
+        int arr[]=new int[n+1];
+
+        for(int i=0;i<trust.length;i++){
+            arr[trust[i][0]]--;
+            arr[trust[i][1]]++;
+        }
+        for(int i=1;i<=n;i++){
+            if(arr[i]==n-1)
+                return i;
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/Problem2.java b/Problem2.java
new file mode 100644
index 0000000..41bc4ee
--- /dev/null
+++ b/Problem2.java
@@ -0,0 +1,49 @@
+
+//Time Complexity: O(m*n) where m is the number of rows and n is the number of columns in the maze
+//Space Complexity: O(m*n) in the worst case we might have to store all the elements in the queue
+
+//BFS approach
+//we use a queue to keep track of the cells to be processed
+//we also use a directions array to keep track of the 4 possible directions we can move in
+//we start from the start cell and mark it as visited by changing its value to -1
+//we then process each cell in the queue and for each cell we try to move in all 4 directions until we hit a wall or the boundary of the maze
+//we then check if the cell we reached is the destination cell, if yes we return true
+
+class Solution {
+    int[][] dirs;
+    int m,n;
+    
+    public boolean hasPath(int[][] maze, int[] start, int[] destination) {
+        this.dirs = new int[][]{{-1,0},{1,0},{0,1},{0,-1}};
+        this.m = maze.length;
+        this.n = maze[0].length;
+
+        Queue<int[]> q = new LinkedList<>();
+        q.add(new int[]{start[0], start[1]});
+        maze[start[0]][start[1]] = -1;
+
+        while(!q.isEmpty()){
+            int[] curr = q.poll();
+            for(int[] dir: dirs){
+                int r = dir[0] + curr[0];
+                int c = dir[1] + curr[1];
+
+                while(r>=0 && c>=0 && r<m && c<n && maze[r][c] != 1){
+                    r += dir[0];
+                    c += dir[1];
+                }
+                
+                r -= dir[0];
+                c -= dir[1];
+
+                if(r == destination[0] && c == destination[1]) return true;
+                if(maze[r][c] != -1){
+                    q.add(new int[]{r,c});
+                    maze[r][c] = -1;
+                }
+            }
+        }
+
+        return false;
+    }
+}