Add files via upload

Author: JanaSabuj

1046/main.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int lastStoneWeight(vector<int>& stones) {
+        priority_queue<int> pq;
+        for (auto x : stones)
+            pq.push(x);
+
+        while (pq.size() >= 2) {
+            int a = pq.top(); pq.pop();
+            int b = pq.top(); pq.pop();
+
+            if (a == b)
+                continue;
+            else
+                pq.push(a - b);
+        }
+
+        if (pq.empty())
+            return 0;
+        else
+            return pq.top();
+    }
+};

1046/main.java

@@ -0,0 +1,22 @@
+class Solution {
+	public int lastStoneWeight(int[] stones) {
+		PriorityQueue<Integer> pq = new PriorityQueue<>(31, Collections.reverseOrder());
+		for (int x : stones)
+			pq.add(x);
+
+		while (pq.size() >= 2) {
+			int a = pq.poll();
+			int b = pq.poll();
+
+			if (a == b)
+				continue;
+			else
+				pq.add(a - b);
+		}
+
+		if (pq.size() == 0)
+			return 0;
+		else
+			return pq.peek();
+	}
+}

1046/main.py

@@ -0,0 +1,15 @@
+class Solution:
+    def lastStoneWeight(self, stones: List[int]) -> int:
+        h = [-x for x in stones]
+        heapq.heapify(h)
+
+        while len(h) >= 2:
+        	a = heapq.heappop(h)
+        	b = heapq.heappop(h)
+
+        	heapq.heappush(h, a - b)
+
+        if len(h) == 0:
+        	return 0
+        else:
+        	return -h[0]

1049/main.cpp

@@ -0,0 +1,37 @@
+class Solution {
+public:
+	int lastStoneWeightII(vector<int>& stones) {
+		// + + - - + - + -
+		int sum = 0;
+		for (int x : stones)
+			sum += x;
+		int m = sum / 2;
+		int n = stones.size();
+
+		vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
+		for (int i = 0; i <= n; i++) {
+			for (int j = 0; j <= m; j++) {
+				if (i == 0 and j == 0)
+					dp[i][j] = 1;
+				else if (i == 0)
+					dp[i][j] = 0;
+				else if (j == 0)
+					dp[i][j] = 1;
+				else if (stones[i - 1] <= j)
+					dp[i][j] = dp[i - 1][j - stones[i - 1]] || dp[i - 1][j];
+				else
+					dp[i][j] = dp[i - 1][j];
+			}
+		}
+
+		int ans = 0;
+		for (int j = m; j >= 0; j--) {
+			if (dp[n][j]) {
+				ans = j;
+				break;
+			}
+		}
+
+		return sum - 2 * ans;
+	}
+};

1049/main.java

@@ -0,0 +1,38 @@
+class Solution {
+	public int lastStoneWeightII(int[] stones) {
+		// + + - - + - + -
+		int sum = 0;
+		for (int x : stones)
+			sum += x;
+		int m = sum / 2;
+		int n = stones.length;
+
+		// vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
+		int[][] dp = new int[n + 1][m + 1];
+
+		for (int i = 0; i <= n; i++) {
+			for (int j = 0; j <= m; j++) {
+				if (i == 0 && j == 0)
+					dp[i][j] = 1;
+				else if (i == 0)
+					dp[i][j] = 0;
+				else if (j == 0)
+					dp[i][j] = 1;
+				else if (stones[i - 1] <= j)
+					dp[i][j] = dp[i - 1][j - stones[i - 1]] | dp[i - 1][j];
+				else
+					dp[i][j] = dp[i - 1][j];
+			}
+		}
+
+		int ans = 0;
+		for (int j = m; j >= 0; j--) {
+			if (dp[n][j] != 0) {
+				ans = j;
+				break;
+			}
+		}
+
+		return sum - 2 * ans;
+	}
+}

1049/main.py

