1.9万

noobcoder
jwh
Draper
Unnatural
heMing_zero
Egbert-Lannister.
cjyasleep
Abcdefg123

mainkeys

Kole
heavens.
kwq
Fool_vamp
372_9
KKKKKKKKKKKKKKKKKKKKKK
L-China

## 23.03.24 学习

class Solution {
public:
int maximalRectangle(vector<vector<char>>& matrix) {
int n = matrix.size(), m = matrix[0].size(), res = 0;
vector<int> heights(m, 0);
heights.push_back(-1);

for (int i = 0; i < n; i ++ ) {
for (int j = 0; j < m; j ++ ) {
if (matrix[i][j] == '0') heights[j] = 0;
else heights[j] ++ ;
}
// for (auto x : heights) cout << x << ' ';
// cout << endl;

// 对于每一层的heights都计算一遍res，遍历完m层最大的res就出来了
stack<int> stk;
for (int i = 0; i <= m; i ++ ) {
while (!stk.empty() && heights[i] < heights[stk.top()]) {
auto cur = stk.top();
stk.pop();

if (stk.empty()) res = max(res, heights[cur] * i);
else res = max(res, heights[cur] * (i - stk.top() - 1));
}
stk.push(i);
}
}

return res;
}
};


## 23.03.24 学习

class Solution {
public:
int largestRectangleArea(vector<int>& heights) {
int n = heights.size(), res = 0;
heights.push_back(-1);
stack<int> stk;

for (int i = 0; i <= n; i ++ ) {
while (!stk.empty() && heights[i] < heights[stk.top()]) {
auto cur = stk.top();
stk.pop();

if (stk.empty()) res = max(res, heights[cur] * i);  // 左边没有比他低的柱子
else res = max(res, heights[cur] * (i - stk.top() - 1));
}
stk.push(i);
}

return res;
}
};


## 23.03.24 学习

class Solution {
public:
static bool cmp(vector<int> a, vector<int> b) {
if (a[0] != b[0]) return a[0] > b[0];
return a[1] < b[1];
}

vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
sort(people.begin(), people.end(), cmp);

vector<vector<int>> res;
for(auto p:people) res.insert(res.begin()+p[1],p);

return res;
}
};


## 23.03.23 学习

class Solution {
public:
vector<int> dailyTemperatures(vector<int>& T) {
stack<int> stk;
vector<int> res(T.size());
for (int i = T.size() - 1; i >= 0; i -- ) {
while (stk.size() && T[i] >= T[stk.top()]) stk.pop();
if (stk.size()) res[i] = stk.top() - i;
stk.push(i);
}
return res;
}
};



## 23.03.23 学习

wzc1995大佬太强了，同样的人，向他学习

class Solution {
public:
int leastInterval(vector<char>& tasks, int n) {
vector<int> t(26, 0);
for (auto c : tasks)
t[c - 'A'] ++ ;

priority_queue<int> heap;
for (auto c : t)
if (c != 0)
heap.push(c);

int res = 0;
int interval = n + 1;
while (true) {
vector<int> tmp;
for (int i = 0; i < interval; i ++ ) {
if (!heap.empty()) {
tmp.push_back(heap.top() - 1);
heap.pop();
}
}

for (auto x : tmp) {
if (x)
heap.push(x);
}

if (heap.empty()) {
res += tmp.size();
break;
} else {
res += n + 1;
}
}

return res;
}
};


## 23.03.22 学习

class Solution {
public:
int countSubstrings(string s) {
int res = 0, n = s.size();
for (int i = 0; i < s.size(); i ++ ) {
for (int j = i, k = i; j >= 0 && k < n; j -- , k ++ ) {
if (s[j] != s[k]) break;
res ++ ;
}

for (int j = i, k = i + 1; j >= 0 && k < n; j -- , k ++ ) {
if (s[j] != s[k]) break;
res ++ ;
}
}

return res;
}
};


## 23.03.22 学习

