LeetCode 刷题基础 -- 模板原型Ⅰ

news2024/12/26 3:30:11

模板原型 - 基础篇

  • 学习网站
    • 一、进制转换
    • 二、二分查找
      • ① 查找指定元素
      • ② 查找第一个大于等于 x 值的序列下标
      • ③ 查找第一个大于 x 值的序列下标
      • ④ 单峰序列
    • 三、双指针
      • ① 两数之和
      • ② 序列合并
      • ③ 集合求交
      • ④ 集合求并
    • 四、其他高效技巧与算法
      • ① 区间和
      • ② 01 对
      • ③ 左小数
    • 五、数学问题
      • ① 最大公约数
      • ② 最小公倍数
      • ③ 素数
      • ④ 质因子
      • ⑤ 组合数
    • 六、数据结构
      • ① 栈
      • ② 队列
      • ③ 链表
    • 七、深度优先遍历（DFS）
      • ① 01 串
      • ② 子集
      • ③ 全排列
      • ④ 组合
      • ⑤ 有限制的选数Ⅰ
      • ⑥ 有限制的选数Ⅱ
      • ⑦ n皇后
      • ⑧ 迷宫可行路径数
      • ⑨ 无向连通图的块数
    • 八、广度优先搜索（BFS）
      • ① 数字操作
      • ② 矩阵中的块
      • ③ 迷宫最短步数
      • ④ 迷宫最短路径

学习网站

晴问算法训练营

一、进制转换

十进制数 n 转 q 进制

    int n,a[1000],len=0;
    cin>>n;
    do{
        a[len++] = n % q;
        n /= q;
    }while(n>0);
    for(int i= len-1;i>=0;i--){
        cout<<a[i];
    }

p进制数 n 转 Q进制

int y = 0,product = 1;   //product 不断乘以p
while( n != 0){
    y += (n%10) * product;
    n /= 10;
    product *= p
}

二、二分查找

① 查找指定元素

//  查找指定元素
int findX(int a[],int l,int r,int x){
    int mid;
    while( l<= r){   //注意<= 号
        mid = (l + r) / 2;
        if(a[mid]==x){
            return mid;
        }else if(a[mid] < x){
            l = mid + 1;
        }else{
            r = mid - 1;
        }
    }
    return -1;
}
int main(){
    cout<<findX(a,0,n-1,x); //n为数组长度
}

② 查找第一个大于等于 x 值的序列下标

// 查找第一个大于等于 x 值的序列下标
int findX(int a[],int l,int r,int x){
    int mid;
    while(l < r){   // 注意< 号
        mid = (l+r)/2;
        if(a[mid] >= x){  //
            r = mid;
        }else{
            l = mid + 1;
        }
    }
    return l;  // 注意return l
}

③ 查找第一个大于 x 值的序列下标

int findX(int a[],int l,int r,int x){
    int mid;
    while(l<=r){
        mid = (l+r)/2;
        if(a[mid]<=x){
            l = mid + 1;
        }else{
            r = mid - 1;
        }
    }
    return l;
}

④ 单峰序列

单峰序列是指，在这个序列中存在一个位置，满足这个位置的左侧（含该位置）是严格递增的、右侧（含该位置）是严格递减的，这个位置被称作峰顶位置。现在给定一个单峰序列，求峰顶位置的下标。

image-20240924133000287

int maxIn = 0;
int mx = 0;
void findX(int a[],int l,int r){
    if(l>r)
        return ;
    int mid = (l+r)/2;
    if(a[mid]>mx){
        mx = a[mid];
        maxIn = mid;
    }
    findX(a,mid+1,r);
    findX(a,l,mid-1);
}

三、双指针

① 两数之和

给定一个严格递增序列A和一个正整数k，在序列A中寻找不同的下标i、j，使得Ai+Aj=k。问有多少对(i,j)同时i<j满足条件。

image-20240924133243742

int i=0,j=n-1,cnt=0;
    while(i<j){
        if(a[i]+a[j]==k){
            cnt++;
            i++;
            j--;
        }else if(a[i]+a[j]<k){
            i++;
        }else{
            j--;
        }
    }

② 序列合并

给定两个升序的正整数序列A和B，将它们合并成一个新的升序序列并输出。