@@ -0,0 +1,30 @@
+class Solution:
+    def lastStoneWeightII(self, stones: List[int]) -> int:
+        sum = 0
+        for x in stones:
+            sum += x
+        m = sum//2
+        n = len(stones)
+
+        dp = [[0 for _ in range(m + 1)] for _ in range(n + 1)]
+
+        for i in range(0, n + 1):
+            for j in range(0, m + 1):                
+                if i == 0 and j == 0:
+                    dp[i][j] = 1
+                elif i == 0:
+                    dp[i][j] = 0
+                elif j == 0:
+                    dp[i][j] = 1
+                elif stones[i - 1] <= j:
+                    dp[i][j] = dp[i - 1][j] | dp[i - 1][j - stones[i - 1]]
+                else:
+                    dp[i][j] = dp[i - 1][j]
+
+        ans = 0
+        for j in range(m, -1, -1):
+            if dp[n][j] != 0:
+                ans = j
+                break
+                
+        return sum - 2 * ans;

221/main.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+	int maximalSquare(vector<vector<char>>& mat) {
+		int n = mat.size();
+		int m = mat[0].size();
+
+		int mx = 0;
+		vector<vector<int>> dp(n, vector<int>(m, 0));
+
+		for (int i = 0; i < n; i++) {
+			for (int j = 0; j < m; ++j) {
+				if (i == 0 || j == 0)
+					dp[i][j] = (mat[i][j] == '0' ? 0 : 1);
+				else if (mat[i][j] == '1')
+					dp[i][j] = min({dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]}) + 1;
+				else
+					dp[i][j] = 0;
+
+				mx = max(mx, dp[i][j]);
+
+			}
+		}
+
+		return mx * mx;// return area
+	}
+};

221/main.java

@@ -0,0 +1,26 @@
+class Solution {
+	public int maximalSquare(char[][] mat) {
+		int n = mat.length;
+		int m = mat[0].length;
+
+		int mx = 0;
+		// vector<vector<int>> vec(n, vector<int>(m, 0));
+		int[][] dp = new int[n][m];
+
+		for (int i = 0; i < n; i++) {
+			for (int j = 0; j < m; ++j) {
+				if (i == 0 || j == 0)
+					dp[i][j] = (mat[i][j] == '0' ? 0 : 1);
+				else if (mat[i][j] == '1')
+					dp[i][j] = Math.min(dp[i - 1][j], Math.min(dp[i][j - 1], dp[i - 1][j - 1])) + 1;
+				else
+					dp[i][j] = 0;
+
+				mx = Math.max(mx, dp[i][j]);
+
+			}
+		}
+
+		return mx * mx;// return area
+	}
+}

221/main.py

@@ -0,0 +1,20 @@
+class Solution:
+    def maximalSquare(self, mat: List[List[str]]) -> int:
+        n = len(mat)
+        m = len(mat[0])
+
+        mx = 0
+        dp = [[0 for _ in range(m)] for _ in range(n)]
+
+        for i in range(n):
+            for j in range(m):
+                if i == 0 or j == 0:
+                    dp[i][j] = 0 if mat[i][j] == "0" else 1
+                elif mat[i][j] == "1":
+                    dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1
+                else:
+                    dp[i][j] = 0
+
+                mx = max(mx, dp[i][j])
+
+        return mx*mx

279/main.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int numSquares(int n) {
+        vector<int> f(n + 1);
+        f[0] = 0;
+        f[1] = 1;
+        for (int i = 2; i <= n; i++) {
+            f[i] = f[i - 1] + 1;
+            for (int j = 1; j * j <= i; j++)
+                f[i] = min(f[i], f[i - j * j] + 1);
+        }
+
+        return f[n];
+    }
+};

279/main.java

@@ -0,0 +1,16 @@
+class Solution {
+    public int numSquares(int n) {
+        // vector<int> f(n + 1);
+        int[] f = new int[n + 1];
+        f[0] = 0;
+        f[1] = 1;
+
+        for (int i = 2; i <= n; i++) {
+            f[i] = f[i - 1] + 1;
+            for (int j = 1; j * j <= i; j++)
+                f[i] = Math.min(f[i], f[i - j * j] + 1);
+        }
+
+        return f[n];
+    }
+}

279/main.py

@@ -0,0 +1,13 @@
+class Solution:
+    def numSquares(self, n: int) -> int:
+        f = [None] * (n + 1)
+        f[0]=0
+        f[1]=1
+        for i in range(2, n+1):
+            f[i] = f[i-1]+1
+            for j in range(1, i):
+                if j * j <= i:
+                    f[i] = min(f[i], f[i - j*j] + 1)
+                else:
+                    break
+        return f[n]