线性基大发现

news2024/11/18 9:35:39

一.构造方法

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.coloradmin.cn/o/2133099.html

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

相关文章

“百度热搜”揭示月饼遇冷背后：如何在经济下行中理性消费 + 应对风险？

“百度热搜”揭示月饼遇冷背后：如何在经济下行中理性消费 + 应对风险？

中秋将至，月饼本该成为节日的主角。然而，令人惊讶的是，近期的“百度热搜”显示月饼销售出现了前所未有的冷遇。这背后的原因是什么？在经济下行的背景下，人们的消费观念正悄然转变。今天，我们就来聊聊如何在这样的经济环境中保持理性消费，并应对潜在的经济风险。 经济下行…
阅读更多...
数组去重、数组扁平化

数组去重、数组扁平化

数组去重 排序然后for循环判断相邻的两个是否一样 定义新数组&#xff0c;for循环新数组中没有这个元素就添加 利用对象的键&#xff0c;需要新建对象和数组 利用双重for循环判断 利用for循环和indexOf判断是否存在 利用newSet构造函数不接受重复数据 数组扁平化
阅读更多...
visual studio code下载教程（手把手）

visual studio code下载教程（手把手）

今天我来给大家介绍一下visual studio code (VScode)的下载 一、VSCode介绍 VSCode 是一款由微软开发且跨平台的免费源代码编辑器&#xff1b;该软件支持语法高亮、代码自动补全、代码重构、查看定义功能&#xff0c;并且内置了命令行工具和 Git 版本控制系统。 二、官方下载…
阅读更多...
谷歌将把那些冗长的文档变成你下一个最喜欢的播客

谷歌将把那些冗长的文档变成你下一个最喜欢的播客

如果你有很多学校或工作的阅读任务&#xff0c;但更喜欢听播客&#xff0c;谷歌全新的AI驱动的Audio Overview工具可以满足你的需求。这项工具首次在今年的Google I/O大会上展示&#xff0c;Audio Overviews可以让你将文档、幻灯片和其他文本转换为一个AI主持的音频节目&#x…
阅读更多...
深度学习：入门简介

深度学习：入门简介

目录 一、深度学习与机器学习的关系 二、神经网络构造 三、推导 四、感知器与多层感知器 1.感知器 2.多层感知器 3.偏置 五、如何确定输入层和输出层个数 一、深度学习与机器学习的关系 深度学习是一种机器学习的子领域&#xff0c;利用多层神经网络来学习数据的复杂特…
阅读更多...
Windows技术栈企业基础底座(1)-为基于Windows的Nginx安装证书

Windows技术栈企业基础底座(1)-为基于Windows的Nginx安装证书

企业的基础环境是一个组织的信息化数字化底座。传统企业基础环境多种系统&#xff0c;应用交杂&#xff0c;多种技术栈使得深入运维成本极大&#xff0c;且人员知识技能较难复用&#xff0c;造成资源浪费。本系列旨在尝试推动这一理念, 建立Windows, 或linux聚焦的技术栈的企业…
阅读更多...
部署自己的对话大模型，使用Ollama + Qwen2 +FastGPT 实现

部署自己的对话大模型，使用Ollama + Qwen2 +FastGPT 实现

部署资源 AUTODL 使用最小3080 资源&#xff0c;cuda > 12.0使用云服务器&#xff0c;部署fastGPT oneAPI&#xff0c;M3E 模型 操作步骤 配置代理 export HF_ENDPOINThttps://hf-mirror.com下载qwen2模型 huggingface-cli download Qwen/Qwen2-7B-Instruct-GGUF qwen2-7…
阅读更多...
Flutter能赚钱，你还担心它被Google抛弃吗？

Flutter能赚钱，你还担心它被Google抛弃吗？

哈喽&#xff0c;我是老刘 Flutter自从诞生以来有很多的质疑和担心。 其中Flutter会不会被Google放弃是大家最重要的一个担心。 尤其是前段时间Flutter团队裁员后这种担心达到了顶点。 但是由LeanCode主导的一次针对Flutter的技术调查报告&#xff0c;应该能很大程度上解答这个…
阅读更多...
为什么要分库分表

为什么要分库分表

目录 为什么分库分表业务驱动分库分表优缺点优点缺点 如何分库分表分库分表原则分库多少合适分表多少合适分库分表字段选择逻辑 库或表不够怎么办数据归档 为什么分库分表 业务驱动 业务&#xff1a;增长快&#xff0c;业务复杂度高。系统流量疯狂增长&#xff0c;部分大表数…
阅读更多...
[linux 驱动]i2c总线设备驱动详解与实战

[linux 驱动]i2c总线设备驱动详解与实战

目录 1 描述 2 结构体 2.1 bus_type 2.2 i2c_bus_type 2.2.1 i2c_device_match 2.2.2 i2c_device_probe 2.2.3 i2c_device_remove 2.2.4 i2c_device_shutdown 2.2 i2c_adapter 2.3 i2c_algorithm 2.4 i2c_driver 2.5 i2c_client 3 i2c核心 3.1 注册i2c适配器 3.2…
阅读更多...
windows电脑怎么录屏？电脑录屏全攻略，轻松捕捉精彩瞬间

