不知道什么的复习题

已于 2022-11-25 09:44:49 修改
阅读量408 收藏
点赞数
文章标签： 深度优先 算法 图论
于 2022-11-24 22:25:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cn_tigerhan/article/details/128012487
版权

P4408 [NOI2003] 逃学的小孩，一眼就看出要化简题面：不就是找三个点使得AB+BC最大嘛，不妨想起直径的性质，最长，而且其他点到它的距离最长。那么直接拿直径来做就行。推导出结论为ans=max(min(dis[A][k],dis[B][k])+dis[A][B]);那么直接求直径算就行，我们尝试贪心的选择路径就行了。

#include<bits/stdc++.h>
#define int long long 
using namespace std;
int n,m,len=0,last[250001],dis[3][250001],A,B;
struct pp
{
	int x,y,c,next;
};pp p[250001];
void ins(int x,int y,int c)
{
	int now=++len;
	p[now]={x,y,c,last[x]};last[x]=now;
	return ;
}
void dfs1(int x,int fa)
{
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;if(y==fa) continue ;
		dis[0][y]=dis[0][x]+p[i].c;dfs1(y,x);
	}
	if(dis[0][x]>dis[0][A]) A=x;
	return ;
} 
void dfs2(int x,int fa)
{
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;if(y==fa) continue ;
		dis[0][y]=dis[0][x]+p[i].c;dfs2(y,x);
	}
	if(dis[0][x]>dis[0][B]) B=x;
	return ;
}
void dfs3(int x,int fa,int k)
{
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;if(y==fa) continue ;
		dis[k][y]=dis[k][x]+p[i].c;dfs3(y,x,k);
	}
	return ;
}
signed main()
{
	memset(last,-1,sizeof(last));
	scanf("%lld%lld",&n,&m);
	for(int i=1;i<=m;i++) 
	{
		int x,y,c;scanf("%lld%lld%lld",&x,&y,&c);
		ins(x,y,c);ins(y,x,c);
	}
	dfs1(1,1);memset(dis[0],0,sizeof(dis[0]));dfs2(A,A);
	dfs3(A,A,1);dfs3(B,B,2);int ans=0;
	for(int i=1;i<=n;i++) ans=max(min(dis[1][i],dis[2][i])+dis[0][B],ans);
	printf("%lld\n",ans); 
	return 0;
}

P3225 [HNOI2012]矿场搭建呃复习一下割点以及不知道什么东西的做法。讨论一下就行,发现一定能在缩完之后得到一颗树，那么不妨推敲一下每种情况的不同。

#include<bits/stdc++.h>
#define int long long 
using namespace std;
int n,m,len=0,last[100001],dfsx[100001],low[100001],dfs_x=0,id[100001],point=0,sum,num;
bool v[100001];
struct pp
{
	int x,y,next;
};pp p[100001];
void ins(int x,int y)
{
	int now=++len;
	p[now]={x,y,last[x]};last[x]=now;
	return ;
}
void CNT(int x,int dd) 
{
	int ch=0;dfsx[x]=low[x]=++dfs_x;
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;
		if(!dfsx[y])
		{
			CNT(y,dd);low[x]=min(low[x],low[y]);//考虑从最上面的点过来	 
			if(low[y]>=dfsx[x]&&dd!=x) v[x]=true;//如果有一个点能被断掉 
			if(x==dd) ch++;//根的情况 
		}
		low[x]=min(low[x],dfsx[y]);//取一手最小值 
	}
	if(ch>=2) v[x]=true;//如果是根的话 
	return ;
}
void dfs(int x)
{
    id[x]=point;//标记 
    if(v[x]) return;
    sum++;//	printf("*");
    for(int i=last[x];i!=-1;i=p[i].next)
    {
        int y=p[i].y;
        if(v[y]&&id[y]!=point) num++,id[y]=point;//统计割点数目。 
        //如果是割点且标记不与遍历的的连通块相同就修改标记。 
        if(!id[y]) dfs(y);
    }
}
signed main()
{
	int tot=0;
	while(scanf("%lld",&n))
	{
		if(!n) break ;int ans1=0,ans2=1,maxx=0 ;
		memset(low,0,sizeof(low));memset(last,-1,sizeof(last));memset(id,0,sizeof(id));
		memset(dfsx,0,sizeof(dfsx));memset(p,0,sizeof(p));memset(v,false,sizeof(v));len=0;dfs_x=0;point=0;
		for(int i=1;i<=n;i++)
		{
			int x,y;scanf("%lld%lld",&x,&y);
			ins(x,y);ins(y,x);maxx=max(max(x,y),maxx);
		}
		for(int i=1;i<=maxx;i++) if(!dfsx[i]) CNT(i,i);
		for(int i=1;i<=maxx;i++)
		{
			if(!v[i]&&!id[i]) 
			{
				point++;num=sum=0;dfs(i);//printf(">>%d\n",point);
				if(!num) ans1+=2,ans2*=sum*(sum-1)/2;
				if(num==1) ans1++,ans2*=sum;
			}
		}
		printf("Case %lld: %lld %lld\n",++tot,ans1,ans2);
	}
	return 0;	
}

