NOIP2016总结

article/2025/9/27 19:26:47

Day1：

T1：模拟；

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cstdlib>
 4 #include<cstring>
 5 #include<string>
 6 #include<ctime>
 7 #include<cmath>
 8 #include<set>
 9 #include<map>
10 #include<queue>
11 #include<algorithm>
12 #include<iomanip>
13 using namespace std;
14 #define FILE "toy"
15 #define up(i,j,n) for(int i=(j);i<=(n);i++)
16 #define pii pair<int,int>
17 #define LL long long
18 namespace IO{
19     char buf[1<<15],*fs,*ft;
20     int gc(){return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?-1:*fs++;}
21     int read(){
22         int ch=gc(),f=0,x=0;
23         while(ch<'0'||ch>'9'){if(ch=='-')f=1;ch=gc();}
24         while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+ch-'0';ch=gc();}
25         return f?-x:x;
26     }
27 }using namespace IO;
28 const int maxn=101000;
29 int n,m;
30 int a[maxn];
31 char s[maxn][20];
32 int main(){
33     freopen(FILE".in","r",stdin);
34     freopen(FILE".out","w",stdout);
35     scanf("%d%d",&n,&m);
36     up(i,0,n-1)scanf("%d %s",&a[i],s[i]);
37     int x,y,now=0;
38     up(i,1,m){
39         scanf("%d%d",&x,&y);
40         if(x==a[now])now=(now-y+n)%n;
41         else now=(now+y)%n;
42     }
43     printf("%s",s[now]);
44     return 0;
45 }
46
View Code

T2:

这次noip2016最难的题？

考场上只急着打暴力了，没有好好思考；

实际上想了之后还是很简单的；

这题的关键是理清思路，题目上的特点是 若一条路径已走的时间若与当前节点的值相等，这一点的答案加1；

最暴力的思路当然是dfs Q遍，先判断这个点是否在这条路径上，然后判断已走的距离是不是等于当前点的权值，都符合的话ans++；

如何化简条件？

我们可以发现当若有一条从x->y的路径是一条链，且dep[x]<dep[y]，则若dep[i]-dep[x]=v[i]，则该点ans++；

这可以变形成dep[i]-v[i]=dep[x]，左边只与点i自身有关；

经过了这样的转化，我们发现可以这样做，将一个路径拆成从x->lca和lca->y两个链，然后可以仿照上面的方法，用dep与v[i]的关系做。

但做到了这一步仍然没什么卵用；

我们是否可以把目光转移，从看一条路径到看每个点？

对每个点而言，我们需要计算的是，它自身dep[i]±v[i]正好匹配经过它的路径所要求的的值的路径的数目；

这很绕，实际上对路径只有两个要求，第一个是经过它，第二个是路径与这个点可以匹配；

怎么维护？

第一个，维护只经过它的路径的值的集合；

第二个，在集合中快速找到符合要求的值的数目；

满足这两个要求，第一个可以用离线的方法维护，第二个可以在dfs的途中顺便维护一个桶，这个桶里存的就是经过它的路径的值的集合，然后可以O(1)查询；

这里面还有一个地方需要注意，每次桶从一颗子树出来的时候会带着这颗子树的信息，再进入另一个桶的时候会出现问题，解决方案是作差，先记录一下当前的ans值，待遍历完所有子树，再记录一下当前的ans，两个的差值即为所求；

