线性基大发现

一.构造方法

1.贪心法（每一个数往里插入即可）

/*贪心法构造线性基的特点：
1.从小到大排列
2.各个基的高位可能存在重复的1
2.线性基不是唯一的，与原集合的元素顺序有关*/
void insert(int x){//贪心法
    for(int i=63;i>=0;i--){
        if(!(x>>i)) continue;//x第i位为1
        if(!p[i]){//已存在p[i]
            p[i]=x;
            break;
        }
        x^=p[i];//不存在的话加上再异或
    }
}

2.高斯消元法（统一插入）

/*高斯消元构造线性基特点：
1.从大到小排列
2.各个基的高位没有重复的1*/
void gauss(){
    k=0;
    for(int i=62;i>=0;i--){
        //把当前第i位是1的数换上去
        for(int j=k;j<n;j++){
            if(a[j]>>i&1){
                swap(a[j],a[k]);
                break;
            }
        }
        //当前第i位的所有向量都是0
        if((a[k]>>i&1)==0) continue;
        //当前第i位全部消为0
        for(int j=0;j<n;j++){
            if(j!=k&&(a[j]>>i&1)) a[j]^=a[k];
        }
        //基的个数+1
        k++;
        if(k==n) break;
    }
}

 二.例题

 1.P3812 【模板】线性基

 贪心：

#include<bits/stdc++.h>
using namespace std;
#define fast ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define For(i,j,k) for (int i=(j);i<=(k);i++)
#define rof(i,j,k) for (int i=(j);i>=(k);i--)
#define ull unsigned long long
#define lowbit(x) ((x)&(-(x)))
#define PII pair<int,int>
#define int long long
#define endl "\n"
#define ls rt<<1
#define rs rt<<1|1
typedef long long ll;
const int mod = 998244353;
const int N=2e5+7;
int n,m;
int p[70];
/*贪心法构造线性基的特点：
1.从小到大排列
2.各个基的高位可能存在重复的1
2.线性基不是唯一的，与原集合的元素顺序有关*/
void insert(int x){//贪心法
    for(int i=63;i>=0;i--){
        if(!(x>>i)) continue;//x第i位为1
        if(!p[i]){//已存在p[i]
            p[i]=x;
            break;
        }
        x^=p[i];//不存在的话加上再异或
    }
}
void solve(){
    cin>>n;
    int a;
    for(int i=1;i<=n;i++){
        cin>>a;
        insert(a);
    }
    int ans=0;
    for(int i=63;i>=0;i--){
        ans=max(ans,ans^p[i]);
    }
    cout<<ans<<endl;
}
signed main(){
    fast;
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
}

高斯消元法：

 

#include<bits/stdc++.h>
using namespace std;
#define fast ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define For(i,j,k) for (int i=(j);i<=(k);i++)
#define rof(i,j,k) for (int i=(j);i>=(k);i--)
#define ull unsigned long long
#define lowbit(x) ((x)&(-(x)))
#define PII pair<int,int>
#define int long long
#define endl "\n"
#define ls rt<<1
#define rs rt<<1|1
typedef long long ll;
const int mod = 998244353;
const int N=2e5+7;
int n,m,k;
int a[N];
/*高斯消元构造线性基特点：
1.从大到小排列
2.各个基的高位没有重复的1*/
void gauss(){
    k=0;
    for(int i=62;i>=0;i--){
        //把当前第i位是1的数换上去
        for(int j=k;j<n;j++){
            if(a[j]>>i&1){
                swap(a[j],a[k]);
                break;
            }
        }
        //当前第i位的所有向量都是0
        if((a[k]>>i&1)==0) continue;
        //当前第i位全部消为0
        for(int j=0;j<n;j++){
            if(j!=k&&(a[j]>>i&1)) a[j]^=a[k];
        }
        //基的个数+1
        k++;
        if(k==n) break;
    }
}
void solve(){
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>a[i];
    }
    gauss();
    int ans=0;
    for(int i=0;i<k;i++){
        ans^=a[i];
    }
    cout<<ans<<endl;
}
signed main(){
    fast;
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
}

排列好从大到小异或即可。  

2. hdu3949

这里记得分三种情况，当k即线性基的个数小于n时会有0的出现，另外当大于2的k次方时说明不存在特判一下即可。 