P1273 有线电视网，烦人的树形背包，差点没搞出来。一般看到不能直接从上一个点转移的东西，直接状压或者背包好了。气死！注意有一个小细节，每次u合并儿子son的背包时，两层循环中，外层只循环到u在遍历到son之前的叶节点总数，son只循环到son自己子树内的叶节点总数 。那么你的时间是n^2，要是你枚举上当前节点的，那时间就是n ^ 3了。这样复杂度就假了。那么不妨枚举选取了多少个节点，明显可以转移钱。最后再枚举一下就好。https://blog.csdn.net/no1_terminator/article/details/77824790推荐

#include<bits/stdc++.h>
using namespace std;
int n,m,len=0,last[100001],siz[100001],f[4000][4000],tmp[4000],val[4000];
struct pp
{
	int x,y,c,next;
};pp p[100001];
void ins(int x,int y,int c)
{
	int now=++len;
	p[now]={x,y,c,last[x]};last[x]=now;
	return ;
}
void dfs(int x,int fa)
{
	if(x>=n-m+1)
	{
		siz[x]=1;f[x][1]=val[x];
		return ;
	}
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;if(y==fa) continue ;dfs(y,x);
		for(int j=0;j<=siz[x];j++) tmp[j]=f[x][j];
		for(int j=0;j<=siz[x];j++)
		{
			for(int k=0;k<=siz[y];k++) f[x][j+k]=max(f[x][j+k],tmp[j]+f[y][k]-p[i].c);//printf("%d\n",f[x][j+k]);
		}
		siz[x]+=siz[y];
	}
	return ;
}
int main()
{
	memset(last,-1,sizeof(last));memset(f,~0x3f,sizeof(f));
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n-m;i++)
	{
		int x;scanf("%d",&x);
		for(int j=1;j<=x;j++) 
		{
			int y,c;scanf("%d%d",&y,&c);
			ins(i,y,c);
		}
	}
	for(int i=n-m+1;i<=n;i++) scanf("%d",&val[i]);
	for(int i=1;i<=n;i++) f[i][0]=0;
	dfs(1,1);int ans=0;
	for(int i=m;i>=1;i--)
	{//printf("%d  ",f[1][i]);
		if(f[1][i]>=0) 
		{
			printf("%d",i);
			return 0;
		}
	}
	return 0;
}

P2656 采蘑菇

