22/7/16

已于 2022-07-17 09:52:30 修改
阅读量204 收藏
点赞数
文章标签： 算法 c++
于 2022-07-16 16:32:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aidaqiudeaichao/article/details/125816076
版权

1，cf Non-Coprime Partition；2，acwing 1144.连接格点；3，acwing 1146.新的开始（有细节）；

4，北极通讯网络；5，理想的正方形（二维滑动窗口模型）；

1，cf Non-Coprime Partition

题意：给一个数n，让你把1~n的正整数划分为两个不相交子集，使得两个子集的和的最大公因数>1；如果可以划分，输出Yes，并输出集合1的大小及元素，集合2的大小及元素；否则No；

思路：一开始直接想的就是偶数项划分在一起，奇数项划分在一起；怎么快速验证呢？打表；

 输出n为i的时候的最大公因数；

 很明显，最大公因数是递增的，一定大于1；

所以可以这样划分；

数学证明： 

 an就是n；所以(2n-1)*n 和 n*(2n+1)的最大公因数就是n；

#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define rep1(i,a,n) for(register int i=(a);i<(n);++i) 
#define rep2(i,a,n) for(register int i=(a);i<=(n);++i) 
#define per1(i,n,a) for(register int i=(n);i>(a);i--) 
#define per2(i,n,a) for(register int i=(n);i>=(a);i--)
#define quick_cin() cin.tie(0),cout.tie(0),ios::sync_with_stdio(false)
#define memset(a,i,b) memset((a),(i),sizeof (b))
#define memcpy(a,i,b) memcpy((a),(i),sizeof (b))
#define pro_q priority_queue
#define pb push_back
#define pf push_front
#define endl "\n"
#define lowbit(m) ((-m)&(m))
#define YES cout<<"YES\n"
#define NO cout<<"NO\n"
#define Yes cout<<"Yes\n"
#define No cout<<"No\n"
#define yes cout<<"yes\n"
#define no cout<<"no\n"
#define yi first
#define er second
#define INF 0x3f3f3f3f
#define tulun int e[N],ne[N],h[N],w[N],idx;
#define add2(a,b) e[idx]=b,ne[idx]=h[a],h[a]=idx++;
#define add3(a,b,c) w[idx]=c,e[idx]=b,ne[idx]=h[a],h[a]=idx++;
#define T_solve() int T;cin>>T;while(T--)solve();
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
typedef double dob;
const int N=1e6+10;
int n;
signed main()
{
    quick_cin();
    cin>>n;
    if(n<=2)No;
    else
    {
        Yes;
        if(n&1)cout<<(n-1)/2<<" ";
        else cout<<n/2<<" ";
        rep2(i,1,n)if(!(i&1))cout<<i<<" ";
        cout<<endl;
        if(n&1)cout<<(n+1)/2<<" ";
        else cout<<n/2<<" ";
        rep2(i,1,n)if(i&1)cout<<i<<" ";
    }
    return 0;
}

2，连接格点；

 思路：对格点编号，

eg 3*3的矩阵：1 2 3

                       4 5 6

                       7 8 9

每个位置编号：坐标（x，y）编号就是m*（x-1）+y，然后遍历两次矩阵，分别加上横向边，权值是2，纵向边权值是 1；所以可以直接跑kruskal；

注意连续若干行的读入现在只能用while（~scanf（））来做；