int merge() {
    int i = 0, j = 0, counter = 0;
    while (i < n && j < m) {
        if (a[i] < b[j]) {
            mergedNums[counter++] = a[i++];
        } else {
            mergedNums[counter++] = b[j++];
        }
    }
    while (i < n) {
        mergedNums[counter++] = a[i++];
    }
    while (j < m) {
        mergedNums[counter++] = b[j++];
    }
    return counter;
}

③ 集合求交

给定一个包含 n 个正整数的集合 S1，再给定一个包含 m 个正整数的集合 S2，求两个集合的交集。

image-20240924133626143

void getIntersection() {
    int i = 0, j = 0;
    while (i < n && j < m) {
        if (a[i] == b[j]) {
            intersection.push_back(a[i]);
            i++, j++;
        } else if (a[i] < b[j]) {
            i++;
        } else {
            j++;
        }
    }
}

④ 集合求并

给定一个包含 n 个正整数的集合S1，再给定一个包含 m 个正整数的集合S2，求两个集合的并集。

image-20240924133722056

void getUnionSet() {
    int i = 0, j = 0;
    while (i < n && j < m) {
        if (a[i] == b[j]) {
            unionSet.push_back(a[i]);
            i++, j++;
        } else if (a[i] < b[j]) {
            unionSet.push_back(a[i++]);
        } else {
            unionSet.push_back(b[j++]);
        }
    }
    while (i < n) {
        unionSet.push_back(a[i++]);
    }
    while (j < m) {
        unionSet.push_back(b[j++]);
    }
}

四、其他高效技巧与算法

① 区间和

给定由n个正整数组成的序列A，接下来给出k个查询，每个查询指定两个正整数l、r，计算序列从第l个整数至第r个整数之和，即Al+Al+1+…+Ar。

int main() {
    int n;
    cin >> n;
    vector<int> A(n + 1);
    vector<int> prefixSum(n + 1, 0);
    
    // 读取原数组并构建前缀和数组
    for (int i = 1; i <= n; ++i) {
        cin >> A[i];
        prefixSum[i] = prefixSum[i - 1] + A[i];
    }
    
    int k;
    cin >> k;
    for (int i = 0; i < k; ++i) {
        int l, r;
        cin >> l >> r;
        // 计算区间和并输出结果
        cout << prefixSum[r] - prefixSum[l - 1] << endl;
    }
    
    return 0;
}

② 01 对

给定由n个0或1组成的序列，我们把序列中从左至右（可不连续）存在的0、1称为01对，问在序列中有多少个01对。

image-20240924134524016

int main() {
    int n, x, numZero = 0;
    scanf("%d", &n);
    long long result = 0;
    for (int i = 0; i < n; i++) {
        scanf("%d", &x);
        if (x == 1) {
            result += numZero;
        } else {
            numZero++;
        }
    }
    printf("%lld", result);
    return 0;
}

解析：从左到右 01 对，若看 0 ，不确定后面有多少1。但是若看 1，则必知道前面有多少0，这样就知道有多少 01 对了。

③ 左小数

给定由n个正整数组成的序列，问在序列中有多少个数，满足在它左边的所有数都比它小。

image-20240924135155830

int main() {
    int n, x, leftMax = 0;
    scanf("%d", &n);
    int result = 0;
    for (int i = 0; i < n; i++) {
        scanf("%d", &x);
        if (x > leftMax) {
            result++;
        }
        leftMax = max(leftMax, x);
    }
    printf("%d", result);
    return 0;
}

五、数学问题

① 最大公约数

int gcd(int a, int b) {
    if (b == 0) {
        return a;
    } else {
        return gcd(b, a % b);
    }
}

int main() {
    int a, b;
    scanf("%d%d", &a, &b);
    printf("%d", gcd(a, b));
    return 0;
}

② 最小公倍数

int gcd(int a, int b) {
    if (b == 0) {
        return a;
    } else {
        return gcd(b, a % b);
    }
}

int main() {
    int a, b;
    scanf("%d%d", &a, &b);
    printf("%d", gcd(a, b));
    return 0;
}

③ 素数

int gcb(int a,int b){
    if(b==0){
        return a;
    }else{
        return gcb(b,a%b);
    }
}