#include<bits/stdc++.h>
using namespace std;
int n,m,len=0,last[100001],dfsx[100001],low[100001],dfs_x=0,id[100001],point=0;
int q[100001],top=0,siz[100001],f[100001],ans=0;bool v[100001];
struct pp
{
	int x,y,c,next,val,re;
};pp p[400001],L[400001];
int getval(int x,int k)
{
	int tot=0;
	while(x) tot+=x,x=x*k/10;
	return tot;
}
void ins(int x,int y,int c)
{
	int now=++len;
	p[now]={x,y,c,last[x]};last[x]=now;
	return ;
}
void SH(int x)
{
	dfsx[x]=low[x]=++dfs_x;
	v[x]=true;q[++top]=x;
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;
		if(!dfsx[y]) SH(y),low[x]=min(low[x],low[y]);
		else if(v[y]) low[x]=min(low[x],dfsx[y]);
	}
	if(dfsx[x]==low[x])
	{
		point++;
		while(dfsx[x]<=dfsx[q[top]])
		{
			id[q[top]]=point;v[q[top]]=false;
			top--,dfs_x--;
		}
	}
	return ;
} 
bool cmp(const pp &x,const pp &y)
{
	if(x.x!=y.x) return x.x<y.x;
	return x.y<y.y;
}
void remake()
{
	memset(last,-1,sizeof(last));len=0;memset(p,0,sizeof(p));
	for(int i=1;i<=m;i++) L[i].x=id[L[i].x],L[i].y=id[L[i].y];
	sort(L+1,L+m+1,cmp);
	for(int i=1;i<=m;i++)
	{
		if(L[i].x==L[i].y) siz[L[i].x]+=getval(L[i].val,L[i].re);
		else ins(L[i].x,L[i].y,L[i].val);
	}
	return ;
}
void dfs(int x)
{
	if(f[x]) return ;
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;
		dfs(y);f[x]=max(f[x],f[y]+p[i].c);
	}
	f[x]+=siz[x];
	return ;
}
int main()
{
	memset(last,-1,sizeof(last));memset(f,0,sizeof(f));
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++)
	{
		int x,y,val,re;double k;scanf("%d%d%d%lf",&x,&y,&val,&k);
		re=k*10;ins(x,y,0);L[i].x=x,L[i].y=y,L[i].val=val,L[i].re=re;
	}
	int ST;scanf("%d",&ST);
	for(int i=1;i<=n;i++) if(!dfsx[i]) SH(i);
	remake();dfs(id[ST]);printf("%d",f[id[ST]]);
	return 0;
}

P2619 [国家集训队]Tree I，奇怪的二分，但是看得出来在限定范围内求最小，那么考虑从选择的边的边权入手，考虑贪心的选择但是这样是错误的，具体的可以自己举一个反例。如果，在当前情况下，如若白点的边数不够的话，说明它的白的整体边权过大了。那么我们让所有的白边减去一个(x)， 就会导致，顺序变换，那么就会改变选择的边。刚刚在想，要是选择的白边多了怎么办，完全没问题，因为可以继续减。
在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
int n,m,need,fa[100001];
struct pp
{
	int x,y,c,color;
};pp p[1000001];
int findfa(int x)
{
	if(fa[x]==x) return x;
	return fa[x]=findfa(fa[x]);
}
int check()
{
	int tot=0,num=0,rt=0;
	for(int i=1;i<=m;i++)
	{
		int x=p[i].x,y=p[i].y,fx=findfa(x),fy=findfa(y);
		if(fx!=fy) rt+=p[i].c,tot+=(p[i].color^1),fa[fx]=fy,num++;
		if(num==n-1)break;
	}
	if(tot>=need) return rt;
	return 0;
}
bool cmp(const pp &x,const pp &y)
{
	if(x.c==y.c) return x.color<y.color;
	return x.c<y.c;	
}
void remake(int val)
{
	for(int i=0;i<=n;i++) fa[i]=i;
	for(int i=1;i<=m;i++) if(!p[i].color) p[i].c+=val;
	sort(p+1,p+m+1,cmp);
	return ;
}
int main()
{
	scanf("%d%d%d",&n,&m,&need);
	int l=-111,r=111,ans;
	for(int i=1;i<=m;i++) scanf("%d%d%d%d",&p[i].x,&p[i].y,&p[i].c,&p[i].color);//l-=min(p[i].c,0),r+=max(0,p[i].c);
	while(l<=r)
	{
		int mid=(l+r)/2;
		remake(mid);
		if(check()) ans=mid,l=mid+1;
		else r=mid-1;
		remake(-mid);
	}
	remake(ans);
	printf("%d",check()-ans*need);
	return 0;
}

