CF #673 div2 赛后总结

最新推荐文章于 2020-11-02 17:02:12 发布
最新推荐文章于 2020-11-02 17:02:12 发布
阅读量326 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangjianjunab/article/details/108848036
版权

文章目录

前言

完成成就：在学校熬夜熬到1点

第一次CF打比赛就炸成这个样子

A

题目翻译：

一个长度为 n n n的数组，每次选择 i , j ( 1 ≤ i , j ≤ n , i ≠ j ) i,j(1≤i,j≤n,i≠j) i,j(1≤i,j≤n,i​=j)，然后执行执行一个操作： a [ j ] = a [ i ] + a [ j ] a[j]=a[i]+a[j] a[j]=a[i]+a[j]，并且要求操作完后 a [ j ] ≤ k a[j]≤k a[j]≤k，问最多进行多少次操作。

这不直接贪心搞？

很明显每次拿每一个去跟最小的数字copy一下即可，因为用最小的数字增长的最慢啊。

时间复杂度： O ( n ) O(n) O(n)

#include<cstdio>
#include<cstring>
#include<algorithm>
#define  N  1100
using  namespace  std;
int  a[N];
int  n,K;
int  main()
{
	int  T;scanf("%d",&T);
	while(T--)
	{
		scanf("%d%d",&n,&K);
		for(int  i=1;i<=n;i++)scanf("%d",&a[i]);
		sort(a+1,a+n+1);
		int  ans=0;
		for(int  i=2;i<=n;i++)ans+=(K-a[i])/a[1];
		printf("%d\n",ans);
	}
	return  0;
}

因为懒得打找最小直接排序了

B

题目翻译：

有一个对于数组的估值函数 f f f， f ( a ) f(a) f(a)是满足 i ≠ j , a [ i ] + a [ j ] = T i≠j,a[i]+a[j]=T i​=j,a[i]+a[j]=T的二元组 ( i , j ) (i,j) (i,j)的数量，然后让你把 a a a数组分成 b , c b,c b,c两个数组，同时要求 f ( b ) + f ( c ) f(b)+f(c) f(b)+f(c)最小。

不难发现，对于一个数字 x x x， T − x T-x T−x是固定的，且对于 T − x T-x T−x而言， x x x也是固定的，所以只需要把 x x x和 T − x T-x T−x分到两个不同的数组即可。

但是需要注意的是： x = T − x x=T-x x=T−x的情况时，需要均匀的分配。

时间复杂度： O ( n l o g n ) O(nlogn) O(nlogn)

#include<cstdio>
#include<cstring>
#include<map>
#define  N  110000
using  namespace  std;
map<int,int> fuck;//直接用map算了
int  a[N],n,m,ans[N];
int  main()
{
	int  T;scanf("%d",&T);
	while(T--)
	{
		fuck.clear();
		scanf("%d%d",&n,&m);
		for(int  i=1;i<=n;i++)scanf("%d",&a[i]);
		for(int  i=1;i<=n;i++)
		{
			int  x=a[i];
			if(fuck.count(m-x)==1)ans[i]=fuck[m-x]^1;
			else  ans[i]=0;
			fuck[x]=ans[i];
		}
		for(int  i=1;i<=n;i++)printf("%d ",ans[i]);
		printf("\n");
	}
	return  0;
}

C

题目翻译：

对于一个长度为 n n n的数组，你需要对于 [ 1 , n ] [1,n] [1,n]中每个数字都找到其对应的神奇数：
（我们设现在正在进行寻找的数字是 k k k）对于每一段长度为 k k k的连续子段，如果这些子段中的最小值都是同一个数字，那么这个数字就是数字 k k k的神奇数，简称 k − k- k−神奇数。

不难发现， k k k越大，答案只会越小，满足单调性，又发现 a a a数组的数字都在 [ 1 , n ] [1,n] [1,n]范围内，所以我们针对每一个数字，算出当子段长度大到什么数字时，答案小于等于这个数字，然后用个单调栈维护即可。

时间复杂度： O ( n ) O(n) O(n)