int main(){
    int a,b;
    cin>>a>>b;
    if(gcb(a,b)==1){
        cout<<"Yes";
    }else{
        cout<<"No";
    }
}

补充：打印素数表

void getPrimes(int n) {
    memset(isPrime, true, sizeof(isPrime));
    for (int i = 2; i <= n; i++) {
        if (isPrime[i]) {
            primes.push_back(i);
            for (int j = i + i; j <= n; j += i) {
                isPrime[j] = false;
            }
        }
    }
}

int main() {
    int n;
    scanf("%d", &n);
    getPrimes(n);
    for (int i = 0; i < primes.size(); i++) {
        printf("%d\n", primes[i]);
    }
    return 0;
}

④ 质因子

给定一个正整数n，对n进行质因子分解。

image-20240924191214245

void getPrimes(int n) {
    memset(isPrime, true, sizeof(isPrime));
    for (int i = 2; i <= n; i++) {
        if (isPrime[i]) {
            primes.push_back(i);
            for (int j = i + i; j <= n; j += i) {
                isPrime[j] = false;
            }
        }
    }
}

int main() {
    int n;
    scanf("%d", &n);
    getPrimes((int)sqrt(1.0 * n));
    for (int i = 0; i < primes.size() && n > 1; i++) {
        int counter = 0;
        while (n > 1 && n % primes[i] == 0) {
            counter++;
            n /= primes[i];
        }
        if (counter > 0) {
            printf("%d %d\n", primes[i], counter);
        }
    }
    if (n > 1) {
        printf("%d 1", n);
    }
    return 0;
}

⑤ 组合数

image-20240924191626523

#include <cstdio>
typedef long long LL;

LL C(LL n, LL m) {
    LL ans = 1;
    for (LL i = 1; i <= m; i++) {
        ans = ans * (n - m + i) / i;
    }
    return ans;
}

int main() {
    LL n, m;
    scanf("%lld%lld", &n, &m);
    printf("%lld", C(n, m));
    return 0;
}

六、数据结构

① 栈

现有一个空栈s和一个正整数n，将1,2,3,…,n依次入栈，期间任意时刻出栈。然后给定一个出栈序列，问其是否是一个合法的出栈序列。

image-20240924192048236

int main() {
    int n;
    scanf("%d", &n);
    stack<int> s;
    int x, nowMax = 0;
    bool isValid = true;
    for (int i = 0; i < n; i++) {
        scanf("%d", &x);
        if (x > nowMax) {
            for (int j = nowMax + 1; j <= x; j++) {
                s.push(j);
            }
            nowMax = x;
        }
        if (s.top() != x) {
            isValid = false;
            break;
        } else {
            s.pop();
        }
    }
    printf(isValid ? "Yes" : "No");
    return 0;
}

② 队列

约瑟夫环：假设n个人按编号顺时针从小到大排成一圈（编号为从1到n）。接着约定一个正整数k，从编号为1的人开始顺时针报数（编号为1的人报数1，编号为2的人报数2……），报到k的人离开圈子，然后他的下一个人继续从1开始报数，以此类推，直到圈子里只剩下一个人。

image-20240924192230935

int main(){
    int n,k,m;
    cin>>n>>m;
    queue<int> q;
    for(int i=1;i<=n;i++){
        q.push(i);
    }
    int cnt = 0;
    while(!q.empty()){
        int num = q.front();
        cnt++;
        if(cnt % m ==0){
           cout<<q.front();
            q.pop();
            if(q.size()>=1){
                cout<<" ";
            }
        }else{
            q.pop();
            q.push(num);
        }
    }
}

③ 链表

private:
    struct ListNode{
        int val;
        ListNode* next;
        ListNode():val(0),next(NULL){}
        ListNode(int val):val(val),next(NULL){}
        ListNode(int val,ListNode* next):val(val),next(NULL){}
    };
    int len;
    ListNode* dummyhead; //链表虚拟头结点