要不我们去做国集的题目吧虽然看起来很难：P3918 [国家集训队]特技飞行。这个比较简单不难发现无论怎么摆放动作，一个动作的贡献都是c*abs（第一次做-最后一次做），那么我们直接排列就行。

#include<bits/stdc++.h>
using namespace std;
int n,m,a[100001],ans=0,tot=0;
bool cmp(const int &x,const int &y)
{
	return x>y;
}
int main()
{
	scanf("%d%d",&m,&n);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	sort(a+1,a+n+1,cmp);
	for(int i=1;i<=min(m/2,n);i++) tot++,ans+=(a[i]*(m-tot*2+1));
	printf("%d",ans);
	return 0;
}

P1499 [CTSC2000]公路巡逻呃这个算了。
P1792 [国家集训队]种树一眼dp发现会爆炸，那么直接看题解，大佬说：可反悔贪心！我哈哈大笑，根本不会。问题不大，不妨维护一个大根堆，对于每一个选取的节点，将其的左右两个节点的val-它的val的和插入进去，那么就可以做到反悔了。

#include<bits/stdc++.h> 
using namespace std;
int n,m,a[220000],pre[220000],net[220000],ans=0;bool v[220000];
struct node
{
	int id,val;
	friend bool operator <(const node &x,const node &y)
	{
		return x.val < y.val;	
	};
};priority_queue<node > q;
void dl(int now)
{
	pre[now]=pre[pre[now]];net[now]=net[net[now]];
	net[pre[now]]=now;pre[net[now]]=now;
	return ;
}
int main()
{
	memset(v,false,sizeof(v));
	scanf("%d%d",&n,&m);
	if(n/2<m) 
	{
		printf("Error!");return 0;
	}
	for(int i=1;i<=n;i++) 
	{
		scanf("%d",&a[i]),pre[i]=i-1,net[i]=i+1;
		node e;e.id=i,e.val=a[i],q.push(e);
	}
	pre[1]=n;net[n]=1;
	for(int i=1;i<=m;i++)
	{
		while(v[q.top().id]) q.pop();
		node now=q.top();q.pop();
		a[now.id]=a[pre[now.id]]+a[net[now.id]]-a[now.id];v[pre[now.id]]=v[net[now.id]]=true;
		node e;e.val=a[now.id];e.id=now.id;q.push(e);
		ans+=now.val;dl(now.id);
	}
	printf("%d",ans);
	return 0;
}

明天需要做点：dp+数据结构+字符串。

P2634 [国家集训队]聪聪可可,树形dp，明显的性质，一个合法情况中肯定可以由两个情况组成，比如说3%3=(1+2)%3，那么直接转移上去%3意义下权值的就行了。注意了，要计算上自己与子树中匹配的点的次数，还有！因为点对有序，所以要*2。

#include<bits/stdc++.h>
using namespace std;
int n,m,len=0,last[1000001],f[100001][4],ans=-0;
struct pp
{
	int x,y,c,next;
};pp p[1000001];
void ins(int x,int y,int c)
{
	int now=++len;
	p[now]={x,y,c,last[x]};last[x]=now;
	return ;
}
void dp(int x,int fa)
{
	f[x][0]=1;//printf("*");
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;if(y==fa) continue ;
		dp(y,x);
		for(int j=0;j<=2;j++) ans+=f[y][j]*f[x][(3-((j+p[i].c)%3+3)%3)%3]*2;
		for(int j=0;j<=2;j++) f[x][(p[i].c+j+3)%3]+=f[y][j];
	}
	return ;
}

int main()
{
	memset(last,-1,sizeof(last));
	scanf("%d",&n);
	for(int i=1;i<=n-1;i++)
	{
		int x,y,c;scanf("%d%d%d",&x,&y,&c);
		ins(x,y,c);ins(y,x,c);
	}
	dp(1,1);ans+=n; 
	int k=__gcd(ans,n*n);
	printf("%d/%d",ans/k,n*n/k);
	return 0;
}