#include<cstdio>
#include<cstring>
#define  N  310000
using  namespace  std;
int  a[N],n;
int  last[N],minn[N];
int  sta[N],top;
inline  int  mymax(int  x,int  y){return  x>y?x:y;}
int  main()
{
	int  T;scanf("%d",&T);
	while(T--)
	{
		scanf("%d",&n);
		for(int  i=1;i<=n;i++)minn[i]=-1,last[i]=0;
		for(int  i=1;i<=n;i++)
		{
			int  x;scanf("%d",&x);
			int  val=i-last[x];
			minn[x]=mymax(minn[x],val);
			last[x]=i;
		}
		for(int  i=1;i<=n;i++)
		{
			if(last[i])minn[i]=mymax(n-last[i]+1,minn[i]);
		}
		top=0;
		for(int  i=n;i>=1;i--)
		{
			if(minn[i]==-1)continue;
			int  val=minn[i];
			while(top  &&  minn[sta[top]]>=val)top--;
			sta[++top]=i;
		}
		int  ll=0;
		for(int  i=1;i<=n;i++)
		{
			while(ll<top  &&  minn[sta[ll+1]]<=i)ll++;
			if(!ll)printf("-1 ");
			else  printf("%d ",sta[ll]);
		}
		printf("\n");
	}
	return  0;
}

D

题目翻译：

对于一个数组 a a a（里面的数字都是正数）。

你可以选择 i , j , x ( 1 ≤ i , j ≤ n , 0 ≤ x ≤ 1 0 9 ) i,j,x(1≤i,j≤n,0≤x≤10^9) i,j,x(1≤i,j≤n,0≤x≤109)并进行一次操作（其实 x x x小于等于 1 0 9 10^9 109没用的，反正数组总和也才这么大）：
a i − = i ∗ x , a j + = i ∗ x a_i-=i*x,a_j+=i*x ai​−=i∗x,aj​+=i∗x
并且要求每次操作完后的数组中的数字都是非负的，问要多少步才能让所有数字相同，并输出操作次数和操作序列，请注意，操作次数只要在 [ 0 , 3 n ] [0,3n] [0,3n]之间即可。

不难发现， 1 1 1号节点可以自由的让别人加数字，所以我们不妨考虑把其他的点多余平均数的部分汇聚到 1 1 1点。然后我WA了。

但是赛后我通过膜拜奆佬，发现了真正的做法：
也是汇聚到 1 1 1点，设平均数为 o v a ova ova，如果 o v a < a [ i ] < i ova<a[i]<i ova<a[i]<i，上述做法就会出问题，但是如果我们如果强行凑到 i i i，有可能会面临 1 1 1号节点的数字不够的问题。

因此我们需要把所有的数字汇聚到 1 1 1点，对于第 i i i号节点 ( i ≥ 2 ) (i≥2) (i≥2)，如果 a [ i ] m o d    i ≠ 0 a[i]\mod i≠0 a[i]modi​=0，那么我们只需要直接把缺的部分补满然后全部扔到 1 1 1i即可，因为缺的数字最多是 i − 1 i-1 i−1个，同时因为原始数字的数字都是正数，所以 1 1 1在拿走了 [ 1 , i − 1 ] [1,i-1] [1,i−1]中所有数字之后，肯定是大于等于 i − 1 i-1 i−1个数字的，所以肯定可以拿走 i i i的所有数字。

我们发现，上述的操作方案最多会有 3 ( n − 1 ) 3(n-1) 3(n−1)个操作。