public:
    MyLinkedList() {
        len = 0;
        dummyhead = new ListNode();
    }
    
    int get(int index) {
        if(index<0||index>len-1) return -1;
        ListNode* p = dummyhead->next;
        while(index--){
            p = p ->next;
        }
        return p->val;
    }
    
    void addAtHead(int val) {
        ListNode* p = new ListNode(val);
        p->next = dummyhead->next;
        dummyhead->next = p;
        len++;
    }
    
    void addAtTail(int val) {
        ListNode* p = new ListNode(val),*cur=dummyhead;
        while(cur->next) cur = cur->next;
        cur->next = p;
        len++;
    }
    
    void addAtIndex(int index, int val) {
        if(index<=0) addAtHead(val);
        else if(index==len) addAtTail(val);
        else{
            ListNode* p = new ListNode(val),*pre = dummyhead;
            while(index--) pre = pre->next;
            p->next = pre->next;
            pre->next = p;
            len++;
        }
    }
    
    void deleteAtIndex(int index) {
        if(index<0||index>len-1) return;
        ListNode* pre = dummyhead,*p = NULL;
        while(index--) pre = pre->next;
        p = pre->next;
        pre->next = p->next;
        delete p;
        len--;
    }
};

 // 创建单链表
ListNode *head = new ListNode,*p = head;
	for(int i=1;i<=n;i++){
		scanf("%d",&v);
		p->next = new ListNode(v);
		p = p->next;
	}

//头插法
p = q ->next;
q->next = H->next;
H->next = q;
q = p;

//尾插法
LNode *rear = H->next;
while(){
    q = new ListNode(v);
    rear->next = q;
    rear = q;
}
rear->next = NULL;


//单链表法二
struct Node {
    int data, next;
} nodes[MAXN];

七、深度优先遍历（DFS）

① 01 串

在一个长度为n的数组中填写0或者1，输出所有可能的结果。

image-20240330203136805

vector<int> temp;
vector<vector<int> > result;
void DFS(int k){
    if(k==n) {
        result.push_back(temp);
        return;
    }
    temp.push_back(0);
    DFS(k+1);
    temp.pop_back();
    
    temp.push_back(1);
    DFS(k+1);
    temp.pop_back();
}

② 子集

给定一个正整数n，假设序列S=[1,2,3,…,n]，求S的所有子集。

image-20240330203234392

void DFS(int idx) {
    if (idx == n + 1) {
        result.push_back(temp);
        return;
    }
    temp.push_back(idx);
    DFS(idx + 1);
    
    temp.pop_back();
    DFS(idx + 1);
}

bool cmp(vector<int> a, vector<int> b) { 
    if (a.size() != b.size()) {
        return a.size() < b.size();
    } else {
        return a < b;
    }
}

③ 全排列

给定一个正整数n，假设序列S=[1,2,3,…,n]，求S的全排列。

image-20240330203331436

bool used[MAXN] = {false};

void DFS(int idx) {
    if (idx == n + 1) {
        result.push_back(temp);
        return;
    }
    for (int i = 1; i <= n; i++) {
        if (!used[i]) {
            temp.push_back(i);
            used[i] = true;
            DFS(idx + 1);
            used[i] = false;
            temp.pop_back();
        }
    }
}

④ 组合

给定两个正整数n、k，假设序列S=[1,2,3,…,n]，求从S中任选k个的所有可能结果。

image-20240330203510567

void DFS(int idx) {
    
    if (temp.size() == k) {   
        result.push_back(temp);
        return;
    }
    if (idx == n + 1) {
        return;
    }
    temp.push_back(idx);
    DFS(idx + 1);
    
    temp.pop_back();
    DFS(idx + 1);
}

⑤ 有限制的选数Ⅰ

给定n个互不相同的正整数，从中选择若干个数（每个数只能选一次），使得这些数之和为定值K。求满足条件的方案数。

image-20240330204302160

void DFS(int idx, int nowSum) {
    if (idx == n + 1) {
        if (nowSum == k) {
            ans++;
        }
        return;
    }
    if (nowSum > k) {
        return;
    }
    DFS(idx + 1, nowSum + a[idx]);
    DFS(idx + 1, nowSum);
}

⑥ 有限制的选数Ⅱ

给定n个互不相同的正整数，从中选择若干个数（每个数可以选任意次），使得这些数之和为定值K。求满足条件的方案数。

image-20240330204203107