#include<bits/stdc++.h>
using namespace std;
#define fast ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define For(i,j,k) for (int i=(j);i<=(k);i++)
#define rof(i,j,k) for (int i=(j);i>=(k);i--)
#define ull unsigned long long
#define lowbit(x) ((x)&(-(x)))
#define PII pair<int,int>
#define int long long
#define endl "\n"
#define ls rt<<1
#define rs rt<<1|1
typedef long long ll;
const int mod = 998244353;
const int N=2e5+7;
int n,m,k;
int a[N];
void gauss(){
    k=0;//从第一位开始
    for(int i=62;i>=0;i--){
        //把当前第i位是1的数换上去
        for(int j=k;j<n;j++){
            if(a[j]>>i&1){
                swap(a[j],a[k]);
                break;
            }
        }
        //当前第i位的所有向量都是0
        if((a[k]>>i&1)==0) continue;
        //当前第i位全部消为0
        for(int j=0;j<n;j++){
            if(j!=k&&(a[j]>>i&1)) a[j]^=a[k];
        }
        //基的个数+1
        k++;
        if(k==n) break;
    }
}
void solve(){
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>a[i];
    }
    gauss();
    cin>>m;
    while(m--){
        int num=0;
        cin>>num;
        if(k!=n) num--;//因为线性基中不包括0所以如果小于n说明会有0出现第1个最小的也会有所以--
        if((1LL<<k)<=num) cout<<"-1"<<endl;
        else{
            int ans=0;
            for(int i=0;i<k;i++){
                //第i小实际上就是直接看这个数每一位是不是1就好
                if(num>>i&1) ans^=a[k-i-1];
            }
            cout<<ans<<endl;
        }
    }
}
signed main(){
    fast;
    int t=1;
    cin>>t;
    int T=t;
    while(T--){
        cout<<"Case #"<<t-T<<":"<<endl;
        solve();
    }
}

3.P3857 [TJOI2008] 彩灯 

 

 

 这个把每个数当成进制处理即可。

#include<bits/stdc++.h>
using namespace std;
#define fast ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define For(i,j,k) for (int i=(j);i<=(k);i++)
#define rof(i,j,k) for (int i=(j);i>=(k);i--)
#define ull unsigned long long
#define lowbit(x) ((x)&(-(x)))
#define PII pair<int,int>
#define int long long
#define endl "\n"
#define ls rt<<1
#define rs rt<<1|1
typedef long long ll;
const int mod = 998244353;
const int N=2e6+7;
int n,m,k;
int a[N];
void gauss(){
    k=0;
    for(int i=62;i>=0;i--){
        //把当前第i位是1的数换上去
        for(int j=k;j<m;j++){
            if(a[j]>>i&1){
                swap(a[j],a[k]);
                break;
            }
        }
        //当前第i位的所有向量都是0
        if((a[k]>>i&1)==0) continue;
        //当前第i位全部消为0
        for(int j=0;j<m;j++){
            if(j!=k&&(a[j]>>i&1)) a[j]^=a[k];
        }
        //基的个数+1
        k++;
        if(k==m) break;
    }
}
void solve(){
    cin>>n>>m;
    for(int i=0;i<m;i++){
        string s;
        cin>>s;
        int x=1;
        for(int j=0;j<n;j++){
            if(s[j]=='O'){
                a[i]+=x;
            }
            x*=2;
        }
    }
    gauss();
    int ans=pow(2,k);
    ans=ans%2008;
    cout<<ans<<endl;
}
signed main(){
    fast;
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
}

4.P4570 [BJWC2011] 元素

 

 这个就与上面不同了，不可以直接使用高斯消元法因为我们发现这个只取其中一些个，并且与先异或无关，所以这时候我们采用贪心法线性基。

#include<bits/stdc++.h>
using namespace std;
#define fast ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define For(i,j,k) for (int i=(j);i<=(k);i++)
#define rof(i,j,k) for (int i=(j);i>=(k);i--)
#define ull unsigned long long
#define lowbit(x) ((x)&(-(x)))
#define PII pair<int,int>
#define int long long
#define endl "\n"
#define ls rt<<1
#define rs rt<<1|1
typedef long long ll;
const int mod = 998244353;
const int N=2e6+7;
int n,m;
struct node{
    int num;
    int val;
}p[70],a[N];
bool cmp(node x,node y){
    return x.val>y.val;
}
//贪心法最好的就是你可以想办法将你大的先拿再进行线性基解决
void insert(node x){
    for(int i=60;i>=0;i--){
        if((x.num>>i&1)==0) continue;
        if(p[i].num){
            x.num^=p[i].num;
        }else{
            p[i]=x;
            break;
        }
    }
}
void solve(){
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>a[i].num>>a[i].val;
    }
    sort(a,a+n,cmp);
    for(int i=0;i<n;i++){
        insert(a[i]);
    }
    int ans=0;
    for(int i=0;i<60;i++){
        ans+=p[i].val;
    }
    cout<<ans<<endl;
}
signed main(){
    fast;
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
}