在大佬眼里就是道水题...

 

  1 #include<iostream>
  2 #include<cstdio>
  3 #include<cstdlib>
  4 #include<cstring>
  5 #include<string>
  6 #include<ctime>
  7 #include<cmath>
  8 #include<set>
  9 #include<map>
 10 #include<queue>
 11 #include<algorithm>
 12 #include<iomanip>
 13 #include<queue>
 14 using namespace std;
 15 #define FILE "dealing"
 16 #define up(i,j,n) for(int i=(j);i<=(n);i++)
 17 #define pii pair<int,int>
 18 #define LL long long
 19 namespace IO{
 20     char buf[1<<15],*fs,*ft;
 21     int gc(){return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?-1:*fs++;}
 22     int read(){
 23         int ch=gc(),f=0,x=0;
 24         while(ch<'0'||ch>'9'){if(ch=='-')f=1;ch=gc();}
 25         while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+ch-'0';ch=gc();}
 26         return f?-x:x;
 27     }
 28 }using namespace IO;
 29 const int maxn=600010;
 30 int n,m;
 31 struct node{
 32     int y,next,v;
 33 }e[maxn],u[maxn],v[maxn],q[maxn];
 34 int headu[maxn],headv[maxn],headq[maxn],lenu,lenv,lenq;
 35 int linkk[maxn],len=0;
 36 int s[maxn],t[maxn],w[maxn];
 37 inline void insert(int x,int y,node* e,int* linkk,int& len,int v){e[++len].y=y;e[len].v=v;e[len].next=linkk[x];linkk[x]=len;}
 38 int top[maxn],siz[maxn],son[maxn],fa[maxn],dep[maxn],Lca[maxn],dfs_clock=0;
 39 int f[maxn],flag[maxn];
 40 int getf(int x){return x==f[x]?x:f[x]=getf(f[x]);}
 41 int pre[maxn],low[maxn],id[maxn];
 42 void tarjan(int x){
 43     siz[x]=1;
 44     pre[x]=++dfs_clock;
 45     id[dfs_clock]=x;
 46     flag[x]=1;
 47     for(int i=linkk[x];i;i=e[i].next){
 48         if(e[i].y==fa[x])continue;
 49         fa[e[i].y]=x;
 50         dep[e[i].y]=dep[x]+1;
 51         tarjan(e[i].y);
 52     }
 53     for(int i=headq[x];i;i=q[i].next){
 54         if(Lca[q[i].v])continue;
 55         if(flag[q[i].y]==1)Lca[q[i].v]=q[i].y;
 56         else if(flag[q[i].y]==2)Lca[q[i].v]=getf(q[i].y);
 57     }
 58     f[x]=fa[x];
 59     flag[x]=2;
 60     low[x]=++dfs_clock;
 61     id[dfs_clock]=x;
 62 }
 63 void init(){
 64     n=read(),m=read();
 65     int x,y;
 66     up(i,1,n-1){x=read(),y=read();insert(x,y,e,linkk,len,0);insert(y,x,e,linkk,len,0);}
 67     up(i,1,n)w[i]=read();
 68     up(i,1,m){
 69         s[i]=read(),t[i]=read();
 70         insert(s[i],t[i],q,headq,lenq,i);
 71         insert(t[i],s[i],q,headq,lenq,i);
 72     }
 73     up(i,1,n)f[i]=i;
 74     tarjan(1);
 75 }
 76 inline void make_tag(int s,int t,int st,bool flag){
 77     if(flag){
 78         insert(s,st,u,headu,lenu,1);
 79         insert(t,st,u,headu,lenu,-1);
 80     }
 81     else {
 82         insert(s,st,v,headv,lenv,1);
 83         insert(t,st,v,headv,lenv,-1);
 84     }
 85 }
 86 int ans[maxn];
 87 int cnt1[maxn<<3],cnt2[maxn<<3];
 88 int l[maxn];
 89 void slove(){
 90     up(i,1,m){
 91         if(Lca[i]==s[i])make_tag(fa[s[i]],t[i],dep[s[i]],0);
 92         else if(Lca[i]==t[i])make_tag(s[i],fa[t[i]],dep[s[i]],1);
 93         else {
 94             make_tag(s[i],fa[Lca[i]],dep[s[i]],1);
 95             make_tag(Lca[i],t[i],2*dep[Lca[i]]-dep[s[i]],0);
 96         }
 97     }
 98     memset(flag,0,sizeof(flag));
 99     int x;
100     for(int i=1;i<=dfs_clock;i++){
101         x=id[i];
102         if(flag[x]){
103             for(int i=headu[x];i;i=u[i].next){
104                 if(u[i].v==-1)cnt1[u[i].y+maxn]--;
105                 else cnt1[u[i].y+maxn]++;
106             }
107             for(int i=headv[x];i;i=v[i].next){
108                 if(v[i].v==1)cnt2[v[i].y+maxn]--;
109                 else cnt2[v[i].y+maxn]++;
110             }
111             ans[x]=cnt1[dep[x]+w[x]+maxn]+cnt2[dep[x]-w[x]+maxn]-l[x];
112         }
113         else {
114             l[x]=cnt1[dep[x]+w[x]+maxn]+cnt2[dep[x]-w[x]+maxn];
115             flag[x]=1;
116         }
117     }
118     up(i,1,n)printf("%d%c",ans[i],i==n?'\n':' ');
119 }
120 int main(){
121     freopen(FILE".in","r",stdin);
122     freopen(FILE".out","w",stdout);
123     init();
124     slove();
125     return 0;
126 }
View Code

 