windows电脑怎么录屏？电脑录屏全攻略，轻松捕捉精彩瞬间

在数字化时代&#xff0c;屏幕录制已成为我们日常生活和工作中不可或缺的一部分。无论是记录游戏的高光时刻、制作教学视频&#xff0c;还是保存重要的在线会议内容&#xff0c;Windows电脑都为我们提供了多种高效便捷的录屏方式&#xff0c;如果你还不知道怎么录屏&#xff0c…
阅读更多...
什么是领域驱动设计？

什么是领域驱动设计？

什么是领域驱动设计&#xff1f; 领域驱动设计&#xff08;Domain-Driven Design&#xff0c;简称DDD&#xff09;是一种面向对象的软件开发方法&#xff0c;它强调将软件系统的设计和实现过程与业务领域紧密结合&#xff0c;通过深入理解和建模业务领域&#xff0c;从而实现高…
阅读更多...
抓包工具检测手把手教学 - 某招聘网站

抓包工具检测手把手教学 - 某招聘网站

大家好&#xff0c;我是南枫~~~ 先问大家一个问题&#xff0c;你们有没有遇到过想爬一个网站&#xff0c;想用老方法&#xff0c;直接右键打开抓包工具&#xff0c;此时&#xff0c;突然&#xff01;整个页面都变得空白&#xff0c;什么数据都没有了的情况…… 如果你没遇到过…
阅读更多...
探索MySQL视图的无限可能：优化查询、增强数据安全与简化数据访问

探索MySQL视图的无限可能：优化查询、增强数据安全与简化数据访问

作者简介&#xff1a;我是团团儿&#xff0c;是一名专注于云计算领域的专业创作者&#xff0c;感谢大家的关注 座右铭&#xff1a; 云端筑梦&#xff0c;数据为翼&#xff0c;探索无限可能&#xff0c;引领云计算新纪元 个人主页&#xff1a;团儿.-CSDN博客 目录 前言&#…
阅读更多...
OpenAI发布o1预览模型：推理能力更强可达理科博士生水准

OpenAI发布o1预览模型：推理能力更强可达理科博士生水准

近日OpenAI宣布推出了新一代 AI 模型系列 OpenAI o1&#xff0c;按照官方技术博客说法&#xff0c;o1 在推理能力上代表了人工智能最强的水平。 那究竟是怎么一回事呢&#xff1f; OpenAI CEO Sam Altman 表示&#xff1a;o1 系列的推出代表了 AI 能力的新起点&#xff0c;能…
阅读更多...
用Python设置PDF中图片的透明度

用Python设置PDF中图片的透明度

在PDF文档的设计与内容创作过程中&#xff0c;图像的透明度设置是一个重要的操作。尤其是在处理图文密集型PDF文档时&#xff0c;设置适当的图片透明度能够极大地提升视觉表达的层次感与专业性。设置PDF图像的透明度能够让图像更好地融入背景&#xff0c;实现平滑过渡的效果&am…
阅读更多...
PAT甲级-1028 List Sorting

PAT甲级-1028 List Sorting

题目 题目大意 输入给出学生数目和C值&#xff0c;以及每个学生的信息。要求按照C值对学生信息作出不同的排序&#xff0c;如果C为1&#xff0c;就将学号升序排列&#xff1b;如果C为2&#xff0c;将学生姓名非递减排序&#xff1b;如果C为3&#xff0c;将学生分数非递减排序。…
阅读更多...
SldWorks问题1: 在装配体中获取零件的面

SldWorks问题1: 在装配体中获取零件的面

问题 我为零件的某个面进行了命名&#xff0c;以此查找&#xff0c;进行配合。 在使用先前写好的查找方法时&#xff0c;有时会出现找不到的情况。 然后捣鼓了半天&#xff0c;发现&#xff1a; 只有当“零件文档显示的配置&#xff0c;和已放置的零件配置一致”时&#xff…
阅读更多...
《C++PrimerPlus》第10章：类和对象

《C++PrimerPlus》第10章：类和对象

文章目录 文章介绍目录重点知识10.2 抽象和类10.3 类的构造函数和析构函数10.4 this指针10.5 对象数组10.6 类作用域 文章介绍 目录 重点知识 10.2 抽象和类 类开发人员&#xff1a;设计类 类调用人员&#xff1a;使用类 10.3 类的构造函数和析构函数 10.4 this指针 10.5 对…
阅读更多...
微服务杂谈

微服务杂谈

几个概念 还是第一次听说Spring Cloud Alibaba &#xff0c;真是孤陋寡闻了&#xff0c;以前只知道 SpringCloud 是为了搭建微服务的&#xff0c;spring boot 则是快速创建一个项目&#xff0c;也可以是一个微服务 。那么SpringCloud 和 Spring boot 有什么区别呢&#xff1f;S…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023