5.P4301 [CQOI2013] 新Nim游戏 

这就属于很典型的用了个nim游戏的结论。我们只需要让后手无论怎么取都不能将后面异或值为0即可，所以让后面形成线性基，即我们取线性基以外的数即可。

#include<bits/stdc++.h>
using namespace std;
#define fast ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define For(i,j,k) for (int i=(j);i<=(k);i++)
#define rof(i,j,k) for (int i=(j);i>=(k);i--)
#define ull unsigned long long
#define lowbit(x) ((x)&(-(x)))
#define PII pair<int,int>
#define int long long
#define endl "\n"
#define ls rt<<1
#define rs rt<<1|1
typedef long long ll;
const int mod = 998244353;
const int N=2e6+7;
int n,m,k;
int a[N];
int p[N];
int ans=0;
/*我们先手取尽可能少的数，使得局面形成线性基，
这样无论后手怎么取，一定是我们赢*/
void insert(int x){//贪心法
    int y=x;
    for(int i=63;i>=0;i--){
        if(!(x>>i)) continue;//x第i位为1才继续走
        if(!p[i]){//已存在p[i]
            p[i]=x;
            break;
        }
        x^=p[i];//不存在的话加上再异或
    }
    if(x==0) ans+=y;//不是线性基的直接拿走
}
bool cmp(int x,int y){
    return x>y;
}
void solve(){
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    sort(a+1,a+n+1,cmp);//因为要取最小所以我们排个序
    for(int i=1;i<=n;i++){
        insert(a[i]);
    }
    cout<<ans<<endl;
}
signed main(){
    fast;
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
}

 6.P4151 [WC2011] 最大XOR和路径

 

 

简单情况下，图分为一条主链和若干个环，沿着主链走，中间碰到环可以走也可以不走。

相当于把所有的环插入一个集合再考虑要不要异或，求最大值即可。

一般情况下，多条主链和多条环，两条主链就构成一个环，

所以还是相当于把环放入之后用一个总的异或长度在异或换的线性基

#include<bits/stdc++.h>
using namespace std;
#define fast ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define For(i,j,k) for (int i=(j);i<=(k);i++)
#define rof(i,j,k) for (int i=(j);i>=(k);i--)
#define ull unsigned long long
#define lowbit(x) ((x)&(-(x)))
#define PII pair<int,int>
#define int long long
#define endl "\n"
#define ls rt<<1
#define rs rt<<1|1
typedef long long ll;
const int mod = 998244353;
const int N=2e6+7;
int n,m;
int p[70];
int sum[N];
int ans,cnt;
int vis[N];
/*简单情况下，图分为一条主链和若干个环，沿着主链走，中间碰到环可以走也可以不走。
相当于把所有的环插入一个集合再考虑要不要异或，求最大值即可。

一般情况下，多条主链和多条环，两条主链就构成一个环，
所以还是相当于把环放入之后用一个总的异或长度在异或换的线性基*/
struct Edge
{
    int to, w, next;//终点，边权，同起点的上一条边的编号
}edge[N];//边集
int head[N];//head[i],表示以i为起点的第一条边在边集数组的位置（编号）
void init()//初始化
{
    for (int i = 0; i <= n; i++) head[i] = -1;
    cnt = 0;
}
void add_edge(int u, int v, int w)//加边，u起点，v终点，w边权
{
    edge[cnt].to = v; //终点
    edge[cnt].w = w; //权值
    edge[cnt].next = head[u];//以u为起点上一条边的编号，也就是与这个边起点相同的上一条边的编号
    head[u] = cnt++;//更新以u为起点上一条边的编号
}
void insert(int x){//贪心法
    for(int i=63;i>=0;i--){
        if(!(x>>i)) continue;//x第i位为1
        if(!p[i]){//已存在p[i]
            p[i]=x;
            break;
        }
        x^=p[i];//不存在的话加上再异或
    }
}
//可以想一想为什么dfs在这里不会T
void dfs(int x,int s){
    vis[x]=1;
    sum[x]=s;
    for(int i=head[x];i!=-1;i=edge[i].next){
       int y=edge[i].to;
       if(!vis[y]){
        dfs(y,edge[i].w^sum[x]);
       }else{
        insert(edge[i].w^sum[x]^sum[y]);
       }
    }
}
void solve(){
    cin>>n>>m;
    init();
    for(int i=1;i<=m;i++){
        int u,v,w;
        cin>>u>>v>>w;
        add_edge(u,v,w);
        add_edge(v,u,w);
    }
    dfs(1,0);
    ans=ans^sum[n];//1到n链异或和
    for(int i=63;i>=0;i--){
        ans=max(ans,ans^p[i]);//因为要取大的所以从大的开始异或
    }
    cout<<ans<<endl;
}
signed main(){
    fast;
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
}

 7.P3265 [JLOI2015] 装备购买

 

 这个就是一个很普遍性的高斯消元了，我们就是相当于把一个矩阵做成线性基。这道题要注意的一个点事eps开1e-3可以但1e-6等就不能了，可能还是评测数据的原因QAQ。