#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define rep1(i,a,n) for(register int i=(a);i<(n);++i) 
#define rep2(i,a,n) for(register int i=(a);i<=(n);++i) 
#define per1(i,n,a) for(register int i=(n);i>(a);i--) 
#define per2(i,n,a) for(register int i=(n);i>=(a);i--)
#define quick_cin() cin.tie(0),cout.tie(0),ios::sync_with_stdio(false)
#define memset(a,i,b) memset((a),(i),sizeof (b))
#define memcpy(a,i,b) memcpy((a),(i),sizeof (b))
#define pro_q priority_queue
#define pb push_back
#define pf push_front
#define endl "\n"
#define lowbit(m) ((-m)&(m))
#define YES cout<<"YES\n"
#define NO cout<<"NO\n"
#define Yes cout<<"Yes\n"
#define No cout<<"No\n"
#define yes cout<<"yes\n"
#define no cout<<"no\n"
#define yi first
#define er second
#define INF 0x3f3f3f3f
#define tulun int e[N],ne[N],h[N],w[N],idx;
#define add2(a,b) e[idx]=b,ne[idx]=h[a],h[a]=idx++;
#define add3(a,b,c) w[idx]=c,e[idx]=b,ne[idx]=h[a],h[a]=idx++;
#define T_solve() int T;cin>>T;while(T--)solve();
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
typedef double dob;
const int N=2e6+10;
struct node 
{
    int a,b,w;
    bool operator <(const node&b)
    {
        return w<b.w;
    }
}edge[N];
int n,m;
int mp[1010][1010];
int p[N];
int find(int x){return p[x]==x?x:p[x]=find(p[x]);}
int cnt,num,ans;
void kruskal()
{
    sort(edge,edge+cnt);
    rep1(i,0,cnt)
    {
        int a=edge[i].a,b=edge[i].b,w=edge[i].w;
        if(num==n*m-1)return;
        a=find(a);
        b=find(b);
        if(a!=b)
        {
            num++;
            ans+=w;
            p[a]=b;
        }
    }
}
signed main()
{
   // quick_cin();
    cin>>n>>m;
    rep2(i,1,n*m)p[i]=i;
    rep2(i,1,n)
    {
        rep2(j,1,m)
        {
            mp[i][j]=m*(i-1)+j;
            if(j>1)
            {
                int a=mp[i][j-1],b=mp[i][j];
                edge[cnt++]={a,b,2};
            }
        }
    }
    rep2(j,1,m)
    {
        rep2(i,1,n)
        {
            if(i>1)
            {
                int a=mp[i-1][j];
                int b=mp[i][j];
                edge[cnt++]={a,b,1};
            }
        }
    }
    int x1,y1,x2,y2;
    while(~scanf("%d %d %d %d",&x1,&y1,&x2,&y2))
    {
        int a=m*(x1-1)+y1;
        int b=m*(x2-1)+y2;
        a=find(a);
        b=find(b);
        if(a!=b)
        {
            num++;
            p[a]=b;
        }
    }
    kruskal();
    cout<<ans;
    return 0;
}

3，新的开始；

思路：

首先是我做错的思路：直接先跑一个最小生成树，在加上最小的建造发电站的费用；但是这样会错在当连接费用大于建造费用的时候；而且题目也没说只可以造一个发电站；

正解：想象一个超级源点，建造发电站就是超级源点和矿井连一条边，权值为建造发电站的费用，这样就可以将建造发电站和连接矿井放在一起做；

#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define rep1(i,a,n) for(register int i=(a);i<(n);++i) 
#define rep2(i,a,n) for(register int i=(a);i<=(n);++i) 
#define per1(i,n,a) for(register int i=(n);i>(a);i--) 
#define per2(i,n,a) for(register int i=(n);i>=(a);i--)
#define quick_cin() cin.tie(0),cout.tie(0),ios::sync_with_stdio(false)
#define memset(a,i,b) memset((a),(i),sizeof (b))
#define memcpy(a,i,b) memcpy((a),(i),sizeof (b))
#define pro_q priority_queue
#define pb push_back
#define pf push_front
#define endl "\n"
#define lowbit(m) ((-m)&(m))
#define YES cout<<"YES\n"
#define NO cout<<"NO\n"
#define Yes cout<<"Yes\n"
#define No cout<<"No\n"
#define yes cout<<"yes\n"
#define no cout<<"no\n"
#define yi first
#define er second
#define INF 0x3f3f3f3f
#define tulun int e[N],ne[N],h[N],w[N],idx;
#define add2(a,b) e[idx]=b,ne[idx]=h[a],h[a]=idx++;
#define add3(a,b,c) w[idx]=c,e[idx]=b,ne[idx]=h[a],h[a]=idx++;
#define T_solve() int T;cin>>T;while(T--)solve();
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
typedef double dob;
struct node 
{
    int a,b,w;
    bool operator <(const node&b)
    {
        return w<b.w;
    }
}edge[310*310];
int edge_num;
int n,m;
int cost[310][310];
int v[310];
int p[310*310];
int find(int x){return p[x]==x?x:p[x]=find(p[x]);}
int ans;
void kruskal()
{
   sort(edge,edge+edge_num);
   rep2(i,1,n+1)p[i]=i;
   rep1(i,0,edge_num)
   {
        int a=edge[i].a,b=edge[i].b,w=edge[i].w;
        a=find(a);
        b=find(b);
        if(a!=b)
        {
            p[a]=b;
            ans+=w;
        }
   }
}
signed main()
{
    quick_cin();
    cin>>n;
    rep2(i,1,n)
    {
        cin>>v[i];
        int a=i,b=n+1,w=v[i];
        edge[edge_num++]={a,b,w};
    }
    rep2(i,1,n)
    {
        rep2(j,1,n)
        {
            cin>>cost[i][j];
            if(j<i)
            {
                int a=i,b=j,w=cost[i][j];
                edge[edge_num++]={a,b,w};
            }
        }
    }
    kruskal();
    cout<<ans;
    return 0;
}

