🚀 15-Oct-2021

Author: sureshmangs

competitive programming/codeforces/313B - Ilya and Queries.cpp

@@ -0,0 +1,90 @@
+/*
+Ilya the Lion wants to help all his friends with passing exams. They need to solve the following problem to pass the IT exam.
+
+You've got string s?=?s1s2... sn (n is the length of the string), consisting only of characters "." and "#" and m queries. Each query is described by a pair of integers li,?ri (1?=?li?<?ri?=?n). The answer to the query li,?ri is the number of such integers i (li?=?i?<?ri), that si?=?si?+?1.
+
+Ilya the Lion wants to help his friends but is there anyone to help him? Help Ilya, solve the problem.
+
+Input
+The first line contains string s of length n (2?=?n?=?105). It is guaranteed that the given string only consists of characters "." and "#".
+
+The next line contains integer m (1?=?m?=?105) — the number of queries. Each of the next m lines contains the description of the corresponding query. The i-th line contains integers li,?ri (1?=?li?<?ri?=?n).
+
+Output
+Print m integers — the answers to the queries in the order in which they are given in the input.
+
+Examples
+inputCopy
+......
+4
+3 4
+2 3
+1 6
+2 6
+outputCopy
+1
+1
+5
+4
+inputCopy
+#..###
+5
+1 3
+5 6
+1 5
+3 6
+3 4
+outputCopy
+1
+1
+2
+2
+0
+
+*/
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+ 
+void solve() {
+	string s;
+	cin >> s;
+	
+	int m;
+	cin >> m;
+	
+	vector <int> v(s.length(), 0);
+	
+	for (int i = 0; i < s.length(); i++) {
+		if (s[i] == s[i + 1]) v[i + 1] = v[i] + 1;
+		else v[i + 1] = v[i];
+	}
+	
+	while (m--) {
+		int l, r;
+		cin >> l >> r;
+		
+		cout << v[r - 1] - v[l - 1] << "\n";
+	}
+	
+}
+ 
+int main(){
+    ios_base::sync_with_stdio(false);
+	cin.tie(NULL);
+	
+	int t = 1;
+	//cin >> t;
+	
+	while (t--)  solve();
+	
+    return 0;
+}
+
+
+

competitive programming/leetcode/1448. Count Good Nodes in Binary Tree.cpp

@@ -0,0 +1,83 @@
+Given a binary tree root, a node X in the tree is named good if in the path 
+from root to X there are no nodes with a value greater than X.
+
+Return the number of good nodes in the binary tree.
+
+ 
+
+Example 1:
+
+
+
+Input: root = [3,1,4,3,null,1,5]
+Output: 4
+Explanation: Nodes in blue are good.
+Root Node (3) is always a good node.
+Node 4 -> (3,4) is the maximum value in the path starting from the root.
+Node 5 -> (3,4,5) is the maximum value in the path
+Node 3 -> (3,1,3) is the maximum value in the path.
+Example 2:
+
+
+
+Input: root = [3,3,null,4,2]
+Output: 3
+Explanation: Node 2 -> (3, 3, 2) is not good, because "3" is higher than it.
+Example 3:
+
+Input: root = [1]
+Output: 1
+Explanation: Root is considered as good.
+ 
+
+Constraints:
+
+The number of nodes in the binary tree is in the range [1, 10^5].
+Each node's value is between [-10^4, 10^4].
+   Hide Hint #1  
+Use DFS (Depth First Search) to traverse the tree, and constantly keep track of the current path maximum.
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    int res = 0;
+    
+    void traversal(TreeNode *root, int maxi) {
+        if (!root) return;
+        
+        if (root->val >= maxi) res++;
+        
+        maxi = max(maxi, root->val);
+        
+        traversal(root->left, maxi);
+        traversal(root->right, maxi);
+    }
+        
+    int goodNodes(TreeNode* root) {
+        if (!root) return res;
+        
+        traversal(root, root->val);
+        
+        return res;
+    }
+};

competitive programming/leetcode/36. Valid Sudoku.cpp

@@ -0,0 +1,108 @@
+Determine if a 9 x 9 Sudoku board is valid. Only the filled cells 
+need to be validated according to the following rules:
+
+Each row must contain the digits 1-9 without repetition.
+Each column must contain the digits 1-9 without repetition.
+Each of the nine 3 x 3 sub-boxes of the grid must contain the digits 1-9 without repetition.
+Note:
+
+A Sudoku board (partially filled) could be valid but is not necessarily solvable.
+Only the filled cells need to be validated according to the mentioned rules.
+ 
+
+Example 1:
+
+
+Input: board = 
+[["5","3",".",".","7",".",".",".","."]
+,["6",".",".","1","9","5",".",".","."]
+,[".","9","8",".",".",".",".","6","."]
+,["8",".",".",".","6",".",".",".","3"]
+,["4",".",".","8",".","3",".",".","1"]
+,["7",".",".",".","2",".",".",".","6"]
+,[".","6",".",".",".",".","2","8","."]
+,[".",".",".","4","1","9",".",".","5"]
+,[".",".",".",".","8",".",".","7","9"]]
+Output: true
+Example 2:
+
+Input: board = 
+[["8","3",".",".","7",".",".",".","."]
+,["6",".",".","1","9","5",".",".","."]
+,[".","9","8",".",".",".",".","6","."]
+,["8",".",".",".","6",".",".",".","3"]
+,["4",".",".","8",".","3",".",".","1"]
+,["7",".",".",".","2",".",".",".","6"]
+,[".","6",".",".",".",".","2","8","."]
+,[".",".",".","4","1","9",".",".","5"]
+,[".",".",".",".","8",".",".","7","9"]]
+Output: false
+Explanation: Same as Example 1, except with the 5 in the top left corner being 
+modified to 8. Since there are two 8's in the top left 3x3 sub-box, it is invalid.
+ 
+
+Constraints:
+
+board.length == 9
+board[i].length == 9
+board[i][j] is a digit or '.'.
+
+
+
+
+
+
+
+class Solution {
+public:
+    
+    bool checkRow(vector<vector<char>>& board) {
+        for (int j = 0; j < 9; j++) {
+            vector <int> freq(10, 0);
+            for (int i = 0; i < 9; i++) {
+                if (board[i][j] == '.') continue;
+                freq[board[i][j] - '0']++;
+            }
+            for (auto &x: freq) {
+                if (x > 1) return false; // multiple same elements in one column
+            }
+        }
+        return true;
+    }
+    
+    bool checkCol(vector<vector<char>>& board) {
+        for (int i = 0; i < 9; i++) {
+            vector <int> freq(10, 0);
+            for (int j = 0; j < 9; j++) {
+                if (board[i][j] == '.') continue;
+                freq[board[i][j] - '0']++;
+            }
+            for (auto &x: freq) {
+                if (x > 1) return false; // multiple same elements in one row
+            }
+        }
+        return true; 
+    }
+    
+    bool checkSubBox(vector<vector<char>>& board) {
+        for (int i = 0; i < 9; i += 3) {
+            for (int j = 0; j < 9; j += 3) {
+                vector <int> freq(10, 0);
+                for (int p = i; p < i + 3; p++){
+                    for (int q = j; q < j + 3; q++) {
+                        if (board[p][q] == '.') continue;
+                        freq[board[p][q] - '0']++;
+                    }
+                }
+                for (auto &x: freq) {
+                    if (x > 1) return false; // multiple same elements in one sub box
+                }
+            }
+        }
+        return true;
+    }
+    
+    bool isValidSudoku(vector<vector<char>>& board) {
+        return checkRow(board) && checkCol(board) && checkSubBox(board);
+    }
+};