#include<bits/stdc++.h>
using namespace std;
#define fast ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define For(i,j,k) for (int i=(j);i<=(k);i++)
#define rof(i,j,k) for (int i=(j);i>=(k);i--)
#define ull unsigned long long
#define lowbit(x) ((x)&(-(x)))
#define PII pair<int,int>
#define int long long
#define endl "\n"
#define ls rt<<1
#define rs rt<<1|1
typedef long long ll;
const int mod = 998244353;
const int N=700;
const double eps=1e-3;//这里过小会wa
int n,m,k;
int ans,cnt;
struct node{
    double z[N];
    int c;
}a[N];
int p[N];
bool cmp(node x,node y){
    return x.c<y.c;
}
void gauss(){//高斯消元
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(fabs(a[i].z[j])>eps){//如果(i,j)>0
                if(!p[j]){ //如果p[j]不存在
                    ans+=a[i].c; //累计花费
                    p[j]=i; //记录最高位为第j为的线性基
                    cnt++; //累计个数
                    break;
                }else{ //如果p[j]存在，则进行消元
                    double d=a[i].z[j]/a[p[j]].z[j];
                    for(int k=j;k<=m;k++){
                        a[i].z[k]-=a[p[j]].z[k]*d;
                    }
                }
            }
        }
    }
}
void solve(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            cin>>a[i].z[j];
        }
    }
    for(int i=1;i<=n;i++){
        cin>>a[i].c;
    }
    sort(a+1,a+n+1,cmp);
    gauss();
    cout<<cnt<<" "<<ans<<endl;
}
signed main(){
    fast;
    int t=1;
    //cin>>t;
    while(t--){
        solve();
    }
}

我觉得最难的还是你知道什么时候用贪心什么时候用高斯消元做线性基，知道以后还要会结合才能做出这类题，所以加油吧！！！

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

c#中给winform定义快捷键的几种方式

c#中给winform定义快捷键的几种方式

快捷键的使用在日常的开发中频率比较高&#xff0c;这里总结了最常见的各种快捷键的设置方式&#xff0c;需要的时候大家直接照抄就可以了&#xff0c;不用再去查询如何实现了。 文章目录 一、按钮快捷键二、菜单快捷键三、全局快捷键1、重写ProcessCmdKey2、使用KeyPreview属…
阅读更多...
Word使用手册

Word使用手册

修改样式 编辑word文档时&#xff0c;标题和正文文本通常有不同的格式&#xff0c;如果能将这些格式保存为样式&#xff0c;下一次就能直接调用样式&#xff0c;而不需要重复手动设置格式。 可以将样式通常保存为不同的 样式模板.docx&#xff0c;要调用不同样式集&#xff0…
阅读更多...
MATLAB基础应用精讲-【数模应用】卡方拟合优度检验（附MATLAB、python和R语言代码实现）

MATLAB基础应用精讲-【数模应用】卡方拟合优度检验（附MATLAB、python和R语言代码实现）