顺便进行了一下求lca的速度测试：

只求LCA的话，树链剖分最快，tarjan次之，倍增最慢（经常被卡）；

还需要一些附加信息的话，tarjan无法处理，树链剖分效率很好，倍增效率太低；

代码长度上，树链剖分最长，lca次之，tarjan最短；

如果考场上只求lca的话，建议tarjan，很好写；

T3：

无力吐槽，这题让一心一意备考noip的人怎么受得了；

概率dp；

把概率扒下来其实就是一背包动规；

具体的还是自己去体会(看代码)......

 

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cstdlib>
 4 #include<cstring>
 5 #include<string>
 6 #include<ctime>
 7 #include<cmath>
 8 #include<set>
 9 #include<map>
10 #include<queue>
11 #include<algorithm>
12 #include<iomanip>
13 #include<queue>
14 using namespace std;
15 #define FILE "dealing"
16 #define up(i,j,n) for(int i=(j);i<=(n);i++)
17 #define pii pair<int,int>
18 #define LL long long
19 #define db double 
20 namespace IO{
21     char buf[1<<15],*fs,*ft;
22     int gc(){return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?-1:*fs++;}
23     int read(){
24         int ch=gc(),f=0,x=0;
25         while(ch<'0'||ch>'9'){if(ch=='-')f=1;ch=gc();}
26         while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+ch-'0';ch=gc();}
27         return f?-x:x;
28     }
29 }using namespace IO;
30 const int maxn=2020;
31 const db inf=100000000.0;
32 int n,m,v,e,a[maxn],b[maxn];
33 db k[maxn];
34 int d[maxn][maxn];
35 void init(){
36     scanf("%d%d%d%d",&n,&m,&v,&e);
37     memset(d,10,sizeof(d));
38     up(i,1,v)d[i][i]=0;
39     up(i,1,n)scanf("%d",&a[i]);
40     up(i,1,n)scanf("%d",&b[i]);
41     up(i,1,n)scanf("%lf",&k[i]);
42     int x,y,vv;
43     up(i,1,e){
44         scanf("%d%d%d",&x,&y,&vv);
45         if(d[x][y]>vv)d[x][y]=d[y][x]=vv;
46     }
47     up(g,1,v)up(i,1,v)up(j,1,v)if(d[i][g]+d[g][j]<d[i][j])d[i][j]=d[i][g]+d[g][j];
48 }
49 db f[2020][2020][2];
50 void slove(){
51     up(i,1,n)up(j,0,m)f[i][j][0]=f[i][j][1]=inf;
52     f[1][1][1]=f[1][0][0]=0;
53     db duu,duv,dvu,dvv,ans=inf;
54     up(i,2,n)for(int j=0;j<=i&&j<=m;j++){
55         duu=d[a[i-1]][a[i]],duv=d[a[i-1]][b[i]],dvu=d[b[i-1]][a[i]],dvv=d[b[i-1]][b[i]];
56         if(j!=i)f[i][j][0]=min(f[i-1][j][1]+duu*(1-k[i-1])+dvu*k[i-1],duu+f[i-1][j][0]);
57         if(j)f[i][j][1]=min(f[i-1][j-1][1]+duu*(1-k[i-1])*(1-k[i])+duv*(1-k[i-1])*k[i]+dvv*k[i]*k[i-1]+dvu*k[i-1]*(1-k[i]),f[i-1][j-1][0]+duv*k[i]+duu*(1-k[i]));
58     }
59     for(int i=0;i<=m;i++)ans=min(ans,min(f[n][i][0],f[n][i][1]));
60     printf("%.2lf\n",ans);
61 }
62 int main(){
63     freopen(FILE".in","r",stdin);
64     freopen(FILE".out","w",stdout);
65     init();
66     slove();
67     return 0;
68 }
View Code

 

 

Day2:

T1:

组合数，考场脑子一抽写了二维树状数组，但实际也没什么问题（实际这题的二维动规是有一定的风险的，有人因此挂了）；

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cstdlib>
 4 #include<cstring>
 5 #include<string>
 6 #include<ctime>
 7 #include<cmath>
 8 #include<set>
 9 #include<map>
10 #include<queue>
11 #include<algorithm>
12 #include<iomanip>
13 using namespace std;
14 #define FILE "problem"
15 #define up(i,j,n) for(int i=(j);i<=(n);i++)
16 #define pii pair<int,int>
17 #define LL long long
18 namespace IO{
19     char buf[1<<15],*fs,*ft;
20     int gc(){return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?-1:*fs++;}
21     int read(){
22         int ch=gc(),f=0,x=0;
23         while(ch<'0'||ch>'9'){if(ch=='-')f=1;ch=gc();}
24         while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+ch-'0';ch=gc();}
25         return f?-x:x;
26     }
27 }using namespace IO;
28 const int maxn=2020,N=2000;
29 int c[maxn][maxn];
30 int sum[maxn][maxn];
31 int T,k,n,m;
32 int main(){
33     //freopen(FILE".in","r",stdin);
34     //freopen(FILE".out","w",stdout);
35     T=read(),k=read();
36     c[0][0]=1;
37     up(i,1,N){
38         c[i][0]=1;
39         up(j,1,i){
40             c[i][j]=(c[i-1][j-1]+c[i-1][j])%k;
41             sum[i][j]=sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+(c[i][j]==0?1:0);
42         }
43         up(j,i+1,N)sum[i][j]=sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1];
44     }
45     while(T--){
46         n=read(),m=read();
47         if(m>n)m=n;
48         printf("%d\n",sum[n][m]);
49     }
50     return 0;
51 }
View Code

T2:

数学题目，需要证一下单调性（求个导如何？）

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cstdlib>
 4 #include<cstring>
 5 #include<string>
 6 #include<ctime>
 7 #include<cmath>
 8 #include<set>
 9 #include<map>
10 #include<queue>
11 #include<algorithm>
12 #include<iomanip>
13 using namespace std;
14 #define FILE "earthworm"
15 #define up(i,j,n) for(int i=(j);i<=(n);i++)
16 #define pii pair<int,int>
17 #define LL long long
18 namespace IO{
19     char buf[1<<15],*fs,*ft;
20     int gc(){return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?-1:*fs++;}
21     int read(){
22         int ch=gc(),f=0,x=0;
23         while(ch<'0'||ch>'9'){if(ch=='-')f=1;ch=gc();}
24         while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+ch-'0';ch=gc();}
25         return f?-x:x;
26     }
27 }using namespace IO;
28 const int maxn=8001000;
29 const double E=0.0000001;
30 int a[maxn],b[maxn],c[maxn];
31 int ha,hb,hc,tb=1,tc=1;
32 int n,m,u,v,t,q,d;
33 LL pop(){
34     int L;
35     if(ha&&(a[ha]>=b[tb]||tb>hb)&&(a[ha]>=c[tc]||tc>hc))L=a[ha],ha--;
36     else if(tb<=hb&&(b[tb]>=a[ha]||!ha)&&(b[tb]>=c[tc]||tc>hc))L=b[tb],tb++;
37     else L=c[tc],tc++;
38     return L;
39 }
40 int main(){
41     n=read(),m=read(),q=read(),u=read(),v=read(),t=read();
42     up(i,1,n)a[i]=read();
43     sort(a+1,a+n+1);
44     ha=n;
45     LL L,top=1;
46     up(i,1,m){
47         L=pop()+d;
48         d+=q;
49         if(top*t==i){printf("%lld ",L);top++;}
50         b[++hb]=(int)(L*u/v)-d;
51         c[++hc]=L-b[hb]-2*d;
52     }
53     cout<<endl;
54     top=1;
55     up(i,1,m+n){
56         L=pop();
57         if(t*top==i){printf("%lld ",L+d);top++;}
58     }
59     return 0;
60 }
61
View Code

T3：

惭愧惭愧，考场不假思索，先打暴力......

后改记忆化，本质上都是状压dp；

吐槽的是，我同学写正解都被卡了一个n，而我写dfs，没有被卡掉......

