class Solution {
public:
string losingPlayer(int x, int y)
{
int cnt = 0;
while (x > 0 && y > 3)
{
x -= 1;
y -= 4;
++cnt;
}
return cnt % 2 == 1 ? "Alice" : "Bob";
}
};
Hint
class Solution {
public:
int minimumCost(int m, int n, vector<int>& horizontalCut, vector<int>& verticalCut)
{
// Sorting the cuts in descending order to start from the largest piece
// Counters for horizontal and vertical pieces
// Variable to accumulate the minimum cost
// Loop until we have processed all possible cuts
while ()
{
// Compare the current largest horizontal cut with the current largest vertical cut
if ()
{
// Add the cost of the horizontal cut multiplied by the number of vertical pieces + 1
}
else
{
// Add the cost of the vertical cut multiplied by the number of horizontal pieces + 1
}
}
// If there are remaining horizontal cuts, add their costs
while ()
{
}
// If there are remaining vertical cuts, add their costs
while ()
{
}
// Return the accumulated minimum cost
}
};
#define ll long long
class Solution {
public:
long long minimumCost(int m, int n, vector<int>& horizontalCut, vector<int>& verticalCut)
{
// 因為會越切越多塊，所以 cost 要由大往小排
sort(horizontalCut.begin(), horizontalCut.end(), greater<int>());
sort(verticalCut.begin(), verticalCut.end(), greater<int>());
int hPieces = 0, vPieces = 0;
ll minCost = 0;
while (hPieces < m - 1 && vPieces < n - 1)
{
if (horizontalCut[hPieces] > verticalCut[vPieces])
{
minCost += horizontalCut[hPieces++] * (vPieces + 1);
}
else
{
minCost += verticalCut[vPieces++] * (hPieces + 1);
}
}
while (hPieces < m - 1)
{
minCost += horizontalCut[hPieces++] * (vPieces + 1);
}
while (vPieces < n - 1)
{
minCost += verticalCut[vPieces++] * (hPieces + 1);
}
return minCost;
}
};
Hint
class Solution {
public:
int minimumCost(int m, int n, vector<int>& horizontalCut, vector<int>& verticalCut)
{
// Sorting the cuts in descending order to start from the largest piece
// Counters for horizontal and vertical pieces
// Variable to accumulate the minimum cost
// Loop until we have processed all possible cuts
while ()
{
// Compare the current largest horizontal cut with the current largest vertical cut
if ()
{
// Add the cost of the horizontal cut multiplied by the number of vertical pieces + 1
}
else
{
// Add the cost of the vertical cut multiplied by the number of horizontal pieces + 1
}
}
// If there are remaining horizontal cuts, add their costs
while ()
{
}
// If there are remaining vertical cuts, add their costs
while ()
{
}
// Return the accumulated minimum cost
}
};
class Solution {
public:
int minimumCost(int m, int n, vector<int>& horizontalCut, vector<int>& verticalCut)
{
sort(horizontalCut.begin(), horizontalCut.end(), greater<int>());
sort(verticalCut.begin(), verticalCut.end(), greater<int>());
int hPieces = 0, vPieces = 0;
int minCost = 0;
while (hPieces < m - 1 && vPieces < n - 1)
{
if (horizontalCut[hPieces] > verticalCut[vPieces])
{
minCost += horizontalCut[hPieces++] * (vPieces + 1);
}
else
{
minCost += verticalCut[vPieces++] * (hPieces + 1);
}
}
while (hPieces < m - 1)
{
minCost += horizontalCut[hPieces++] * (vPieces + 1);
}
while (vPieces < n - 1)
{
minCost += verticalCut[vPieces++] * (hPieces + 1);
}
return minCost;
}
};
Hint
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* modifiedList(vector<int>& nums, ListNode* head)
{
// Create an unordered set from the input vector nums for quick lookup
// Create a dummy node to serve as the new list's head
// Initialize a pointer to the dummy node for constructing the new list
// Initialize a pointer to traverse the original list
// Traverse the original list
while ()
{
// If the current node's value is not in the set, add it to the new list
if ()
{
// Create a new node with the current node's value and link it to the new list
// Move the prev pointer to the newly created node
}
// Move to the next node in the original list
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* modifiedList(vector<int>& nums, ListNode* head)
{
unordered_set<int> st(nums.begin(), nums.end());
ListNode* dummy = new ListNode();
ListNode* prev = dummy;
ListNode* cur = head;
while (cur)
{
if (!st.count(cur->val))
{
prev->next = new ListNode(cur->val);
prev = prev->next;
}
cur = cur->next;
}
return dummy->next;
}
};
Hint
class Solution {
public:
string getSmallestString(string s)
{
// Iterate through the string from the beginning to the second last character
for ()
{
// Check if both current and next characters have the same parity (both even or both odd)
// and if the current character is greater than the next character
if ()
{
// Swap the current character with the next one
// Exit the loop after the first swap
}
}
// Return the modified string
}
};
class Solution {
public:
string getSmallestString(string s)
{
for (int i = 0; i < s.size() - 1; ++i)
{
if (s[i] % 2 == s[i + 1] % 2 && s[i] > s[i + 1])
{
swap(s[i], s[i + 1]); break;
}
}
return s;
}
};
#define ll long long
class Solution {
public:
long long countSubarrays(vector<int>& nums, int k)
{
unordered_map<int, ll> map;
ll res = 0;
for (int x : nums)
{
unordered_map<int, long long> map2;
for (auto& [y, count] : map)
{
map2[y & x] += count;
}
map2[x] += 1;
map = map2;
res += map[k];
}
return res;
}
};
Extend the Array: To handle the circular nature of the array, extend the colors array by appending the first k-1 elements to its end. This allows us to easily check for alternating groups that wrap around the end of the array.
Initialize Counters:
res to store the number of alternating groups.cnt to count the length of the current alternating group.Iterate Through the Extended Array:
cnt counter.cnt counter to 1.cnt counter reaches k, increment the res counter as it indicates the end of an alternating group.Return the Result: Finally, return the res counter, which represents the number of alternating groups of length k.
class Solution {
public:
int numberOfAlternatingGroups(vector<int>& colors, int k)
{
for (int i = 0; i < k - 1; ++i)
{
colors.push_back(colors[i]);
}
int res = 0;
// cnt 用來記錄長度是否達到 k
int cnt = 1;
for (int i = 1; i < colors.size(); ++i)
{
// 如果是交錯的格子，則 cnt++
if (colors[i] != colors[i - 1])
{
++cnt;
}
else
{
// 如果不是交錯的格子，則 reset cnt= 1
cnt = 1;
}
// 如果 cnt 達到 k，則結果 + 1
if (cnt >= k) ++res;
}
return res;
}
};
#define ll long long
class Solution {
public:
long long maximumPoints(vector<int>& enemyEnergies, int currentEnergy)
{
sort(enemyEnergies.begin(), enemyEnergies.end());
int n = enemyEnergies.size();
if (currentEnergy < enemyEnergies[0]) return 0;
ll availableEngergy = currentEnergy;
for (int j = n - 1; j > 0; --j)
{
availableEngergy += enemyEnergies[j];
}
return availableEngergy / enemyEnergies[0];
}
};
class Solution {
public:
int numberOfAlternatingGroups(vector<int>& colors)
{
int n = colors.size();
for (int i = 0; i < n; ++i)
{
colors.push_back(colors[i]);
}
int cnt = 0;
for (int i = 0; i < n; ++i)
{
if (colors[i] == colors[i + 2] && colors[i] != colors[i + 1])
{
++cnt;
}
}
return cnt;
}
};