目录 前言 几个高频面试题目 卡方分布与拟合优度的卡方检验是什么关系？ 算法原理 什么是卡方检验 卡方是什么？ 如何使用卡方表计算器？ 什么是卡方拟合优度检验 使用条件 基本原理 数学模型 卡方检验自由度 理论频数计算 需要注意的事项 卡方检验分类 1、 独…
阅读更多...
校园管理系统创新：Spring Boot框架应用案例

校园管理系统创新：Spring Boot框架应用案例

第4章 系统设计 4.1 系统体系结构 校园管理系统的结构图4-1所示&#xff1a; 图4-1 系统结构 登录系统结构图&#xff0c;如图4-2所示&#xff1a; 图4-2 登录结构图 校园管理系统结构图&#xff0c;如图4-3所示。 图4-3 校园管理系统结构图 4.2开发流程设计 系统流程的分…
阅读更多...
走进低代码表单开发（一）：可视化表单数据源设计

走进低代码表单开发（一）：可视化表单数据源设计

在前文&#xff0c;我们已对勤研低代码平台的报表功能做了详细介绍。接下来&#xff0c;让我们深入探究低代码开发中最为常用的表单设计功能。一个完整的应用是由众多表单组合而成的&#xff0c;所以高效的表单设计在开发过程中起着至关重要的作用。让我们一同了解勤研低代码开…
阅读更多...
网络安全要点总结

网络安全要点总结

1. 入侵检测与防御： 1）入侵检测与系统IDS(intrusion detection system):防火墙之后的第二道闸门； IDS的部署：采用镜像端口或者集线器方式；部署在：服务器交换机上，internet接入路由器后面的第一台交换机上； IRSintrusion response system入侵响应系统： 2）.IPS（…
阅读更多...
如何进行大模型训练和微调？（实战）

如何进行大模型训练和微调？（实战）

1、在项目中&#xff0c;如果prompt和function calling足够好&#xff0c;尽量不要微调&#xff0c;节约成本。 以下是针对function calling的slot&#xff0c;评估准确率&#xff08;识别准确度&#xff09;、召回率&#xff08;全面率&#xff09;&#xff0c;F1值。 从中可以…
阅读更多...
华为初级认证HCIA怎么样？

华为初级认证HCIA怎么样？

想在网络技术领域实现职业突破吗&#xff1f;华为HCIA初级认证是专为网络领域的新手与初学者设计的一项入门级认证。它旨在评估并确认个人对网络基本原理和技术知识的扎实掌握&#xff0c;是步入华为认证体系大门的基石。 一、华为HCIA 初级认证概述 华为初级认证网络工程师&am…
阅读更多...
为OneAPI配置MySQL数据库及设置开机启动

为OneAPI配置MySQL数据库及设置开机启动

OneAPI启动时&#xff0c;如果发现没有数据库他会在项目根目录自动创建SqlLit&#xff0c;为提高OneAPI的性能及管理&#xff0c;这里给出一个使用MySQL数据库的案例&#xff0c;同时本文介绍如何在源码部署的情况下&#xff0c;设置OneAPI的开机自动启动。 OneAPI的源代码安装…
阅读更多...
【Qt】实现顶部导航栏自适应滑动效果

【Qt】实现顶部导航栏自适应滑动效果

需求&#xff1a; 顶部导航栏有若干选项&#xff0c;可能很多&#xff0c;顶部区域不能完全展示&#xff0c;比如10个选项&#xff0c;界面一次只能展示五个&#xff0c;那么要求把后面的选项隐藏起来&#xff0c;并且&#xff0c;当点击第四个第五个按钮的时候&#xff0c;自…
阅读更多...
Android Studio 加载多个FLutter项目

Android Studio 加载多个FLutter项目

按顺序操作即可 选择工程 选择Modules, 导入 module 选中创建module 选择要导入的目录&#xff0c;只选择主目录&#xff0c;下面的文件不要选 添加完成&#xff0c;点击ok后&#xff0c;会进行导入 最终导入成功
阅读更多...
【rpg像素角色】俯视角-行走动画

【rpg像素角色】俯视角-行走动画

制作像素角色的俯视角行走动画并不像看上去那么复杂&#xff0c;尤其是在你已经完成了角色的4个方向站立姿势之后&#xff08;其中左右方向可以通过水平翻转实现&#xff09;。接下来&#xff0c;我会一步步为你讲解如何制作行走动画。 1. 理解行走规律 在制作行走动画之前&am…
阅读更多...
堆排序