实质上dfs会避免访问很多不可能出现的状态，所以效率比较高；

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cstdlib>
 4 #include<cstring>
 5 #include<string>
 6 #include<ctime>
 7 #include<cmath>
 8 #include<set>
 9 #include<map>
10 #include<queue>
11 #include<algorithm>
12 #include<iomanip>
13 using namespace std;
14 #define FILE "angrybirds"
15 #define up(i,j,n) for(int i=(j);i<=(n);i++)
16 #define pii pair<int,int>
17 #define LL long long
18 #define pdd pair<double,double> 
19 namespace IO{
20     char buf[1<<15],*fs,*ft;
21     int gc(){return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?-1:*fs++;}
22     int read(){
23         int ch=gc(),f=0,x=0;
24         while(ch<'0'||ch>'9'){if(ch=='-')f=1;ch=gc();}
25         while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+ch-'0';ch=gc();}
26         return f?-x:x;
27     }
28 }using namespace IO;
29 inline bool chkmin(int &a,int b){return a>b?a=b,true:false;}
30 inline bool chkmax(int &a,int b){return a<b?a=b,true:false;}
31 const int maxn=20,N=2000;
32 const double E=0.00000001;
33 int T,n,m;
34 int ans;
35 double x[maxn],y[maxn];
36 inline bool c(double x,double y){return abs(x-y)<=E;} 
37 inline pdd slove(double q,double w,double e,double r){
38     pdd dui;
39     if(c(q,e))return make_pair(0,0);
40     dui.first=(w*e-q*r)/(q*e*(q-e));
41     if(dui.first+E>=0)return make_pair(0,0);
42     dui.second=(w*e-dui.first*q*q*e)/(q*e);
43     return dui;
44 }
45 int f[300000];
46 int dfs(int top,int vis){
47     if(f[vis]!=-1)return f[vis];
48     if(top==n+1)return f[vis]=0;
49     if((1<<top-1)&vis)return f[vis]=dfs(top+1,vis);
50     pdd p;
51     f[vis]=n;
52     int q=vis;
53     up(i,top+1,n){
54         vis=q;
55         if(!((1<<i-1)&vis)){
56             p=slove(x[top],y[top],x[i],y[i]);
57             if(!p.first)continue;
58             vis=vis^(1<<top-1);
59             vis=vis^(1<<i-1);
60             up(j,top+1,n){
61                 if(vis&(1<<j-1))continue;
62                 if(c(p.first*x[j]*x[j]+p.second*x[j],y[j]))vis=vis^(1<<j-1);
63             }
64             chkmin(f[q],dfs(top+1,vis)+1);
65         }
66     }
67     vis=q;
68     chkmin(f[vis],dfs(top+1,vis^(1<<top-1))+1);
69     return f[vis];
70 }
71 int main(){
72     //freopen(FILE".in","r",stdin);
73     //freopen(FILE".out","w",stdout);
74     scanf("%d",&T);
75     while(T--){
76         scanf("%d%d",&n,&m);
77         up(i,1,n)scanf("%lf%lf",&x[i],&y[i]);
78         if(!m||m==2)ans=n;
79         if(m==1)ans=(n%3)?(n/3+2):(n/3+1);
80         memset(f,-1,sizeof(f));
81         cout<<dfs(1,0)<<endl;
82     }
83     return 0;
84 }
View Code

 

转载于:https://www.cnblogs.com/chadinblog/p/6123797.html


http://chatgpt.dhexx.cn/article/MrsqEqHT.shtml

相关文章

2016noip-问题求解超级详细解

2016noip-问题求解超级详细解

noip2016普及组问题求解 从一个44的棋盘&#xff08;不可旋转&#xff09;中选取不在同一行也不在同一列上的两个方格&#xff0c;共有&#xff08; &#xff09;种方法。 解题&#xff1a;首先是如下棋盘 于是我们发现这是组合问题&#xff0c;也就是从16个格子中选择两个格子…
阅读更多...
MIPI D-PHY C-PHY

MIPI D-PHY C-PHY

MIPI可分为物理层和逻辑层两大部分。物理层尽可能采用通用内容&#xff0c;逻辑层则是分别面向摄像头、显示屏、移动通信、存储等不同用途的专用协议。MIPI的物理层有D-PHY、M-PHY、C-PHY等3种。D-PHY现在大量应用于应用处理器与显示屏、摄像头连接的部分。随着摄像头、显示屏的…
阅读更多...
以太网phy学习