void DFS(int idx, int nowSum) {  //k为目标值
    if (idx == n + 1) {
        if (nowSum == k) {
            ans++;
        }
        return;
    }
    for (int i = 0; i <= (k - nowSum) / a[idx]; i++) {
        DFS(idx + 1, nowSum + i * a[idx]);
    }
}

⑦ n皇后

bool vis_col[14],vis_l[30],vis_r[30];  //col 列 ，l左对角线，r右对角线
int n,ans;
void dfs(int row){  //行
	if(row==n){
		ans++;
		return;
	}
	for(int i=0;i<n;i++){
		if(!vis_col[i]&&!vis_l[i-row+n]&&!vis_r[i+row]){
			vis_col[i] = vis_l[i-row+n] = vis_r[i+row] = 1;
			dfs(row+1);
			vis_col[i] = vis_l[i-row+n] = vis_r[i+row] = 0;
		}
	}
}

⑧ 迷宫可行路径数

现有一个n∗m大小的迷宫，其中1表示不可通过的墙壁，0表示平地。每次移动只能向上下左右移动一格（不允许移动到曾经经过的位置），且只能移动到平地上。求从迷宫左上角到右下角的所有可行路径的条数。

image-20240924195453975

int De[][2] = {{0,1},{0,-1},{1,0},{-1,0}};
int mp[5][5];
bool vis[5][5] = {false};
int cnt = 0;
int n,m;
bool isVilid(int x,int y){
    if(x<0||y<0||x>=n||y>=m||vis[x][y]==true||mp[x][y]==1){
        return false;
    }else{
        return true;
    }
}

void DFS(int x,int y){
    if(x==n-1&&y==m-1){
        cnt++;
        return;
    }
    vis[x][y] = true;
    for(int i=0;i<5;i++){
        int next_x = x + De[i][0];
        int next_y = y + De[i][1];
        if(isVilid(next_x,next_y)){
            DFS(next_x,next_y);
        }
    }
    vis[x][y] = false;
}

int main(){
    cin>>n>>m;
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            cin>>mp[i][j];
        }
    }
    DFS(0,0);
    cout<<cnt;

}

⑨ 无向连通图的块数

tmp43BE

#include <cstdio>
#include <vector>
using namespace std;

const int MAXN = 100;
vector<int> G[MAXN];
bool vis[MAXN];

void DFS(int u) {
    vis[u] = true;
    for (int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if (!vis[v]) {
            DFS(v);
        }
    }
}

int main() {
    memset(vis, false, sizeof(vis));
    int n, m, u, v;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
    }
    int blockCount = 0;
    for (int i = 0; i < n; i++) {
        if (!vis[i]) {
            DFS(i);
            blockCount++;
        }
    }
    printf("%d", blockCount);
    return 0;
}

八、广度优先搜索（BFS）

① 数字操作

从整数1开始，每轮操作可以选择将上轮结果加1或乘2。问至少需要多少轮操作才能达到指定整数 n。

const int MAXN = 100000;
bool inQueue[MAXN + 1] = {false};

int getStep(int n) {
    int step = 0;
    queue<int> q;
    q.push(1);
    while (true) {
        int cnt = q.size();
        for (int i = 0; i < cnt; i++) {
            int front = q.front();
            q.pop();
            if (front == n) {
                return step;
            }
            inQueue[front] = true;
            if (front * 2 <= n && !inQueue[front * 2]) {
                q.push(front * 2);
            }
            if (front + 1 <= n && !inQueue[front + 1]) {
                q.push(front + 1);
            }
        }
        step++;
    }
}

② 矩阵中的块

现有一个n∗m的矩阵，矩阵中的元素为0或1。然后进行如下定义：

  1. 位置(x,y)与其上下左右四个位置(x,y+1)、(x,y−1)、(x+1,y)、(x−1,y)是相邻的；
  2. 如果位置(x1,y1)与位置(x2,y2)相邻，且位置(x2,y2)与位置(x3,y3)相邻，那么称位置(x1,y1)与位置(x3,y3)也相邻；
  3. 称个数尽可能多的相邻的1构成一个“块”。

求给定的矩阵中“块”的个数。

int n, m, matrix[MAXN][MAXN];
bool inQueue[MAXN][MAXN] = {false};

const int MAXD = 4;
int dx[MAXD] = {0, 0, 1, -1};
int dy[MAXD] = {1, -1, 0, 0};