4，北极通讯网络；

 注意：卫星设备必须在两台及以上才能发挥实际作用；

思路：最好的就是把卫星设备贪心给最大边用，k台卫星设备可以删去k-1条边（仅在k>=2时）所以输出第n-k条边即为答案；

注意我对k=max(k,1)，防止k=0的情况误判；

#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define rep1(i,a,n) for(register int i=(a);i<(n);++i) 
#define rep2(i,a,n) for(register int i=(a);i<=(n);++i) 
#define per1(i,n,a) for(register int i=(n);i>(a);i--) 
#define per2(i,n,a) for(register int i=(n);i>=(a);i--)
#define quick_cin() cin.tie(0),cout.tie(0),ios::sync_with_stdio(false)
#define memset(a,i,b) memset((a),(i),sizeof (b))
#define memcpy(a,i,b) memcpy((a),(i),sizeof (b))
#define pro_q priority_queue
#define pb push_back
#define pf push_front
#define endl "\n"
#define lowbit(m) ((-m)&(m))
#define YES cout<<"YES\n"
#define NO cout<<"NO\n"
#define Yes cout<<"Yes\n"
#define No cout<<"No\n"
#define yes cout<<"yes\n"
#define no cout<<"no\n"
#define yi first
#define er second
#define INF 0x3f3f3f3f
#define tulun int e[N],ne[N],h[N],w[N],idx;
#define add2(a,b) e[idx]=b,ne[idx]=h[a],h[a]=idx++;
#define add3(a,b,c) w[idx]=c,e[idx]=b,ne[idx]=h[a],h[a]=idx++;
#define T_solve() int T;cin>>T;while(T--)solve();
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
typedef double dob;
const int N=500*500+10;
struct node 
{
    int a,b;
    dob w;
    bool operator <(const node&b)
    {
        return w<b.w;
    }
}edge[N];
PII ver[N];
int edge_num;
int p[N];
int find(int x){return p[x]==x?x:p[x]=find(p[x]);}
int n,k;
dob ans;
void kruskal()
{
    sort(edge,edge+edge_num);
    rep2(i,1,n)p[i]=i;
    int cnt=0;
    k=max(k,1);
    rep1(i,0,edge_num)
    {
        int a=edge[i].a,b=edge[i].b;
        dob w=edge[i].w;
        a=find(a);
        b=find(b);
        if(a!=b)
        {
            p[a]=b;
            cnt++;
        }
        if(cnt==n-k)
        {
            ans=w;
            break;
        }
    }
}
dob len(int x1,int y1,int x2,int y2)
{
    return sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
}
signed main()
{
    quick_cin();
    cin>>n>>k;
    rep2(i,1,n)
    {
        int x,y;
        cin>>x>>y;
        ver[i]={x,y};
    }
    rep2(i,2,n)
    {
        rep2(j,1,i-1)
        {
            int a=i,b=j;
            int x1=ver[i].first,y1=ver[i].second;
            int x2=ver[j].first,y2=ver[j].second;
            dob w=len(x1,y1,x2,y2);
            edge[edge_num++]={a,b,w};
        }
    }
    kruskal();
    cout<<fixed<<setprecision(2)<<ans;
    return 0;
}