以太网phy学习

关键词 10BASE2:采用细同轴电缆接口的IEEE 802.3 10Mb/s物理层规格(参见IEEE 802.3 Clause 10.) 10BASE5:采用粗同轴电缆接口的IEEE 802.3 10Mb/s物理层规格(参见IEEE 802.3 Clause 8.) 10BASE-F:采用光纤电缆接口的IEEE 802.3 10Mb/s物理层规格(参见IEEE 802.3 Clause 15.) 1…
阅读更多...
M-PHY协议解读一：M-PHY整体概述

M-PHY协议解读一：M-PHY整体概述

1.1 M-PHY整体概述 M-PHY协议思维导图如下&#xff1a; 思维导图主要分为两大部分&#xff1a;M-PHY基本特点和基本概念。第一部分对M-PHY的基本特点进行描述&#xff0c;通过与D-PHY/C-PHY多个维度的对比分析&#xff0c;对M-PHY有一个整体的基本认识&#xff1b;第二部分对M…
阅读更多...
以太网PHY 开发与解析

以太网PHY 开发与解析

目录 1.PHY芯片介绍 1.1 芯片引脚定义和说明 1.2 PHY芯片功能说明 1.3 供电管理 1.4 寄存器说明 1.4.1 控制寄存器 1.4.2 状态寄存器 1.4.3 PHY ID寄存器 1.4.4 自协商广播寄存器 1.4.5 自动协商链接合作伙伴能力寄存器 1.4.6 自动协商扩展寄存器 1.4.7 AVICOM指定…
阅读更多...
PHY MAC

PHY MAC

常用网卡芯片 DM9000 MAC(数据链路层)PHY(物理层) CS8900 PHY LAN91C111 MACPHY PHY 百科名片 PHY指物理层&#xff0c;OSI的最底层。 一般指与外部信号接口的芯片。 以太网PHY芯片 。小小的不起眼但又无处不在的网卡。如果在5年前&#xff0…
阅读更多...
MIPI C-PHY 与 D-PHY

MIPI C-PHY 与 D-PHY

MIPI&#xff1a;即移动产业处理器接口&#xff08;Mobile Industry Processor Interface 简称MIPI&#xff09;联盟&#xff1b;是MIPI联盟发起的为移动应用处理器制定的开放标准和一个规范。 CSI&#xff1a;MIPI-CSI-2协议是MIPI联盟协议的子协议&#xff0c;专门针对摄像头…
阅读更多...
MIPI系列之“C-PHY”

MIPI系列之“C-PHY”

本篇主要介绍物理层WG中的C-PHY。C-PHY基于3-Phase symbol编码技术&#xff0c;通过three-wire trios传输2.28 bits/symbol&#xff0c;其目标速率是2.5Gsymbols/s。C-PHY与D-PHY有许多共同点&#xff0c;C-PHY的绝大部分特性都是从D-PHY改编而来的。C-PHY被设计成能够与D-PHY在…
阅读更多...
ethernet phy

ethernet phy

phy处于physical层&#xff0c;上一层是data link层&#xff1a;MAC&#xff0c;两者通过xMII和MDIO接口通信。 xMII XMII包含MII(802.3 sec22&#xff0c;适用于10M和100M传输)&#xff0c;GMII(802.3 sec35.2.2&#xff0c;适用于1000M传输)&#xff0c;RGMII(GMII的简化版)…
阅读更多...
USB的PHY

USB的PHY

Linux USB 3.0驱动分析&#xff08;六&#xff09;——USB主机控制器HCD分析 网卡芯片,也有 controller(mac芯片) 和 PHY部分 USB 芯片,也有 controller 和 PHY部分 5G 芯片,也有 协议层 和 PHY部分USB主机控制器和USB PHY是如何完成收发数据的 USB 全套硬件组成ControllerC…
阅读更多...
PHY芯片

PHY芯片