P1412 经营与开发这种dp有后效性，那么不妨考虑倒着做，就是从后往前做。遇到有后效性的dp多考虑考虑正难则反，那么反着做就很简单了就是简单的从后往前，如果会取一个点，那么就会对后面造成影响，那么f[i+1]*(…)如果不，那么就直接继承即可。
这个思路想想就懂，但不懂。

#include<bits/stdc++.h>
using namespace std;
double n,m,f[100001],a[100001],k,c,w,p[100001];
int main()
{
	scanf("%lf%lf%lf%lf",&n,&k,&c,&w);
	for(int i=1;i<=n;i++) scanf("%lf%lf",&p[i],&a[i]);
	for(int i=n;i>=1;i--)
	{
		if(p[i]==1) f[i]=max(f[i+1],f[i+1]*(1-0.01*k)+a[i]);
		else f[i]=max(f[i+1],f[i+1]*(1+0.01*c)-a[i]);
	}
	printf("%.2lf",f[1]*w);
	return 0;
}
cn_tigerhan
关注
分布式期末复习题
ThunderF的博客
09-16 1万+
概述题 1.分布式系统的定义？如何从硬件和软件的角度理解分布式系统的内容？   答：分布式系统是若干独立计算机的集合，但对用户来说是一个统一的系统。 2.分布式系统的设计的四个关键目标？   答：资源可用性、分布式透明性、开放性、可伸缩性 3.事务处理具有的四个特性？   答：1.原子性：事务在逻辑上是不可分割的操作单元；2.一致性：事务处理不会违反系统的不变性；3.隔离性：事务的执行不受其他事务的干扰，事务执行的中间结果对其他事务必须是透明的；4.持久性：对于任意已提交的事务，必须保证该事务对系统的改变不
计算机网络技术期末复习题,计算机网络期末复习题.doc
weixin_36162883的博客
07-31 3224
计算机网络期末复习题2-5运行在一台主机上的一个进程使用什么信息来标示运行在另一台主机上的进程。2-6假定你想尽快地处理从远程客户机到服务器的事务，应使用UDP还是TCP，为什么？2-10握手协议的作用是什么？2-11为什么HTTP、FTP、SMTP、POP3都运行在TCP而不是UDP之上？3-6当应用程序运行在UDP上时，该应用程序是否能够得到可靠数据传输？如果能，如何实现？3-9在rdt协议中...
JavaWeb期末复习题
qq_44231797的博客
12-16 7568
JavaWeb期末复习题
python期末复习题解析
热门推荐
unseven的博客
06-18 4万+
目录一、填空题 一、填空题 1.Python标准库math中用来计算平方根的函数是__________。 sqrt 计算平方根可以用pow(x,0.5)或者x**0.5，但这里问的是那个函数专门用来求平方根
网络互联期末作业复习题
m0_46625346的博客
06-10 6940
网络互联期末作业复习题 我是罡罡同学，一位初入网安的小白。☜(ˆ▽ˆ) （疯狂暗示 点赞 ！关注！转发 ！！！ 点赞 ！关注！转发 ！！！） 1 在计算机网络的规划与构建过程中，首先应该建立一个（）的概念 • A、系统 • B、完整 • C、分层 • D、宏观 2 127.0.0.1是一个（）地址。 • A、广播地址 • B、环回测试地址 • C、网络地址 • D、主机地址 3 动态分配IP地址采用的协议是（） • A、IP协议 • B、DHCP协议 • C、ARP协议 • D、TCP协议 1
【脑与认知科学期末复习题】
unseven的博客
12-11 7949
复习题复习题一一、 单选题二、填空题 复习题一 一、 单选题 爬行动物和哺乳动物的差异是（B） A. 爬行动物没有嗅觉 B. 爬行动物缺少哺乳动物的新皮层 C. 爬行动物几乎没有记忆能力 D. 爬行动物有Papez回路，这在哺乳动物中消失了 最早的皮质是嗅觉性的，在鱼类就已经出现，叫做古皮质。 爬行动物就已经具备爬行脑这种结构。爬行脑主要部分是脑干，主要负责人类的非随意性行为，即那些不受思想约束的无意识的生理活动，如调节心跳和呼吸等维持生命的基本功能。爬行脑在人类本能的身体反应中也起着重要作用。 pa
UML选择题复习题库
kfdbes
12-02 9861
UML选择题题库
计算机网络复习题
qq_71879739的博客
12-10 4334
一. 单选题（共90题，45分） 1.（单选题)计算机在局域网络上的硬件地址也可以称为MAC地址，这是因为 () A. 它是物理地址，MAC是物理地址的简称 B. 硬件地址是传输数据时，在传输媒介访问控制层用到的地址 C. 它是链路层地址，MAC是链路层的简称 D. 它是物理层地址，MAC是物理层的简称 正确答案：B：硬件地址是传输数据时，在传输媒介访问控制层用到的地址； 2.（单选题)下列有关曼彻斯特编码的叙述，正确的是（) A. 每个信号起始边界作为时钟信号有利于同步 B. 将时钟
计算机网络期末复习题
日拱一卒,功不唐捐
12-31 4万+
计算机网络复习题一 一、选择题 1、计算机网络可以被理解为（） A 、执行计算机数据处理的软件模块 B 、由自主计算机互联起来的集合体 C 、多个处理器通过共享内存实现的紧耦合系统 D 、用于共同完成一项任务的分布式系统 2、下列传输介质中，哪种传输介质的抗干扰性最好？ A、双绞线 B、光缆 C、同轴电缆 D、无线介质 3、采用全双工通信方式，数据传输的方向性结构为______。 A、可以在两个方向上同时传输 B、只能在一个方向上传...
Java期末复习题
唐昊
12-29 2万+
第1章Java开发入门 一、填空题 1.将.java源文件编译为.class文件的是【 】命令。 2.在Eclipse窗口中选择菜单【 】→New→Java Project创建Java项目。 3.在安装JDK的过程中，有三个功能模块可供选择，它们分别是【 】，【 】和【 】。 4.将Hello.java文件编译为class文件，需要键入【 ...
商务智能复习题
07-02
商务智能复习题 本资源摘要信息涵盖了商务智能领域的多个方面，包括数据仓库、OLAP、OLTP、数据挖掘、 CRM、KDD 等。下面是对每个问题的详细解释： 1. 数据仓库是随着时间变化的，下面的描述不正确的是（C）。数据...
Linux期末复习题.docx
06-09
在服务器服务方面，Linux可以提供Web、SFTP和SSH服务，但不包括XShell。 VMware是一款虚拟化软件，提供了桥接、仅主机和NAT三种网络模式，对应的网络设备分别是VMnet0、VMnet8和VMnet1，VMnet9不属于这些模式。...
译林版六年级英语上册期末复习题.pdf
11-02
这篇文件名为“译林版六年级英语上册期末复习题.pdf”，是一份针对六年级学生英语科目的复习资料，其中包含了多个练习题和知识点。从内容上来看，这份资料涵盖了一定的语法知识点、词汇应用以及阅读理解能力的检验。...
软件设计模式复习题.docx
10-14
软件设计模式复习题 软件设计模式是一种创建可维护、可扩展、灵活的软件系统的方法论。软件设计模式的基本思想是：软件实体应当对扩展开放，而对修改关闭，抽象不应该依赖于细节，细节应该依赖于抽象，一个类或模块...
计算机系统基础复习题（1至4章）.pdf
05-23
计算机系统基础复习题的知识点非常丰富，涵盖了计算机硬件组成、指令执行流程、计算机系统层次结构、性能指标、二进制、十六进制和八进制表示、定点数编码、浮点数表示范围与精度、规格化、计算机编码等多个方面。...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5154
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
二叉树最小深度
2301_80161204的博客
09-27 472
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1284
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
最新发布
m0_57859086的博客
10-01 1014
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
农机化电工技术期末复习题与解答回顾
《电工学》期末复习题及答案包含了农机化、机制电工技术课程的相关知识点，旨在帮助学生准备期末考试。以下是部分题目及其解析： 1. 选择题 - 第一题考察电路中功率的方向，当元件吸收功率且电流i为正时，电压u的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值