/**
* 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:
TreeNode* mergeTrees(TreeNode* r1, TreeNode* r2) {
if (!r1 && !r2) return NULL;
if (r1 && !r2) return r1;
if (!r1 && r2) return r2;

r1->val += r2->val;
r1->left = mergeTrees(r1->left, r2->left);
r1->right = mergeTrees(r1->right, r2->right);
return r1;
}
};


## 23.03.22 学习

### $O(n)$线性扫描

class Solution {
public:
int findUnsortedSubarray(vector<int>& nums) {
int l = 0, r = nums.size() - 1;
while (l < nums.size() - 1 && nums[l] <= nums[l + 1]) l ++ ;
while (r > l && nums[r - 1] <= nums[r]) r -- ;
cout << l << ' ' << r << endl;
if (l == r) return 0;

for (int i = l + 1; i < nums.size(); i ++ )
while (l >= 0 && nums[i] < nums[l])
l -- ;
for (int i = r - 1; i >= 0; i -- )
while (r < nums.size() && nums[i] > nums[r])
r ++ ;

return r - l - 1;
}
};


### $O(nlogn)$排序

    int findUnsortedSubarray(vector<int>& nums) {
vector<int> temp;
temp.assign(nums.begin(),nums.end());
sort(temp.begin(),temp.end());
int n = nums.size(),left = 0,right = n - 1;
while(left < n && nums[left] == temp[left]) left ++;
while(right >= left && nums[right] == temp[right]) right --;
return right - left + 1;
}


## 23.03.22 学习

ChatGPT版代码，CSDN什么垃圾？？？

ThreadPool类的析构函数中，我们将布尔型变量exit设为true，并通知所有线程结束其任务。然后，我们等待所有线程结束并回收其资源。

ThreadPool类还提供了一个add_task()成员函数，用于添加一个新的任务到任务队列中。该函数使用了可变参数模板和lambda函数，将待执行的函数和其参数封装为一个std::function<void()>对象，并将该对象添加到任务队列中。然后，该函数通知一个等待在条件变量cv上的线程以便执行新的任务。

main()函数中，我们创建了一个ThreadPool对象，并向其中添加了8

#include <iostream>
#include <vector>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>

public:
for (size_t i = 0; i < num_threads; ++i) {
while (true) {
{
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, [this] { return exit || !mQueue.empty(); });
if (exit && mQueue.empty()) {
return;
}
mQueue.pop();
}
}
});
}
}

{
std::unique_lock<std::mutex> lock(mtx);
exit = true;
}
cv.notify_all();
}
}

template<class F>
{
{
std::unique_lock<std::mutex> lock(mtx);
}
cv.notify_one();
}

private:
std::queue<std::function<void()>> mQueue;
std::mutex mtx;
std::condition_variable cv;
bool exit;
};

void foo(int i) {
std::cout << "begin" << i << std::endl;
std::cout << "end " << i << std::endl;
}

int main() {

for (int i = 0; i < 8; ++i) {
}

return 0;
}



# 23.03.21 学习

ChatGPT真好用！！！！！

## String类

#include <iostream>
#include <cstring>
using namespace std;

/* string类
* 构造函数：
* string(const char* s);
* string(const string& str);    //拷贝构造，使用一个string对象初始化另一个string对象
* string(string &&str);         //移动构造，使用一个string对象初始化另一个string对象并删掉原对象指针
* 析构函数：
* ~string();
* 重载运算符：
* string & operator=(const string &str);  // 拷贝赋值运算符=，已有对象再赋值
* string & operator=(string & str)        // 移动赋值运算符=，已有对象再赋值，区别类似
* string operator+(const string &str) const;  // 重新+，返回新字符串
* 成员函数：
* size_t size() const;          //获取字符串长度
* 输入输出：
* friend istream& operator>>(istream &is, string &str);
* friend ostream& operator<<(ostream &os, string &str);
*/

class String {
public:
String() {
m_size = 0;
m_data = new char[1];
*m_data = '\0';
}

String(const char* str) {  //通用构造，使用字符串s初始化
m_size = strlen(str);
m_data = new char[m_size + 1];
strcpy(m_data, str);
}
String(const String& str) {  //拷贝构造，使用一个string对象初始化另一个string对象
m_size = str.m_size;
m_data = new char[m_size + 1];
strcpy(m_data, str.m_data);
}
String(String&& str) : m_data(str.m_data), m_size(str.m_size) {   //移动构造，使用一个string对象初始化另一个string对象并删掉原对象指针
str.m_data = nullptr;
str.m_size = 0;
}

String& operator=(const String& str) {  // 拷贝赋值运算符=，已有对象再赋值
if (this != &str) {
delete[] m_data;
m_size = str.m_size;
m_data = new char[m_size + 1];
strcpy(m_data, str.m_data);
}
return *this;
}
String& operator=(String&& str) {  // 移动赋值运算符=，已有对象再赋值，区别类似
if (this != &str) {
delete[] m_data;
m_size = str.m_size;
m_data = str.m_data;
str.m_data = nullptr;
str.m_size = 0;
}
return *this;
}
String operator+(const String& str) const {  // 重新+，返回新字符串
String newStr;
newStr.m_size = m_size + str.m_size;
newStr.m_data = new char[newStr.m_size + 1];
strcpy(newStr.m_data, m_data);
strcat(newStr.m_data, str.m_data);
return newStr;
}

size_t size() const {
return m_size;
}

friend istream& operator>>(istream& is, String& str) {  // 重载>>，先申请一块足够大的内存
char tem[1000];  //简单的申请一块内存
is >> tem;
str.m_size = strlen(tem);
str.m_data = new char[str.m_size + 1];
strcpy(str.m_data, tem);
return is;
}
friend ostream& operator<<(ostream& os, String& str) {  // 重载<<
os << str.m_data;
return os;
}

~String() {
if (m_data)
delete[] m_data;
}

private:
char* m_data;
size_t m_size;
};

int main()
{
String s1 = "123";
cout << s1 << endl;
String s2(move(s1));
cout << s2 << endl;

return 0;
}


## Vector类

#include <iostream>
using namespace std;

template<typename T>
class Vector {
private:
T* data;
int size;
int capacity;
public:
typedef T* iterator;

// 构造函数
Vector() {
size = 0;
capacity = 4;
data = new T[capacity];
}
// 复制构造函数
Vector(const Vector& other) {
size = other.size;
capacity = other.capacity;
data = new T[capacity];
for (int i = 0; i < size; i++) {
data[i] = other.data[i];
}
}
// 析构函数
~Vector() {
delete[] data;
}
// 在尾部添加元素
void push_back(T val) {
if (size == capacity) {
reserve(capacity * 2);
}
data[size++] = val;
}
// 删除尾部元素
void pop_back() {
if (size > 0) {
size--;
}
}
// 重置大小
void resize(int n) {
if (n > capacity) {
reserve(n);
}
size = n;
}
// 重置容量
void reserve(int n) {
if (n > capacity) {
T* newData = new T[n];
for (int i = 0; i < size; i++) {
newData[i] = data[i];
}
delete[] data;
data = newData;
capacity = n;
}
}
// 获取元素个数
int getSize() {
return size;
}
// 获取元素容量
int getCapacity() {
return capacity;
}
// 重载下标运算符
T& operator[](int i) {
return data[i];
}
// 迭代器
iterator begin() { return data; }
iterator end() { return data + size; }
};

int main() {
Vector<int> v;
/*
测试代码
*/

return 0;
}