bool canVisit(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m && matrix[x][y] == 1 && !inQueue[x][y];
}

void BFS(int x, int y) {
    queue<Position> q;
    q.push(Position(x, y));
    inQueue[x][y] = true;
    while (!q.empty()) {
        Position front = q.front();
        q.pop();
        for (int i = 0; i < MAXD; i++) {
            int nextX = front.first + dx[i];
            int nextY = front.second + dy[i];
            if (canVisit(nextX, nextY)) {
                inQueue[nextX][nextY] = true;
                q.push(Position(nextX, nextY));
            }
        }
    }
}

③ 迷宫最短步数

现有一个n∗m大小的迷宫，其中1表示不可通过的墙壁，0表示平地。每次移动只能向上下左右移动一格，且只能移动到平地上。求从迷宫左上角到右下角的最小步数。

bool canVisit(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m && maze[x][y] == 0 && !inQueue[x][y];
}

int BFS(int x, int y) {
    queue<Position> q;
    q.push(Position(x, y));
    inQueue[x][y] = true;
    int step = 0;
    while (!q.empty()) {
        int cnt = q.size();
        while (cnt--) {
            Position front = q.front();
            q.pop();
            if (front.first == n - 1 && front.second == m - 1) {
                return step;
            }
            for (int i = 0; i < MAXD; i++) {
                int nextX = front.first + dx[i];
                int nextY = front.second + dy[i];
                if (canVisit(nextX, nextY)) {
                    inQueue[nextX][nextY] = true;
                    q.push(Position(nextX, nextY));
                }
            }
        }
        step++;
    }
    return -1;
}

④ 迷宫最短路径

现有一个n∗m大小的迷宫，其中1表示不可通过的墙壁，0表示平地。每次移动只能向上下左右移动一格，且只能移动到平地上。假设左上角坐标是(1,1)，行数增加的方向为x增长的方向，列数增加的方向为y增长的方向，求从迷宫左上角到右下角的最少步数的路径。

typedef pair<int, int> Position;

const int MAXN = 100;
int n, m, maze[MAXN][MAXN];
bool inQueue[MAXN][MAXN] = {false};
Position pre[MAXN][MAXN];

const int MAXD = 4;
int dx[MAXD] = {0, 0, 1, -1};
int dy[MAXD] = {1, -1, 0, 0};

bool canVisit(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m && maze[x][y] == 0 && !inQueue[x][y];
}

void BFS(int x, int y) {
    queue<Position> q;
    q.push(Position(x, y));
    inQueue[x][y] = true;
    while (!q.empty()) {
        Position front = q.front();
        q.pop();
        if (front.first == n - 1 && front.second == m - 1) {
            return;
        }
        for (int i = 0; i < MAXD; i++) {
            int nextX = front.first + dx[i];
            int nextY = front.second + dy[i];
            if (canVisit(nextX, nextY)) {
                pre[nextX][nextY] = Position(front.first, front.second);
                inQueue[nextX][nextY] = true;
                q.push(Position(nextX, nextY));
            }
        }
    }
}