以太网媒体接入控制器(MAC) 物理接口收发器(PHY) 以太网接口可分为协议层和物理层。 协议层是由一个叫MAC(Media Access Layer&#xff0c;媒体访问层)控制器的单一模块实现。 物理层由两部分组成&#xff0c;即PHY(Physical Layer&#xff0c;物理层)和传输器。 常见的网卡芯片…
阅读更多...
C-PHY技术是什么

C-PHY技术是什么

2018年5月17日&#xff0c;一加发布了自家旗舰手机一加6&#xff0c;在相机的宣传图片中&#xff0c;首次见到提起C-PHY技术和Type-2对焦这两个概念&#xff0c;于是经过在网络的挖掘和学习&#xff0c;先总结下C-PHY技术的基本概念 C-PHY技术来自哪里 图像传感器&#xff0c;…
阅读更多...
MIPI 系列之 D-PHY

MIPI 系列之 D-PHY

目录 1、简述 2、管脚连接 3、D-PHY 的时钟 4、D-PHY Lane (Clock Lane And Data Lane) 4.1、信号摆幅 4.2、信号含义 4.3、状态码 5、传输特性和方向 6、D-PHY Data Lane 6.1、高速 Data Lane 传输 6.2、双向传输 Data Lane Turnaround 6.3、Data Lane 的 Escape …
阅读更多...
PHY- PHY芯片概述

PHY- PHY芯片概述

1 PHY概述 关于Internet Protocal的分层模型可以参考文章 ：【Internet Protocal-OSI模型中的网络分层模型】，下面我们讲讲底层以太网控制器和收发器的知识。其主要是处理OSI模型中的物理层和链路层的事情。 在CAN/CANFD、FlexRay等总线中，有控制器Controller和收发器Transc…
阅读更多...
以太网PHY原理介绍

以太网PHY原理介绍

一、以太网分层模型 基于 OSI 七层网络模型&#xff0c; 车载以太网的网络拓扑结构如图1-1所示。 图1-1 车载以太网网络拓扑结构图 从图中可以看到位于 Layer1 和 Layer2 的为物理层和数据链路层。 Layer3 以上各层包含了 TCP/IP、 DOIP、SomeIP 等协议&#xff0c; 由 EthSt…
阅读更多...
PHY（Physical Layer，PHY）通俗理解

PHY（Physical Layer，PHY）通俗理解

碎碎念&#xff1a;最近更新的周期有点长... 主要最近和朋友一起重新开了一个公众号&#xff08;FPGA Breaker&#xff09;&#xff0c;这个公众号也和本公众号垂直深度&#xff0c;不会和本公众号内容有太多重叠&#xff0c;主要是本人想推进国内开源IP的使用和发展&#xff0…
阅读更多...
MAC和PHY的区别

MAC和PHY的区别

&#xfeff;&#xfeff; 转载自&#xff1a;https://www.cnblogs.com/feitian629/archive/2013/01/25/2876857.html 一块以太网网卡包括OSI&#xff08;开方系统互联&#xff09;模型的两个层。物理层和数据链路层。物理层定义了数据传送与接收所需要的电与光信号、线路状态、…
阅读更多...
PHY寄存器

PHY寄存器

在之前的文章&#xff0c;我们讲解了STM32的网络外设部分。 文章有《STM32网络电路设计》《STM32网络之MAC控制器》《STM32网络之DMA控制器》《STM32网络之中断》。 STM32只有网络外设时不能进行网络通信的&#xff0c;因为STM32只提供了SMI接口&#xff0c;MII和RMII接口。我们…
阅读更多...
以太网基础-MAC和PHY

以太网基础-MAC和PHY

网卡(Network Interface Card&#xff0c;简称NIC)&#xff0c;也称网络适配器&#xff0c;是电脑与局域网相互连接的设备。无论是普通电脑还是高端服务器&#xff0c;只要连接到局域网&#xff0c;就都需要安装一块网卡。如果有必要&#xff0c;一台电脑也可以同时安装两块或多…
阅读更多...
【以太网通信】PHY 芯片回环测试

【以太网通信】PHY 芯片回环测试

PHY 芯片通常带有回环&#xff08;Loopback&#xff09;功能&#xff0c;用于 PHY 通信链路的测试。本文主要讨论三种常用 PHY 芯片的回环功能&#xff0c;并使用 Broadcom 的 B50612D 芯片进行 PHY 回环测试。 目录 1 常见 PHY 的回环功能 1.1 KSZ9031 1.2 RTL8211 1.3 B5…
阅读更多...
推荐文章

Copyright @ 2022~2023