5，理想的正方形；

题意：

 思路：

我们先求出在行中，每个长度为n的长方形的最值，并存储到最右边的端点；

 

 大概就是这样，第一行中，每个红色的点存储的就是它左边3个长度的最值；

那我求一个3*3的正方形的最值的时候，其实也就是对列方向上这个存储最值的三个长度的矩形取个最值；如图所示；

 

 因此，就可以把二维的问题转化为两次一维的问题，先横着求一边行的最值， 在纵着对列求一遍最值；两次操作处理完后，正方形的最值就储存在它的右下角；遍历所有右下角即可得到最大值减去最小值；

#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define rep1(i,a,n) for(register int i=(a);i<(n);++i) 
#define rep2(i,a,n) for(register int i=(a);i<=(n);++i) 
#define per1(i,n,a) for(register int i=(n);i>(a);i--) 
#define per2(i,n,a) for(register int i=(n);i>=(a);i--)
#define quick_cin() cin.tie(0),cout.tie(0),ios::sync_with_stdio(false)
#define memset(a,i,b) memset((a),(i),sizeof (b))
#define memcpy(a,i,b) memcpy((a),(i),sizeof (b))
#define pro_q priority_queue
#define pb push_back
#define pf push_front
#define endl "\n"
#define lowbit(m) ((-m)&(m))
#define YES cout<<"YES\n"
#define NO cout<<"NO\n"
#define Yes cout<<"Yes\n"
#define No cout<<"No\n"
#define yes cout<<"yes\n"
#define no cout<<"no\n"
#define yi first
#define er second
#define INF 0x3f3f3f3f
#define tulun int e[N],ne[N],h[N],w[N],idx;
#define add2(a,b) e[idx]=b,ne[idx]=h[a],h[a]=idx++;
#define add3(a,b,c) w[idx]=c,e[idx]=b,ne[idx]=h[a],h[a]=idx++;
#define T_solve() int T;cin>>T;while(T--)solve();
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
typedef double dob;
const int N=1e3+10;
int row_min[N][N],row_max[N][N];
int n,m,k;
int w[N][N];
int q[N];
void get_min(int a[],int b[],int tot)
{
    int hh=0,tt=-1;
    rep2(i,1,tot)
    {
        while(hh<=tt&&q[hh]<=i-k)hh++;
        while(hh<=tt&&a[i]<=a[q[tt]])tt--;
        q[++tt]=i;
        b[i]=a[q[hh]];
    }
}
void get_max(int a[],int b[],int tot)
{
    int hh=0,tt=-1;
    rep2(i,1,tot)
    {
        while(hh<=tt&&q[hh]<=i-k)hh++;
        while(hh<=tt&&a[i]>=a[q[tt]])tt--;
        q[++tt]=i;
        b[i]=a[q[hh]];
    }
}
int ans[N],col_min[N],col_max[N];
PII zuizhi[N][N];
signed main()
{
    quick_cin();
    cin>>n>>m>>k;
    rep2(i,1,n)
    rep2(j,1,m)cin>>w[i][j];
    rep2(i,1,n)
    {
        get_min(w[i],row_min[i],m);
        get_max(w[i],row_max[i],m);
    }
    rep2(j,k,m)
    {
        rep2(i,1,n)ans[i]=row_min[i][j];
        get_min(ans,col_min,n);
        rep2(i,1,n)ans[i]=row_max[i][j];
        get_max(ans,col_max,n);
        rep2(i,1,n)zuizhi[i][j]={col_max[i],col_min[i]};
    }
    int res=INT_MAX;
    rep2(i,k,n)
    rep2(j,k,m)
    res=min(res,zuizhi[i][j].first-zuizhi[i][j].second);
    cout<<res;
    return 0;
}