void printPath(Position p) {
    Position prePosition = pre[p.first][p.second];
    if (prePosition == Position(-1, -1)) {
        printf("%d %d\n", p.first + 1, p.second + 1);
        return;
    }
    printPath(prePosition);
    printf("%d %d\n", p.first + 1, p.second + 1);
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2196688.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【每日刷题】Day134

【每日刷题】Day134

【每日刷题】Day134 &#x1f955;个人主页&#xff1a;开敲&#x1f349; &#x1f525;所属专栏&#xff1a;每日刷题&#x1f34d; &#x1f33c;文章目录&#x1f33c; 1. 1218. 最长定差子序列 - 力扣&#xff08;LeetCode&#xff09; 2. LCR 116. 省份数量 - 力扣&…
阅读更多...
掌握这17个Python自动化操作，简化你的日常工作流程，提升工作效率！

掌握这17个Python自动化操作，简化你的日常工作流程，提升工作效率！

Python是一种流行的编程语言&#xff0c;以其简单性和可读性而闻名。因其能够提供大量的库和模块&#xff0c;它成为了自动化各种任务的绝佳选择。让我们进入自动化的世界&#xff0c;探索17个可以简化工作并节省时间精力的Python脚本。 目录&#xff08;上篇&#xff09; 1.自…
阅读更多...
小型数控铣床助力职业教育教学模式

小型数控铣床助力职业教育教学模式

小型数控铣床是在普通铣床上集成了数字控制系统&#xff0c;可以在程序代码的控制下较精确地进行铣削加工的机床。与普通小型铣床相比&#xff0c;小型数控铣床通过数字控制系统实现了自动化加工&#xff0c;提高了加工精度和效率。 小型数控铣床的引入推动了教育装备的现代化进…
阅读更多...
基于单片机的书库环境监测

基于单片机的书库环境监测

目录 一、主要功能 二、硬件资源 三、程序编程 四、实现现象 一、主要功能 基于51单片机&#xff0c;采用DHT11湿度传感器检测湿度&#xff0c;DS18B20温度传感器检测温度&#xff0c; 采用滑动变阻器连接数模转换器模拟二氧化碳和氧气浓度检测&#xff0c;各项数值通过lc…
阅读更多...
Trickle流量限速工具使用示例

Trickle流量限速工具使用示例

简介&#xff1a;trickle 是一个轻量级的流量限速工具&#xff0c;允许用户限制应用程序的网络带宽使用&#xff0c;以便更好地管理网络资源和优化网络性能。本文将介绍 trickle 的安装和使用方法&#xff0c;并通过 Python 封装示例展示如何使用 trickle 控制网络带宽。 历史…
阅读更多...
关于PPT生成的开源大模型总结

关于PPT生成的开源大模型总结

目前需要开源的PPT生成模型&#xff0c;在这里对github上的一些模型进行筛选 搜索关键词&#xff1a;ppt generate&#xff08;more starts&#xff09; williamfzc/chat-gpt-ppt: 支持直接生成PPT支持中英文需要调用ChatGPT&#xff08;Add your token (official openai api k…
阅读更多...
使用正则表达式删除文本的奇数行或者偶数行

使用正则表达式删除文本的奇数行或者偶数行

用智谱清言和kimi搜出来的结果都没法在notepad生效&#xff0c;后面在overflow上找到的答案比较靠谱。 查找&#xff1a;^[^\n]*\n([^\n]*) 替换&#xff1a;\1 删除偶数行 查找&#xff1a;^([^\n]*)\n[^\n]* 替换&#xff1a;\1 代码解释 ^&#xff1a;这个符号代表字符…
阅读更多...
Excel日期导入数据库变为数字怎么办

Excel日期导入数据库变为数字怎么办

在Excel导入到数据库的过程中&#xff0c;经常会碰到Excel里面的日期数据&#xff0c;导进去过后变成了数字。 如下图&#xff1a; 使用navicate等数据库编辑器导入数据库后&#xff1a; 原因分析&#xff1a;这是因为日期和时间在excel中都是以数字形式存储的&#xff0c;这个…
阅读更多...
重学SpringBoot3-集成Redis（二）之注解驱动

重学SpringBoot3-集成Redis（二）之注解驱动

更多SpringBoot3内容请关注我的专栏&#xff1a;《SpringBoot3》 期待您的点赞&#x1f44d;收藏⭐评论✍ 重学SpringBoot3-集成Redis&#xff08;二&#xff09;之注解驱动 1. 为什么选择 Redis 作为缓存&#xff1f;2. 如何在 Spring Boot 中启用 Redis 缓存&#xff1f;2.1 …
阅读更多...
多模态大模型调研BLIP、BLIP2、InstructBLIP

多模态大模型调研BLIP、BLIP2、InstructBLIP

ITC:图像向量与文本向量对齐在同一特征空间 ITM:二分类任务。负样本构建:前方ITC分错的地方&#xff0c;在对比学习的基础上&#xff0c;更细粒度的对其特征。 LM:GPT的生成任务&#xff0c;将文本重新进行预测。 BLIP另一个贡献在于弱监督图文数据清洗方面&#xff0c;通过训…
阅读更多...
学习threejs，模拟窗户光源

学习threejs，模拟窗户光源

&#x1f468;‍⚕️ 主页&#xff1a; gis分享者 &#x1f468;‍⚕️ 感谢各位大佬 点赞&#x1f44d; 收藏⭐ 留言&#x1f4dd; 加关注✅! &#x1f468;‍⚕️ 收录于专栏&#xff1a;threejs gis工程师 文章目录 一、&#x1f340;前言二、&#x1f340;绘制任意字体模型…
阅读更多...
IDEA启动项目在background task 阶段出现oom解决方案

IDEA启动项目在background task 阶段出现oom解决方案

直接Ctrl Alt S 或者如下图形操作
阅读更多...
棒球运动物体检测系统源码分享

棒球运动物体检测系统源码分享

棒球运动物体检测系统源码分享 [一条龙教学YOLOV8标注好的数据集一键训练_70全套改进创新点发刊_Web前端展示] 1.研究背景与意义 项目参考AAAI Association for the Advancement of Artificial Intelligence 项目来源AACV Association for the Advancement of Computer Vis…
阅读更多...
应用界面编写（十四）

应用界面编写（十四）

一. 介绍QT 接下来我们会在Qt Creater来进行界面的编写&#xff0c;并且在荔枝派中运行。那么我们有必要了解一下Qt到底是什么呢&#xff1f;它又为什么可以在荔枝派中运行呢&#xff1f; QT是一个跨平台的应用程序和用户界面框架&#xff0c;用于开发具有图形界面的软件。而…
阅读更多...
【最新版】Stable Diffusion4.9（AI绘画）下载及安装教程(附软件安装包)！

【最新版】Stable Diffusion4.9（AI绘画）下载及安装教程(附软件安装包)！

随着技术的迭代&#xff0c;目前 Stable Diffusion 已经能够生成非常艺术化的图片了&#xff0c;完全有赶超人类的架势&#xff0c;已经有不少工作被这类服务替代&#xff0c;比如制作一个 logo 图片&#xff0c;画一张虚拟老婆照片&#xff0c;画质堪比相机。 最新 Stable Di…
阅读更多...
日常物品实例分割系统源码＆数据集分享

日常物品实例分割系统源码＆数据集分享

日常物品实例分割系统源码&#xff06;数据集分享 [yolov8-seg-dyhead-DCNV3&#xff06;yolov8-seg-SPPF-LSKA等50全套改进创新点发刊_一键训练教程_Web前端展示] 1.研究背景与意义 项目参考ILSVRC ImageNet Large Scale Visual Recognition Challenge 项目来源AAAI Globa…
阅读更多...
Maven - 依赖管理

Maven - 依赖管理

依赖配置 在pom.xml的project标签内添加dependencies标签&#xff0c;之后添加依赖配置。 <dependencies><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-classic</artifactId><version>1.4.5</version>…
阅读更多...
Acwing 记忆化搜索

Acwing 记忆化搜索

Acwing 901.滑雪 输入样例&#xff1a; 5 5 1 2 3 4 5 16 17 18 19 6 15 24 25 20 7 14 23 22 21 8 13 12 11 10 9 输出样例&#xff1a; 25 实现思路&#xff1a; 状态表示f[i][j]&#xff0c;表示从点(i,j)出发的最长路径长度集合划分可分为四种情况&#xff1a;从点(i,j)出…
阅读更多...
Mybatis框架梳理——更新中

Mybatis框架梳理——更新中

Mybatis框架梳理 前言1.ORM2.模块划分2.1 ORM的实现2.2 SQL的映射2.3 插件机制2.4 缓存机制2.5 其他2.5.1 用到的设计模式 3. 愿景 前言 如果让我聊一聊mybatis&#xff0c;我该怎么说呢&#xff1f;开发中时时刻刻都在用它&#xff0c;此时此刻&#xff0c;脑海中却只浮现ORM框…
阅读更多...
揭秘：ARM 工业计算机缘何替代树莓派

揭秘：ARM 工业计算机缘何替代树莓派

工业自动化、物联网以及嵌入式系统等领域对高性能、稳定可靠的计算设备的需求日益增长。国产 ARMxy工业计算机的出现&#xff0c;为这些领域带来了新的机遇和选择。特别是那些采用国产芯片如全志、瑞芯微等&#xff0c;并支持 Ubuntu 系统的工业计算机&#xff0c;展现出了令人…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023