Solutions

Author: trinhminhtriet

solutions/3600-3699/3648.minimum-sensors-to-cover-grid/Solution.java

@@ -0,0 +1,8 @@
+class Solution {
+    public int minSensors(int n, int m, int k) {
+        int size = k * 2 + 1;
+        int x = n / size + (n % size == 0 ? 0 : 1);
+        int y = m / size + (m % size == 0 ? 0 : 1);
+        return x * y;
+    }
+}

solutions/3600-3699/3649.number-of-perfect-pairs/Solution.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    long long perfectPairs(vector<int>& nums) {
+        int n = nums.size();
+
+        vector<long long> arr;
+        for(auto num : nums){
+            long long x = num;
+            arr.push_back(abs(x));
+        }
+        sort(arr.begin(), arr.end());
+
+        long long count = 0;
+        int j = 0;
+
+        for(int i = 0; i < n; i++){
+            while(j < n && arr[j] <= 2 * arr[i]){
+                j++;
+            }
+            count += (j - i - 1);
+        }
+        return count;
+    }
+};

solutions/3600-3699/3649.number-of-perfect-pairs/Solution.java

@@ -0,0 +1,20 @@
+class Solution {
+    public long perfectPairs(int[] nums) {
+        int n = nums.length;
+        long[] arr = new long[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = Math.abs((long) nums[i]);
+        }
+        java.util.Arrays.sort(arr);
+
+        long count = 0;
+        int j = 0;
+        for (int i = 0; i < n; i++) {
+            while (j < n && arr[j] <= 2 * arr[i]) {
+                j++;
+            }
+            count += (j - i - 1);
+        }
+        return count;
+    }
+}

solutions/3600-3699/3650.minimum-cost-path-with-edge-reversals/Solution.java

@@ -0,0 +1,40 @@
+class Solution {
+    private static final int INF = Integer.MAX_VALUE / 2;
+    
+    public int minCost(int n, int[][] edges) {
+        var graph = new ArrayList<List<int[]>>();
+        for (int i = 0; i < n; i++) {
+            graph.add(new ArrayList<>());
+        }
+        
+        for (int[] edge : edges) {
+            int from = edge[0], to = edge[1], cost = edge[2];
+            graph.get(from).add(new int[]{to, cost});
+            graph.get(to).add(new int[]{from, cost * 2});
+        }
+        
+        int[] d = new int[n];
+        Arrays.fill(d, INF);
+        d[0] = 0;
+        
+        var q = new PriorityQueue<int[]>((p1, p2) -> 
+            p1[0] == p2[0] ? Integer.compare(p1[1], p2[1]) : Integer.compare(p1[0], p2[0]));
+        q.offer(new int[]{0, 0});
+        
+        while (!q.isEmpty()) {
+            int[] curr = q.poll();
+            int distance = curr[0], from = curr[1];
+            if (distance > d[from]) continue;
+            
+            for (int[] edge : graph.get(from)) {
+                int to = edge[0], cost = edge[1];
+                if (d[to] > d[from] + cost) {
+                    d[to] = d[from] + cost;
+                    q.offer(new int[]{d[to], to});
+                }
+            }
+        }
+        
+        return d[n - 1] == INF ? -1 : d[n - 1];
+    }
+}

solutions/3600-3699/3651.minimum-cost-path-with-teleportations/Solution.java

@@ -0,0 +1,61 @@
+class Solution {
+    public int minCost(int[][] grid, int k) {
+        int m=grid.length;
+        int n=grid[0].length;
+        int[][][]dp=new int[m+1][n+1][k+1];
+
+        for(int i=0;i<=m;i++){
+            for(int j=0;j<=n;j++){
+                for(int l=0;l<=k;l++){
+                    dp[i][j][l]=(int)1e9;
+                }
+            }
+        }
+
+        int N=(int)1e4;
+        int[]pbest=new int[N+1];
+        Arrays.fill(pbest,(int)1e9);
+
+        for(int l=0;l<=k;l++){
+            int[]currbest=new int[N+1];
+            Arrays.fill(currbest,(int)1e9);
+            for(int i=m-1;i>=0;i--){
+                for(int j=n-1;j>=0;j--){
+                
+                    // base case
+                    if(i==m-1 && j==n-1){
+                        dp[i][j][l]=0;
+                        
+                    }
+
+                    // transitions
+                    else{
+                        int mini=(int)1e9;
+                        if(i+1<=m-1) mini=Math.min(mini,grid[i+1][j]+dp[i+1][j][l]);
+                        if(j+1<=n-1) mini=Math.min(mini,grid[i][j+1]+dp[i][j+1][l]);
+                        if(l>0){
+                            mini=Math.min(mini,0+pbest[grid[i][j]] );
+                        }
+                        dp[i][j][l]=mini;
+                    }
+                    currbest[grid[i][j]]=Math.min(currbest[grid[i][j]],dp[i][j][l]);
+
+
+                }
+            }
+
+          
+            pbest=new int[N+1];
+            Arrays.fill(pbest,(int)1e9);
+            pbest[0]=currbest[0];
+            
+            for(int i=1;i<=N;i++){
+                pbest[i]=Math.min(pbest[i-1],currbest[i]);
+            }
+
+        }
+
+        return dp[0][0][k];
+
+    }
+}

solutions/3600-3699/3653.xor-after-range-multiplication-queries-i/Solution.java

@@ -0,0 +1,20 @@
+class Solution {
+    private static final int MOD = 1000000007;
+    public int xorAfterQueries(int[] nums, int[][] q) {
+        for (int[] query : q) {
+            int l = query[0];
+            int r = query[1];
+            int k = query[2];
+            int v = query[3];
+            while (l <= r) {
+                nums[l] = (int)(((long)nums[l] * v) % MOD);
+                l += k;
+            }
+        }
+        int ans = 0;
+        for (int num : nums) {
+            ans ^= num;
+        }
+        return ans;
+    }
+}

solutions/3600-3699/3654.minimum-sum-after-divisible-sum-deletions/Solution.java

@@ -0,0 +1,14 @@
+class Solution {
+    public long minArraySum(int[] A, int k) {
+        long[] dp = new long[k];
+        Arrays.fill(dp, Long.MAX_VALUE);
+        dp[0] = 0;
+        long res = 0;
+        for (int a : A) {
+            res += a;
+            int index = (int) (res % k);
+            res = dp[index] = Math.min(dp[index], res);
+        }
+        return res;
+    }
+}