Dull丶
关注
PL/SQL课件
07-12
控制结构（第4~7章） 异常处理（第8~10章） 游标（第11~12章） 触发器（第13~14章） 复合数据类型（第15~16章） 动态SQL（第17章） 批量SQL（第18章） 子程序和包（第19~22章） Oracle中对象类型（第23章） Oracle...
信息安全数学基础（第二版）陈恭亮 第一章部分习题
热门推荐
Hugh677的博客
03-27 1万+
（1）证明：若 2| n ， 5|n , 7| n ,则 70|n。 互素 即 10 |n 互素 10*7 |n即 70|n （2）证明：如果a是整数，则被3整除。 如果,则被3整除。 如果,则，则被3整除。 如果,则 ，则被3整除。 （4）证明：任意三个连续整数的乘积都被6整除。 设 a-1 ，a，a+1； 由（2）有 3 | (...
集合划分问题（一）
Dawson的博客
11-14 8317
题目：集合划分问题（一）前言题目要求问题描述：算法设计要求：数据输入：结果输出：分析源代码输入输出示例总结 前言 这是王晓东所著的《计算机算法设计与分析》（第四版）第二章算法实现题的第6道（P41） 题目要求 问题描述： n个元素的集合{1,2,…,n}可以划分若干个非空子集。例如，当n=4时，集合{1,2,3,4}可以划分为15个不同的非空子集如下: {{1},{2},{3},{4}},{{...
划分数组，尽量让两个集合的累加和接近 -- 动态规划
Pain is inevitable but suffering is optional.
05-30 373
题目一 给定一个正数数组arr，请把arr中所有的数分成两个集合，尽量让两个集合的累加和接近。 返回：最接近的情况下，较小集合的累加和。 代码一 class SplitSumClosed: """ 给定一个正数数组arr，请把arr中所有的数分成两个集合，尽量让两个集合的累加和接近。 返回：最接近的情况下，较小集合的累加和。 """ def solution(self, arr): """ 暴力递归 :param arr
算法-划分问题（Java）
云中朝颜的博客
11-02 2459
划分问题划分问题思路找出幂集的原理过程 划分问题 请考虑划分问题(partition problem):给定n个正整数，把它们划分为元素之和相同但不相交的两个子集。(当然，这种问题并不总是有解的。)为该问题设计一个穷举查找算法。应尽量减少该算法需要生成的子集的数量。 思路 1.找到n个正整数的幂集，并计算子集的和 2.判断子集的和是否为n个正整数的一半 3.是的话输出子集 找出幂集的原理 比如想找到{1,3,4}的幂集： 步骤 – – – – – – – – 1.找到{1}的幂集 {空集}
整数集合划分
zhuifengmax的博客
01-25 1113
给定一个包含 N 个正整数的集合，请你将它们划分为两个不相交的集合 A1 和 A2，其中 A1 包含 n1 个元素，A2 包含 n2 个元素。 用 S1 表示集合 A1 内所有元素之和，S2 表示集合 A2 内所有元素之和。 请你妥善划分，使得 |n1−n2| 尽可能小，并在此基础上 |S1−S2| 尽可能大。 输入格式 第一行包含整数 N。 第二行包含 N 个正整数。 输出格式 再一行中输出 |n1−n2| 和 |S1−S2|，两数之间空格隔开。 数据范围 2≤N≤105, 保证集合中各元素以及所有元素之
ubuntu16-22离线一键安装ftp服务安装包
10-27
本教程将详细讲解如何在Ubuntu 16.04上离线安装FTP服务，基于提供的"ubuntu16-22离线一键安装ftp服务安装包"。 首先，我们需要了解FTP服务的核心组件——vsftpd（Very Secure FTP Daemon）。vsftpd是Linux系统中最...
扩展I/O功能的PCA9554
01-15
PCA9554的封装类型包括SSOP、VQFN和QFN三种，分别为16引脚、16引脚和16引脚。器件的尺寸分别为6.20mm x 5.30mm、4.00mm x 4.00mm和3.00mm x 3.00mm。 PCA9554是一个功能强大、灵活性高的I/O扩展器，能够满足大多数...
万能网卡驱动兼容win7 / xp
08-04
Intel 946-G35/Q35系列集成显卡驱动15.12.75.4.1930版For Win7-32 [22.57M] 2009年10月29日 是 Intel B43/G41/G43/G45/Q43/Q45(包括移动版)系列芯片组集成显卡驱动14.42.11.5355版For WinXP-32/XP-64 [17.81M] ...
AcWing 1603. 整数集合划分
Andy尘的博客
01-25 212
给定一个包含N个正整数的集合，请你将它们划分为两个不相交的集合A1和A2，其中A1包含n1个元素，A2包含n2个元素。 用S1表示集合A1内所有元素之和，S2表示集合A2内所有元素之和。 请你妥善划分，使得 |n1−n2|尽可能小，并在此基础上|S1−S2|尽可能大。 输入格式 第一行包含整数N。 第二行包含N个正整数。 输出格式 再一行中输出|n1−n2| 和|S1−S2|，两数之间空格隔开。 数据范围 2≤N≤10^5, 保证集合中各...
数对的最大曼哈顿距离[ABC178E] Dist Max
2301_80882026的博客
10-30 500
/曼哈顿距离化简绝对值之后最终可以化简为两种取最大的即可PII p[N];cin >> n;i <= n;
代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数
Zuoriqiufeng的博客
10-30 403
【代码】代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数。
xtu oj 连接字符串
Go offline for a while
10-30 964
最后总结一下：这题思路比较直观，找公共的元素，代码细节比较多，一个是要求输出字典序小的，第二是前面字符串要枚举完最后一个元素才算满足条件，第三是两个字符串可能完全没有公共部分，需要特判。
二分查找算法—C++
最新发布
2401_82677021的博客
11-03 320
关于求中点位置的操作什么时候需要加1，什么时候不需要。只需看下面的left和right ，如果出现-1，mid就需要加1。否则，不需要加1.
【力扣打卡系列】二分查找(搜索旋转排序数组)
qq_45734745的博客
10-29 306
坚持按题型打卡&刷&梳理力扣算法题系列，语言为go，Day11。
《Java 实现希尔排序：原理剖析与代码详解》
qq_69304031的博客
11-03 512
在排序算法的大家族中，希尔排序是一种改进的插入排序算法，它通过将原始数据分成多个子序列进行预排序，然后逐渐缩小子序列的间隔，最终对整个序列进行常规的插入排序，从而在一定程度上提高了排序的效率。希尔排序的基本思想基于插入排序，但它引入了一个间隔序列（也称为增量序列）的概念，使得排序过程不再是逐个元素地进行比较和插入，而是先对相隔一定间隔的元素进行比较和插入操作，随着排序的进行，间隔逐渐缩小，直到最后间隔为 1，此时就相当于进行了一次普通的插入排序。，经过希尔排序后，控制台会输出排序后的数组，其结果应该是。
JAVA学习-练习试用Java实现“数组排序”
weixin_69763181的博客
11-03 100
这个程序首先导入了'java.util.Arrays'和'java.util.Scanner'，然后定义了一个'main'方法。程序使用'Scanner'类来读取用户的输入，并将其分割成一个字符串数组。然后，它将字符串数组转换成整数数组，并使用'Arrays.sort'方法对整数数组进行排序。以下是一个Java程序，它使用内置的'Arrays.sort'方法对用户输入的整数数组进行排序。编写一个Java程序，对用户输入的整数数组进行排序（可以使用内置的Arrays.sort方法，也可以自己实现排序算法）。
迷宫求解：探索最优路径的算法与应用
liaozp88的博客
11-02 150
迷宫求解问题通常可以通过图搜索算法来解决，常用的方法包括广度优先搜索（BFS）、深度优先搜索（DFS）和A*算法。
ES6/ES7文档与示例代码的实践应用
列表中还包含了多个以数字和-es.js命名的JavaScript文件（22-es.js、14-es.js、21-es.js、08-es.js、23-es.js、18-es.js、25-es.js、16-es.js），这些文件中应该包含了各种ES6/ES7的代码实现示例。通过这些代码，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Dull丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值