#include<cstdio>
#include<cstring>
#define  N  15000
#define  NN  500005
using  namespace  std;
int  a[N],n,T;
struct  ANSWER
{
	int  i,j,t;
}ans[NN];int  top;
int  main()
{
	scanf("%d",&T);
	while(T--)
	{
		top=0;memset(ans,0,sizeof(ans));
		scanf("%d",&n);
		int  sum=0;
		for(int  i=1;i<=n;i++){scanf("%d",&a[i]);sum+=a[i];}
		if(sum%n!=0)
		{
			printf("-1\n");
			continue;
		}
		sum/=n;
		for(int  i=2;i<=n;i++)
		{
			int  val=i-a[i]%i;
			if(val!=i)
			{
				++top;
				ans[top].i=1;ans[top].j=i;ans[top].t=val;
				a[i]+=val;
			}
			++top;
			ans[top].i=i;ans[top].j=1;ans[top].t=a[i]/i;
		}
		for(int  i=2;i<=n;i++)
		{
			top++;
			ans[top].i=1;ans[top].j=i;ans[top].t=sum;
		printf("%d\n",top);
		for(int  i=1;i<=top;i++)printf("%d %d %d\n",ans[i].i,ans[i].j,ans[i].t);
	}
	return  0;
}

E

题目翻译：
给你个数组 a a a，要求你找到一个 x x x，使得操作后得到的数组 b b b的逆序对数最少。

操作法则为对于 a a a中每个数字与 x x x异或，得到 b b b。

思路：
我们针对最高位先进行分类讨论。

如果都是 0 0 0的话，那么我们不难发现这些要判断逆序对数只能靠下一位，不管他。

1 1 1也是。

但是 0 , 1 0,1 0,1交替呢？我们先讨论这一位，我们统计一下这一位是 0 0 0时或者是 1 1 1时可以贡献的逆序对数。

然后讨论这一位是 0 / 1 0/1 0/1是对于下一位的影响，我们设现在的数组是 a a a，最高位是 1 1 1的数字的数组是 a 1 a1 a1，是 0 0 0的数组是 a 0 a0 a0，我们发现，不管这一位是 0 0 0还是 1 1 1，在下一位中 a 0 , a 1 a0,a1 a0,a1都是独立的产生贡献的（因为交叉产生贡献在这一位就处理了），所以我们只要在一位一位处理并不断分裂即可。

至于例子，拿样例手操一下就知道了。

考试我没有开long long！！！

#include<cstdio>
#include<cstring>
#define  N  610000
using  namespace  std;
typedef  long  long  LL;
int  aa[2][N],n,shit,mid;
LL  to1,to2;
inline  void  chuli(int  *a,int  top,int  *b)
{
	int  zt=0,ot=0;
	for(int  i=top;i>=1;i--)
	{
		if(a[i]&shit)ot++;
		else  zt++;
	}
	int  zc=0,oc=0;
	for(int  i=top;i>=1;i--)
	{
		if(a[i]&shit)
		{
			oc++;b[top-oc+1]=a[i];
			to2+=zc;
		}
		else
		{
			zc++;b[zt-zc+1]=a[i];
			to1+=oc;
		}
	}
	mid=zt;
}
int  ll[2][N],rr[2][N],top[2];
int  main()
{
	long  long  ans2=0,ans1=0;
	scanf("%d",&n);
	for(int  i=1;i<=n;i++)scanf("%d",&aa[0][i]);
	top[0]=1;ll[0][1]=1;rr[0][1]=n;
	int  pre=1,now=0;
	for(int  i=30;i>=1;i--)
	{
		now^=1;pre^=1;
		shit=(1<<(i-1));
		
		top[now]=0;
		to1=to2=0;
		for(int  i=1;i<=top[pre];i++)
		{
			chuli(aa[pre]+ll[pre][i]-1,rr[pre][i]-ll[pre][i]+1,aa[now]+ll[pre][i]-1);
			if(mid>0)
			{
				int  x=++top[now];
				ll[now][x]=ll[pre][i];
				rr[now][x]=ll[pre][i]+mid-1;
			}
			if(mid!=rr[pre][i]-ll[pre][i]+1)
			{
				int  x=++top[now];
				ll[now][x]=ll[pre][i]+mid;
				rr[now][x]=rr[pre][i];
			}
		}
		if(to1>=to2)ans2+=to2;
		else  ans2+=to1,ans1^=shit;
	}
	printf("%lld %lld\n",ans2,ans1);
	return  0;
}

F

题目翻译：

一开始有 n n n个点， m m m条边， q q q个询问，然后接下来有 q q q个询问（有两种）：

  1. 对于 1 1 1号询问，是询问 x x x所能到达的点（包括自己）的 p p p的最大值，然后输出，并且把 p m a x p_{max} pmax​所在的点的 p p p改为 0 0 0。（注意，初始的每个点的 p p p并不一样）。
  2. 删除一条边。

思路：
需要注意的是，基本上很多图上删边的题目都是离线倒着处理，但是这道题目特别狗蛋的是前面的询问对后面有后效性。

我们从后往前扫每个删边操作，然后得到每一次删边之前的联通信息，但是如何维护就成了重中之重，同时还要支持查询和修改。

由于每次最多合并两个联通块，所以我们可以开个新点连接这两个联通块，且以后的管理节点在连接这个新的联通块时也是连接在这个点上，这样不难发现这是一个树的结构，而且还是一个二叉树。

在这里插入图片描述
至于快速找到一个点的最高层的管理节点，并查集！！！

而且这个树还有一个很优秀的性质：一个管理节点的子树就是其在分裂前的联通块。

当然，这个树还有许多很好的性质，但是此题没用。

看到第二点，我们很容易想到用 d f s dfs dfs序搞，线段树维护，然后对于每个询问只要在从后往前搞的时候顺便记录一下这个点联通块的最高层管理节点是哪个即可。

#include<cstdio>
#include<cstring>
#define  N  210000
#define  NN  410000
#define  M  310000
using  namespace  std;
inline  int  mymax(int  x,int  y){return  x>y?x:y;}
int  n,m,q;
struct  TREE
{
	int  l,r,c;
}tr[NN];int  len,last[N],p[N],be[N],id[N],valbe[N];
void  bt(int  l,int  r)
{
	int  now=++len;
	if(l==r)tr[now].c=p[be[l]];
	else
	{
		int  mid=(l+r)>>1;
		tr[now].l=len+1;bt(l,mid);
		tr[now].r=len+1;bt(mid+1,r);
		tr[now].c=mymax(tr[tr[now].l].c,tr[tr[now].r].c);
	}
}
void  change(int  now,int  l,int  r,int  id)
{
	if(l==r){tr[now].c=0;return  ;}
	int  mid=(l+r)>>1;
	if(id<=mid)change(tr[now].l,l,mid,id);
	else  change(tr[now].r,mid+1,r,id);
	tr[now].c=mymax(tr[tr[now].l].c,tr[tr[now].r].c);
}
int  findans(int  now,int  l,int  r,int  ll,int  rr)
{
	if(l==ll  &&  r==rr)return  tr[now].c;
	int  mid=(l+r)>>1,lc=tr[now].l,rc=tr[now].r;
	if(rr<=mid)return  findans(lc,l,mid,ll,rr);
	else  if(mid<ll)return  findans(rc,mid+1,r,ll,rr);
	else  return  mymax(findans(lc,l,mid,ll,mid),findans(rc,mid+1,r,mid+1,rr));
}
 
int  fa[NN];
int  findfa(int  x)
{
	if(fa[x]!=x)fa[x]=findfa(fa[x]);
	return  fa[x];
}
 
struct  edge
{
	int  x,y;bool  c;
}a[M];
 
int  son[NN][2],cnt;
inline  int  mer(int  x,int  y)
{
	int  tx=findfa(x),ty=findfa(y);
	if(tx!=ty)
	{
		cnt++;fa[tx]=fa[ty]=fa[n+cnt]=n+cnt;
		son[n+cnt][0]=tx;son[n+cnt][1]=ty;
	}
}
int  ll[NN],rr[NN],top;
inline  void  dfs(int  x)
{
	ll[x]=top+1;
	if(x<=n)id[x]=++top,be[top]=x;
	else
	{
		dfs(son[x][0]);
		dfs(son[x][1]);
	}
	rr[x]=top;
}
 
struct  Query
{
	int  type,x;
}qu[510000];
 
int  main()
{
	scanf("%d%d%d",&n,&m,&q);
	for(int  i=1;i<=n;i++){scanf("%d",&p[i]);fa[i]=i;valbe[p[i]]=i;}
	for(int  i=1;i<=m;i++)scanf("%d%d",&a[i].x,&a[i].y);
	for(int  i=1;i<=q;i++)
	{
		scanf("%d%d",&qu[i].type,&qu[i].x);
		if(qu[i].type==2)a[qu[i].x].c=1;
	}
	for(int  i=1;i<=m;i++)
	{
		if(!a[i].c)mer(a[i].x,a[i].y);
	}
	for(int  i=q;i>=1;i--)
	{
		if(qu[i].type==2)mer(a[qu[i].x].x,a[qu[i].x].y),qu[i].type=-1;
		else  qu[i].type=findfa(qu[i].x);
	}
	for(int  i=n+cnt;i>=1;i--)
	{
		if(findfa(i)==i)dfs(i);
	}
	bt(1,n);
	for(int  i=1;i<=q;i++)
	{
		if(qu[i].type!=-1)
		{
			int  x=qu[i].type;
			int  y=findans(1,1,n,ll[x],rr[x]);
			if(y)change(1,1,n,id[valbe[y]]);
			printf("%d\n",y);
		}
	}
	return  0;
}
zhangjianjunab
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2020排位赛Ⅲ（div2）D
weixin_45794203的博客
03-09 163
D. Race 题目链接 题目大意：母牛贝西在比赛跑步，跑道长为N，贝西可以以1m/s的加速度改变自己的速度，但贝西到达终点后速度不能超过x m/s，问贝西到达终点所花最少的时间是多少。 思路：采用二分法来计算母牛贝西在跑步期间最高的速度v，然后再计算这个速度是否满足，若满足，就更新结果。 代码： #include <cstdio> #include <cmath> #in...
CF Round #677 div3 赛后总结
蒟蒻QMQ
10-21 223
前言 运气真好AK了(╯‵□′)╯︵┻━┻ 庆祝EEE题没看懂题找规律过了(╯‵□′)╯︵┻━┻ A 题意： 差不多就是说，在1−100001-100001−10000范围内，如果一个数字的每一位都是同一个数字，就叫无聊数字，然后会以1,11,111,1111,2,22...1,11,111,1111,2,22...1,11,111,1111,2,22...这样的顺序排列，然后问无聊数字xxx，以及其的排列前面的数字的位数之和是多少，例如：111111，前面有111，然后位数之和为2+1=32+1=32+1
Codeforces Round #673 (Div. 2) B
he_jifei的博客
09-28 297
Codeforces Round #673 (Div. 2) - B 我作为一个菜鸡，昨天居然把B题给做了出来，泪目QAQ. 于是就写个博客纪念一下。 题目链接：https://codeforces.ml/contest/1417/problem/B 题意： 首先定义：f(x)是在数组x取两个数组成数对(x[i], x[j]) 的个数，数对因满足 i ≠ j 且 x[i] + x[j] = T 题目要求：将一个数组分成a, b两部分，使得f(a) + f(b) 最小。 我的思路： 为了方便表述，假设0， 1
2018.7.4——codeforces #470 div2 比赛小结
weixin_30411997的博客
07-04 100
第一次做这种神奇的比赛，好激动，也有点不适应，然后就GG了。 英文比赛，读题稍稍困难。我太菜了。 先放成绩： 死得灿烂。 然后呢，...
CF 673 div2 E
xkayla
09-29 168
E. XOR Inverse 题意：给n个数字，每个数字^x，使逆序数对最少，求最小的逆序数对和x 逆序：某个位置：左子树 > 右子树 把所有位置情况找出来，然后合计 #include <bits/stdc++.h> using namespace std; const int maxn = 3e5 + 10; int n,a[maxn]; long long trie[maxn * 30][3]; int tot; vector<int> ve[maxn * 30]; lon
Codeforces Round #673 (Div. 2) B. Two Arrays
ACkingdom的博客
09-28 185
题目链接 题意： 给你n个数，你可以将他们分到任意的两个数组中，求怎样可以使得分别两个数组中的两两和为T的对数的数量最小。 思路： 遍历数组，如果该数没有被标记，那么标记该数并标记T-该数，flag数组中标记的数不同，表示这两个数不在同一个数组中，最后直接输出所有数的标记即可。 代码： #include<bits/stdc++.h> #define int long long #define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(
CF#680 Div.2赛后总结
蒟蒻QMQ
11-02 259
文章目录前言ABCDE 前言 哭了啊，又被同机房那几个奆佬摁在地上摩擦，平均比每人少做一道题目。 比赛链接：https://codeforc.es/contest/1445 A 题意：给你两个数组a,ba,ba,b，让你判断能不能通过对bbb重新的排序，让其满足：ai+bi≤k(1≤i≤n)a_{i}+b_{i}≤k(1≤i≤n)ai​+bi​≤k(1≤i≤n)，其中kkk是给定的常数。 做法：不难发现，aaa升序，bbb降序，然后暴力做即可。 时间复杂度：O(nlogn)O(nlogn)O(nlogn)
CF题解DIV2
07-09
Oops! Google Chrome could not connect to codeforces.com Try reloading: codeforces.­com Additional suggestions: Access a cached copy of codeforces.­com Search on Google:
VxWorks操作系统下CF卡驱动程序的开发总结-教程与笔记习题
05-19
VxWorks操作系统下CF卡驱动程序的开发总结
购物车.zip_jsp_warn2cf_购物车
07-14
一个比较简单的web页面的购物车参考程序
NETCFSetupv2.rar_NETCFSetup_NETCFSetupv2_vs2005 CF2.0SP2
09-20
标题中的“NETCFSetupv2.rar_NETCFSetup_NETCFSetupv2_vs2005 CF2.0SP2”表明这是一款针对.NET Compact Framework 2.0 Service Pack 2的安装包，用于Visual Studio 2005的环境。此压缩包可能包含了.NET Compact ...
I1CF-M1202N-C3U2台信透明标签传感器说明书.docx
08-23
5. **感应距离**：I1CF-M1202N-C3U2的感应距离设定为2mm，适合检测薄且透明的物体，确保精确检测。 6. **电压降**：在正常工作状态下，传感器的电压降不超过1.5V，表明其能量转换效率较高。 7. **漏电流**：漏电流...
CF 673 div2 BCD
xkayla
09-29 999
B. Two Arrays 题意：给n个数，把他分成0，1两组， f(x) = 每组内任意两个数字和=T的对数 使f(0) + f(1) 最小 #include <bits/stdc++.h> using namespace std; const int maxn = 1e5 + 10; int t,n,T; int x,ans[maxn]; map<int,int> mp; int main(){ ios::sync_with_stdio(0); cin >> t;
Codeforces Round #673 (Div. 2) ABC 题解
待到山花烂漫时
09-28 307
博客园传送门 A. Copy-paste 题意：问在保持每个数都小于等于k的情况下，最多能执行多少步a[j] += a[i] ，其中（i，j）为任意不同下标。 思路：水题，排个序，用a[1]去加到别的值上，看每个数能加多少个a[1]，累加贡献即可。 view code #include<iostream> #include<string> #include<algorithm> #include<cstdio> #include<cstring>
Codeforces Round #673 (Div. 2) Problem A
cggwz的信息飞船
09-27 285
今天的题。 本来打算把比赛坚持打完的，但是因为生病了，还是早点睡吧，把第一题摸了。 题面如下： BThero is a powerful magician. He has got n piles of candies, the i-th pile initially contains ai candies. BThero can cast a copy-paste spell as follows: He chooses two piles (i,j) such that 1≤i,j≤n and i≠j
codforces (round536)div2比赛总结
qq_40549106的博客
02-02 356
TA Lunar New Year and Cross Counting 对于签到题，这个就简单暴力一下，枚举所有x的中心，然后符合要求就ans++就ok了 代码： #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cstdlib&gt; #include&lt;algorithm&gt; #define MAXN 30001...
[2018-5-11]BNUZ套题比赛div2
星澈的博客
05-12 232
这次真的死脑筋了，明明可以特判却没有用，反而想着其他办法，出发点是好的，可惜想错了地方。。难受啊。 A. Supercentral Pointtime limit per test2 secondsmemory limit per test256 megabytesinputstandard inputoutputstandard outputOne day Vasya painte...
2020.11.1晚 CFdiv2比赛总结（真·CSP模拟）
wangyuda123456789的博客
11-01 513
今天的题才是真正的CSP模拟（滑稽） FK：我没AK，好菜啊（%%%） CottonT5被hack了，痛失AK（%%%） T1势必（S·B）排序 T2势必求max(a+b,c+d) T3需要思考，首先p%q!=0直接输出p。 对于p，q两个数，枚举质因数g，设p中有s个g，q中有t个g 对p/(g^(s-t+1)) 取max即可（保证不是q倍数） 因为q是1e9级别，枚举sqrt(1e9)级别即可，q中最多有一个大于sqrt(1e9)的质数，所以对于一次询问复杂度是sqrt(1e9)的，可以过 T4玄学格物
html css js网页设计
最新发布
07-12
HTML、CSS和JavaScript是构建网页和网站的基本技术，它们共同工作来创建和设计用户界面。下面是关于这三种技术的详细介绍： ### HTML (HyperText Markup Language) - **定义**：HTML是构建网页内容的标准标记语言。 - **作用**：用于创建网页的结构和内容，如段落、链接、图片、表格等。 - **语法**：使用标签（如 `<p>`, `<div>`, `<a>`, `<img>` 等）来定义网页元素。 ### CSS (Cascading Style Sheets) - **定义**：CSS是一种样式表语言，用于描述HTML文档的呈现方式。 - **作用**：用于设置网页的布局、颜色、字体和其他视觉元素。 - **语法**：通过选择器（如 `p`, `.myclass`, `#myid` 等）应用样式规则。 ### JavaScript - **定义**：JavaScript是一种脚本语言，通常用于网页上实现交互功能。 - **作用**：允许网页与用户进行交互，如响应用户操作、动态更新内容、动画效果等。 - **语法**：Java
cf的div1和div2
07-27
在CF比赛中，参赛选手根据他们的水平被分为不同的分级，其中包括Div1和Div2。 Div1（Division 1）是指最高级别的竞赛分级，主要面向那些具有较高编程水平和算法能力的选手。Div1比赛通常包含更加复杂和挑战性的问题...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值