堆排序

一&#xff1a;思想 堆排序(Heapsort)是指利用 堆 这种数据结构所设计的一种排序算法&#xff0c;它是选择排序的一种。它是通过堆来进行选择数据。 动图&#xff1a; 二&#xff1a;实现思路 假设&#xff1a;现在对一个7个整形的数组进行升序堆排&#xff08;2 1 5 7 4 3 …
阅读更多...
基于 CycleGAN 对抗网络的自定义数据集训练

基于 CycleGAN 对抗网络的自定义数据集训练

目录 生成对抗网络&#xff08;GAN&#xff09; CycleGAN模型训练 训练数据生成 下载开源项目CycleGAN 配置训练环境 开始训练 模型测试 可视化结果 生成对抗网络&#xff08;GAN&#xff09; 首先介绍一下什么是GAN网络&#xff0c;它是由生成器&#xff08;Generator…
阅读更多...
【CTF Web】BUUCTF Upload-Labs-Linux Pass-13 Writeup（文件上传+PHP+文件包含漏洞+PNG图片马）

【CTF Web】BUUCTF Upload-Labs-Linux Pass-13 Writeup（文件上传+PHP+文件包含漏洞+PNG图片马）

Upload-Labs-Linux 1 点击部署靶机。 简介 upload-labs是一个使用php语言编写的&#xff0c;专门收集渗透测试和CTF中遇到的各种上传漏洞的靶场。旨在帮助大家对上传漏洞有一个全面的了解。目前一共20关&#xff0c;每一关都包含着不同上传方式。 注意 1.每一关没有固定的…
阅读更多...
Modbus协议02：存储区简介

Modbus协议02：存储区简介

视频链接&#xff1a;【2】Modbus协议存储区说明_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV11G4y1W7pU?p2&vd_sourceb5775c3a4ea16a5306db9c7c1c1486b5 1.为什么需要存储区、存储区类型及代号 2.Modbus存储区范围及地址模型
阅读更多...
SLM561A​​系列 60V 10mA到50mA线性恒流LED驱动芯片 为智能家居照明注入新活力

SLM561A​​系列 60V 10mA到50mA线性恒流LED驱动芯片 为智能家居照明注入新活力

SLM561A系列选型参考&#xff1a; SLM561A10ae-7G SOD123 SLM561A15ae-7G SOD123 SLM561A20ae-7G SOD123 SLM561A25ae-7G SOD123 SLM561A30ae-7G SOD123 SLM561A35ae-7G SOD123 SLM561A40ae-7G SOD123 SLM561A45ae-7G SOD123 SLM561A50ae-7G SOD123 …
阅读更多...
在Webmin上默认状态无法正常显示 Mariadb V11.02及以上版本

在Webmin上默认状态无法正常显示 Mariadb V11.02及以上版本

OS: Armbian OS 24.5.0 Bookworm Mariadb V11.02及以上版本 Webmin&#xff1a;V2.202 非常小众的问题&#xff0c;主要是记录一下。 如题 Webmin 默认无法正常显示 Mariadb V11.02及以上版本 如果对 /etc/webmin/mysql/config 文件作相应调整就可以再现Mariadb管理界面。 路径…
阅读更多...
AI prompt(提示词)

AI prompt(提示词)

# 好用的用于学习的AI提示词 ## 费曼学习法 请使用费曼学习法&#xff0c;用简单的语言解释&#xff08;量子力学&#xff09;是什么&#xff0c;并提供一个简单的例子来说明它如何应用 ## 帕累托法则&#xff08;80/20原则&#xff09; 将&#xff08;量子力学&#xff09;最…
阅读更多...
09_Tensorflow2图像处理大赏：让你的图片笑出AI感，惊艳朋友圈！

09_Tensorflow2图像处理大赏：让你的图片笑出AI感，惊艳朋友圈！

1. 图像处理案例 1.1 逆时针旋转90度 import tensorflow as tf import matplotlib.pyplot as plt import matplotlib.cm as cm import numpy import osdef show_pic(pic,name,cmapNone):显示图像plt.imshow(pic,cmapcmap) plt.axis(off) # 打开坐标轴为 on # 设置图像标题…
阅读更多...
最新文章

Copyright @ 2022~2023