《算法竞赛进阶指南》 0x25 ~ 0x28 代码 + 杂谈

最新推荐文章于 2023-08-22 16:15:47 发布
最新推荐文章于 2023-08-22 16:15:47 发布
阅读量774 收藏
点赞数
分类专栏： 题集 《算法竞赛进阶指南》杂谈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40831340/article/details/98472034
版权

0x25

推箱子。。。。。。。 是真的写废了。。。。

矩阵距离

这个就是常见点 一开始就把多元点 放入队列的写法

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
typedef pair<int, int> P;

int n, m;
int ans[maxn][maxn];
struct node{
    int x, y, st;
};

queue<node> que;

bool chk(int x, int y) {
    return (x < 1 || y < 1 || x > n || y > m || ans[x][y] != -1);
}

void bfs(){
    while(!que.empty()){
        node p = que.front(); que.pop();
        for(int i = 0; i < 4; i ++) {
            int nx = p.x + dx[i];
            int ny = p.y + dy[i];
            if(chk(nx, ny)) continue;
            ans[nx][ny] = p.st + 1;
            que.push(node{nx, ny, p.st + 1});
        }
    }
    
}

int main(){
    memset(ans, -1, sizeof ans);
    cin >> n >> m;
    string str;
    for(int i = 1;i <= n; i ++) {
        cin >> str;
        for(int j = 1; j <= m; j ++) {
            if(str[j - 1] == '1') ans[i][j] = 0, que.push(node{i, j, 0});
        }
    }
    bfs();
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j ++) cout << ans[i][j] << " ";
        cout << endl;
    } 
    return 0;
}

0x26

双端队列BFS
电路维修 权值只有 0 1 0 放前面提前出 1 放后面 以此减低复杂度
注意 每个点 对应的权值 改了好就

#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
const int maxn = 505;

const int dx[] = {1, -1, -1, 1};
const int dy[] = {1, -1, 1, -1};
const int ndx[] = {1, 0, 0, 1};
const int ndy[] = {1, 0, 1, 0};

int n, m;
char str[maxn][maxn];
bool vis[maxn][maxn];
int dis[maxn][maxn];

struct node{
    int x, y;
};

bool check(int x, int y) {return x >= 0 && x <= n && y >= 0 && y <= m;}

void bfs(){
    deque<node> que;
    que.push_back(node{0, 0});
    memset(dis, 0x3f, sizeof dis);
    memset(vis, 0, sizeof vis);
    vis[0][0] = 1;
    dis[0][0] = 0;
    while(!que.empty()) {
        node p = que.front(); que.pop_front();
        for(int i = 0, t; i < 4; i ++) {
            int nx = p.x + ndx[i], tx = p.x + dx[i];
            int ny = p.y + ndy[i], ty = p.y + dy[i];
            if(i < 2) t = str[nx][ny] == '/' ? 1 : 0;
            else t = str[nx][ny] == '/' ? 0 : 1;
            if(check(tx, ty) && !vis[tx][ty] && dis[tx][ty] > dis[p.x][p.y] + t){
                dis[tx][ty] = dis[p.x][p.y] + t;
                if(t) que.push_back(node{tx, ty});
                else que.push_front(node{tx, ty});
            }
        }
    }
    if(dis[n][m] != 0x3f3f3f3f) cout << dis[n][m] << endl;
    else cout << "NO SOLUTION" << endl;
}

int main(){
    int t;
    cin >> t;
    while(t--){
        cin >> n >> m;
        for(int i = 1; i <= n; i ++ ) cin >> (str[i] + 1);
        bfs();
        // for(int i = 0; i <= n; i ++) {
        //     for(int j = 0; j <= m; j++) {
        //         cout << dis[i][j] << " ";
        //     }cout << endl;
        // }
    }
    return 0;
}
优先队列BFS

我想起了DJ最短路。。

Full Tank

这个 也是常见的 很像最短路 分层图一个写法

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 5;

int head[maxn], fcst[maxn], cnt;
int nxt[maxn * 20], to[maxn * 20], dis[maxn * 20];
bool vis[maxn][105];

struct node{
    int u, f, cst;
    bool operator < (const node & a) const {
        return cst > a.cst;
    }
};

void ade(int a, int b, int v) {
    to[++cnt] = b, dis[cnt] = v;
    nxt[cnt] = head[a], head[a] = cnt;
    to[++cnt] = a, dis[cnt] = v;
    nxt[cnt] = head[b], head[b] = cnt;
}

int dj(int c, int s, int t){
    priority_queue<node> que;
    memset(vis, 0, sizeof vis);
    que.push(node{s, 0, 0});
    while(!que.empty()) {
        node p = que.top(); que.pop();
        if(p.u == t) return p.cst;
        if(vis[p.u][p.f]) continue;
        vis[p.u][p.f] = 1;
        if(p.f < c && !vis[p.u][p.f + 1]) {
            que.push(node{p.u, p.f + 1, p.cst + fcst[p.u]});
        }
        for(int i = head[p.u]; i; i = nxt[i]) {
            int v = to[i];
            if(p.f >= dis[i] && !vis[v][p.f - dis[i]]) {
                que.push(node{v, p.f - dis[i], p.cst});
            }
        }
    }
    return -1;
}

int main() {
    int n, m;
    cin >> n >> m;
    for(int i = 0; i < n; i ++) cin >> fcst[i];
    for(int i = 1, a, b, c; i <= m; i ++) 
        cin >> a >> b >> c, ade(a, b, c);
    cin >> m;
    for(int i = 1, c, s, t; i <= m; i ++) {
        cin >> c >> s >> t;
        int ans = dj(c, s, t);
        if(ans == -1) cout << "impossible\n";
        else cout << ans << endl;
    }
    return 0;
}
双向BFS
噩梦

对着3个会动的分别极限BFS 每个人论者进行一次 鬼先走
省去去 一起跑 状态太多的存储 也是BFS一个有效方法

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int maxn = 800 + 5;
const int INF = 0x3f3f3f3;
const int cx[] = {-1, 0, 1, 0};
const int cy[] = {0, 1, 0, -1};
string str;
int n, m, cas;
char mp[maxn][maxn];

struct node{
	int x, y, sp;
	node(int _x, int _y, int _sp){
		x = _x, y = _y, sp = _sp;
	}
};
queue<node> G, Z, M;

bool chkZ(int x, int y) {
	return (x < 1 || y < 1 || x > n || y > m || mp[x][y] == 'Z');
}

bool chkH(int x, int y) {
	if((x < 1 || y < 1 || x > n || y > m)) return 1;
	if(mp[x][y] == 'X' || mp[x][y] == 'Z') return 1;
	return 0; 
}

void pt(){
	for(int i = 1; i <= n; i++) {
		for(int j = 1; j <= m; j ++) {
			cout << mp[i][j] << " ";
		}cout << endl;
	}
}

int sol(){
	while(Z.size()) {
		int time = Z.front().sp;
	//	cout << "-----------" << endl;pt();cout << endl;
		while(!Z.empty() && Z.front().sp < time + 2) {
			node p = Z.front(); Z.pop();
			for(int i = 0; i < 4; i ++) {
				int nx = p.x + cx[i], ny = p.y + cy[i];
				if(chkZ(nx, ny)) continue;
				mp[nx][ny] = 'Z';
				Z.push(node(nx, ny, p.sp + 1));
 			}
		}
	//	pt();cout << endl;
		time = M.front().sp;
		while(!M.empty() && M.front().sp < time + 3) {
			node p = M.front(); M.pop();
			if(mp[p.x][p.y] == 'Z') continue;
			for(int i = 0; i < 4; i ++) {
				int nx = p.x + cx[i], ny = p.y + cy[i];
				if(chkH(nx, ny)) continue;
				if(mp[nx][ny] == 'M') continue;
				if(mp[nx][ny] == 'G') return p.sp / 3 + 1;
				mp[nx][ny] = 'M';
				M.push(node(nx, ny, p.sp + 1));
 			}
		}
		//	pt();cout << endl;
		time = G.front().sp;
		while(!G.empty() && G.front().sp < time + 1) {
			node p = G.front(); G.pop();
			if(mp[p.x][p.y] == 'Z') continue;
			for(int i = 0; i < 4; i ++) {
				int nx = p.x + cx[i], ny = p.y + cy[i];
				if(chkH(nx, ny)) continue;
				if(mp[nx][ny] == 'G') continue;
				if(mp[nx][ny] == 'M') return p.sp + 1;
				mp[nx][ny] = 'G';
				G.push(node(nx, ny, p.sp + 1));
 			}
		}
		//	pt();cout << endl;
	} 
	return -1;
}

signed main(){
	cin >> cas;
	while(cas --) {
		while(!Z.empty()) Z.pop();
		while(!G.empty()) G.pop();
		while(!M.empty()) M.pop();
		cin >> n >> m;
		for(int i = 1; i <= n; i ++) {
			cin >> str;
			for(int j = 1; j <= m; j ++){
				mp[i][j] = str[j - 1];
				if(str[j - 1] == 'G') G.push(node(i, j, 0));
				if(str[j - 1] == 'Z') Z.push(node(i, j, 0));
				if(str[j - 1] == 'M') M.push(node(i, j, 0));
			}
		}
		cout << sol() << endl;
	}
	return 0; 
}

Astar

加上估值函数的 BFS A*
估值函数不能大于实际价值就好
估的越好 我们越能从队列里取出 最优的状态 减低复杂度

第K短路

正常跑最短路 如果补终止 那么 这个点 第几次出现 就是第K短路上的路径和

#include <bits/stdc++.h>
//#define int long long
using namespace std;
const int maxn = 1000 + 10;
const int maxe = 1e5 + 10;
const int INF = 0x3f3f3f3;
typedef pair<int, int> P;

int n, m, s, t, k;
int head[maxn], cnt;
int nxt[maxe << 1], to[maxe << 1], dis[maxe << 1];
void ade(int a, int b, int v) {
	to[++ cnt] = b, dis[cnt] = v;
	nxt[cnt] = head[a], head[a] = cnt;
}

int rhead[maxn], rcnt;
int rnxt[maxe << 1], rto[maxe << 1], rdis[maxe << 1];
void rade(int a, int b, int v) {
	rto[++ rcnt] = b, rdis[rcnt] = v;
	rnxt[rcnt] = rhead[a], rhead[a] = rcnt;
}

int f[maxn];
bool vis[maxn];
void dj(int s, int t) {
	memset(f, 0x3f, sizeof f);
	f[s] = 0;
	priority_queue<P> que;
	que.push(P(0, s));
	while(!que.empty()) {
		P p = que.top(); que.pop();
		int u = p.second;
		if(vis[u]) continue;
		vis[u] = 1;
		for(int i = rhead[u]; i; i = rnxt[i]) {
			int v = rto[i];
			if(f[v] > f[u] + rdis[i]) {
				f[v] = f[u] + rdis[i];
				que.push(P(-f[v], v));
			} 
		}
	}
}

struct node{
	int u, f, g;
	bool operator < (const node & a) const {
		return f + g > a.f + a.g;
	}
};

int Astar(int s, int t, int k) {
	int counts = 0;
	priority_queue<node> que;
	if(s == t) k ++;
	que.push(node{s, 0, 0});
	while(!que.empty()) {
		node p = que.top(); que.pop();
		int u = p.u;
		if(u == t) counts++;
		if(counts == k) return p.g;
		for(int i = head[u]; i; i = nxt[i]) {
			int v = to[i];
			que.push(node{v, 0, dis[i] + p.g});
		}
	}
	return -1;
}

signed main() {
	cin >> n >> m;
	for(int i = 1, a, b, c; i <= m; i ++) {
		cin >> a >> b >> c;
		ade(a, b, c), rade(b, a, c);
	}
	cin >> s >> t >> k;
	dj(t, s);
//	for(int i = 1; i <= n; i ++) cout << f[i] << " " ; cout << endl;
	cout << Astar(s, t, k) << endl;
	return 0;
}

八数码 问题

其实 这里还可以加上 逆序对优化 排除一些无解的情况

#include <bits/stdc++.h>
using namespace std;
const int maxn = 362880 + 100;
const int fac[] = {1,1,2,6,24,120,720,5040,40320,362880};

bool vis[maxn];
const int cx[] = {-1, 1, 0, 0};
const int cy[] = {0, 0, -1, 1};
const char op[] = {'u','d','l','r'};
const int endsta = 0;
char path[maxn];
int pre[maxn];

struct node {
	int sta, g, f;
	int s[9], loc;
	bool operator < (const node& a) const {
		return g + f > a.g + a.f;
	}
};

int cantor(int *a) {
	int x = 0;
	for (int i = 0; i < 9; ++i) {
		int tmp = 0;
		for (int j = i + 1; j < 9; ++j)
			if (a[j] < a[i])
				tmp++;
		x += fac[9 - i - 1] * tmp;
	}
	return x;
}

int dis_f(int *s) {
	int res = 0;
	for(int i = 0; i < 9; i ++)
		if(s[i] != 9) {
			int x = i/3, y = i%3;
			int xx = (s[i] - 1)/3, yy = (s[i]  - 1)%3;
			res += abs(x - xx) + abs(y - yy);
		}
	return res;
}

priority_queue<node>que;
bool astar(node begins) {
	begins.sta = cantor(begins.s);
	begins.g = 0, begins.f = dis_f(begins.s);
	pre[begins.sta] = -1;
	vis[begins.sta] = 1;
	que.push(begins);
	node tmp,now;
	while(!que.empty()) {
		node now = que.top();
		que.pop();
		if(now.sta == endsta) return 1;
		int x = now.loc / 3, y = now.loc % 3;
		for(int i = 0; i < 4; i ++) {
			int nx = x + cx[i];
			int ny = y + cy[i];
			if(nx < 0 || nx > 2 || ny < 0 || ny > 2) continue;
			tmp = now;
			tmp.s[x * 3 + y] = tmp.s[nx * 3 + ny];
			tmp.s[nx * 3 + ny] = 9;
			tmp.sta = cantor(tmp.s);
			if(vis[tmp.sta]) continue;
			vis[tmp.sta] = 1;
			tmp.loc = nx * 3 + ny;
			tmp.g ++;
			tmp.f = dis_f(tmp.s);
			pre[tmp.sta] = now.sta;
			path[tmp.sta] = op[i];
			que.push(tmp);
		}
	}
	return 0;
}

void print(int sta) {
	if(pre[sta] == -1) return ;
	print(pre[sta]);
	printf("%c", path[sta]);
}

int main() {
	node begins;
	char pt;
	for(int i = 0; i < 9; i ++ ) {
		scanf(" %c", &pt);
		if(pt == 'x') begins.s[i] = 9, begins.loc = i;
		else begins.s[i] = pt - '0';
	}
	if(!astar(begins)) puts("unsolvable");
	else print(endsta), puts("");
	return 0;
}

IDA*

排书

这个估值函数 我一开始写的不太对了 一直T 跪了 有点难

#include<cstdio>
#include<iostream>
#include<cmath>
using namespace std;
const int maxn = 25;
int n;

struct node{
    int a[maxn];
    int reh(){
        int cnt = 0;
        if ( a[1] != 1 ) ++cnt;
        if ( a[n] != n ) ++cnt;
        for ( int i = 1; i < n; ++i )
                if ( a[i] + 1 != a[i + 1] ) ++cnt;
        return ceil( cnt / 3.0 );
    }

    bool chk() {
        for(int i = 1; i < n; i ++) 
            if(a[i] + 1 != a[i + 1]) return 0;
        return 1;
    }

    node move(int l, int r, int len) {
        node b = *this;
        for(int i = len + l; i <= r; i ++) b.a[i - len] = b.a[i]; 
        for(int i = r - len + 1; i <= r; i ++) b.a[i] = a[i + l - r + len - 1];
        return b;
   }
}ts;

int flag;

void dfs(node x, int h,int limit) {
    if(flag || x.reh() + h > limit) return;
    if(x.chk()) {flag = 1; return ;}
    for(int len = 1; len < n; len ++) 
        for(int i = 1; i + len - 1 <= n; i ++) 
            for(int j = i + len; j <= n; j ++) 
            dfs(x.move(i, j, len), h + 1, limit);
}

int main() {
    int t; cin >> t;
    while(t --) {
        cin >> n;
        for(int i = 1; i <= n; i ++) cin >> ts.a[i];
        flag = 0;
        for(int i = 0; i < 5; i ++) {
            dfs(ts, 0, i);
            if(flag) {
                cout << i << endl;
                break;
            }
        }
        if(!flag) cout << "5 or more" << endl;
    }
    return 0;
}

待续。

ZHXU1998
关注
专栏目录
当_WIN32_WINNT大于0x500时，ToolTip窗口不显示问题排查
dvlinker的技术专栏
03-14 1万+
当_WIN32_WINNT大于0x500时，ToolTip窗口不显示问题排查。
《算法竞赛进阶指南》 0x6A 代码 + 杂谈
蒟蒻的最后的倔强
08-07 364
舞动的晚会 我自己写的 建图可能写错了 导致后面输出的像是可行边 我也很迷 感觉没有检错图 匹配边(i,j) j到i连边 非匹配边 (i,j) i到j连边 匹配的左点i (i,S) 不匹配的左点i (S,i) 匹配的右点j (T,j) 不匹配的右点j (j,T) 然后用Tarjan求强连通分量 (i,j)是可行边的条件： (i,j)是匹配边 或者 i,j在同一个scc里 那么总边数减去可行边数...
《算法竞赛进阶指南》 0x45 ~ 0x48 代码 + 杂谈
蒟蒻的最后的倔强
07-11 467
点分治 ///淀粉质 链接 ： https://blog.csdn.net/qq_40831340/article/details/90234372 平衡树 theap 模板 // treap模板题 // 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： //插入x数 //删除x数(若有多个相同的数，因只删除一个) //查询x数的排名(排名定义为比当前数小的数的个数+1...
05 算法竞赛进阶指南最短路习题+例题 （附代码+注释+思路）-01
q2090988808的博客
04-06 526
文章目录acwing 340 通信线路题目思路解题代码acwing 341 最优贸易题目思路解题代码 acwing 340 通信线路 题目思路 二分做法思路 定义在[0,1000001] 这个区间中的性质如下： 对于区间中的某一个点x。 求出1走到N,最少经过的长度大于x的边的是否小于等于k。 求出从1到N最少经过几条长度大于x的边。 可以将所有的边权分类：大于等于x的为1，小于的为0。 采用双端队列的BFS来求从1到N的最短路。 解题代码 #include <iostream> #inc
0x25软考|网络工程师经验分享之网络管理
世界上最差的男孩子
06-12 2174
一、网络管理结构概述 二、简单网管协议SNMP 三、管理信息库MIB 四、网络管理工具和命令 五、网络存储技术简介 一、网络管理结构概述 网络管理模型：包括网络监测和网络控制两部分。网络管理模型分为管理站，被管理代理，管理信息库MIB三部分。 两种管理结构： ①集中式：集中控制整个网络。平衡优化网络。适用于小网络。 ②分布式：灵活性和伸缩性，适用于中、大型网络。 两种通信机...
0x28 IDA*
weixin_30748995的博客
07-09 140
一个早上做完了我真牛B 就是A*用于DFS啊，现在我才发现迭代加深真是个好东西。 poj3460%了%了我们的目标是把它的顺序变对，那么第i个位置的值+1是要等于第i+1个位置的值的。对于一个操作，最多就能修正3个位置对应。这题我多迭代了一层时间就跑了多10倍有点恐怖 #include<cstdio> #include<iostream> #inc...
《算法竞赛进阶指南》题解目录
weixin_55355427的博客
04-07 1402
0x00 基本算法 0x01 位运算 T1.a^b T2.64位整数乘法 T3.最短Hamilton路径 T4.起床困难综合症 0x02 递推与递归 T1.递归实现指数型枚举 T2.递归实现组合型枚举 T3.递归实现排列型枚举 T4.费解的开关 T5.Strange Towers of Hanoi T6.Sumdiv T7.Fractal Streets T8.非递归实现组合型枚举 0x03 前缀和与差分 T1.激光炸弹 T2.IncDec Sequence T3.Tallest Cow 0x04 二分 T
0x0000011b共享打印机无法连接 0x0000011b一键修复工具
02-09
WIN10共享打印机出现0x0000011b共享打印机无法连接错误，为了快速处理此问题 ，金石开发了此工具，用于快速修复此错误。只要在共享打印机的电脑上选中此文 件点鼠标右键，在出现的菜单中选择“以管理员身份运行”...
51单片机~串口通信（讲解+代码）
qq_51523386的博客
04-24 1万+
51单片机~串口通信 （一）计算机串行通信原理：
0x80000003+mysql_mysql错误解决办法集合
weixin_34708196的博客
01-18 3678
一、This function has none of DETERMINISTIC, NO SQL, or READS SQL DATA in its de 错误解决办法这是我们开启了bin-log, 我们就必须指定我们的函数是否是1 DETERMINISTIC 不确定的2 NO SQL 没有SQl语句，当然也不会修改数据3 READS SQL DATA 只是读取数据，当然也不会修改数据4 MOD...
c语言0x25怎么转换成31的,进制之间的转化 菜鸟必看
weixin_42349214的博客
05-19 1017
该楼层疑似违规已被系统折叠隐藏此楼查看此楼二进制数要转换为十六进制，就是以4位一段，分别转换为十六进制。如(上行为二制数，下面为对应的十六进制)：11111101，10100101，10011011FD，A5，9B反过来，当我们看到FD时，如何迅速将它转换为二进制数呢？先转换F：看到F，我们需知道它是15(可能你还不熟悉A～F这五个数)...
C语言 文本字符串和十六进制形式的相互转换
Genven_Liang的博客
08-23 1万+
C语言 文本字符串和十六进制形式的相互转换 一、简述 记--C语言实现 文本形式的字符串和十六进制字符串的相互转换。如"01" <==> "3031" 有的数据包含不可见字符，直接打印出来会不可见或残缺，需要转换为十六进制直接看ASCII码值。 二、测试代码 #include <stdio.h> #include <string.h>...
Java基本语法
淼淼不暴躁!
06-03 341
java入门基础Java编程基础数据类型几进制的表示:转义字符**取反,按位异或,左移,右移**条件运算符:**选择条件语句:****循环语句**数组 Java编程基础 数据类型 1.整数类型: byte(8位一个字节),short(16位两个字节),int(32位,4个字节),long(64位,8个字节), 注意点 在使用long的时候需要用在后面加L或者l long num =198l ; long num=45646L; 2.浮点数类型: float (32位,4个字节) , double (64位,
进制转换
sikey的专栏
03-27 502
8进制 028 16进制ox28 1~9 A,B,C,D,E,F(10~15); 如: 1110101， 0111011； 二进制转8进制： 分三个为一组 4 2 1 得出： 001 110 101 = 165； 000 111011 = 73； 二进制转10进制： 相乘如 1110101 :1*(2^6) =64 + 1*(2^5) = 32 +1*(2^4) =...
Java语言基础
Actir的博客
07-08 907
Java语言基础 基础数据类型 Java中有8种基本数据类型来储存数值，字符和布尔值、 基本数据类型（数值型、（整数类型、（byte、short、int、long）浮点数类型（float、double））字型、布尔型） 整数类型： 整数类型用来储存数值，即没有小数部分的数值。可以是正数，也可以是负数。整型数据在java程序中有三种表示形式，分别是十进制，八进制和十六进制。 十进制：十进制的表现形式如 120、0、-127. 除了数字0，不能以0作为其他十进制的开头。 八进制：如0123（转换成十进
汽车UDS诊断之通信控制服务（0x28）深度剖析
热门推荐
心骗小白话的博客
09-15 1万+
CommunicationControl就是通信控制服务，因为ISO14229协议是基于CAN的，所以此服务主要是涉及到CAN通信接收和发送相关的控制。 通信控制 服务 描述 CommunicationControl 客户端向服务端请求打开或关闭某类报文信息的发送和接收功能。（这里的类指的通信类型） 1.英文术语 英文术语 解释 CommunicationControl 通信控制 CommunicationControl Request SID ...
应用角度理解H264码流
qq_38750519的博客
01-06 2628
应用角度理解H264码流前言1、NAL2、SPS 前言 在开发媒体的时候，需要对媒体编解码的一些参数有了解，这篇文章记录一些H264码流开发中，码流的剖析 1、NAL NAL全称Network Abstract Layer, 即网络抽象层。在H.264/AVC视频编码标准中，整个系统框架被分为了两个层面：视频编码层面（VCL）和网络抽象层面（NAL）。其中，前者负责有效表示视频数据的内容，而后者则负责格式化数据并提供头信息，以保证数据适合各种信道和存储介质上的传输。因此我们平时的每帧数据就是一个NA
【AutoSar_UDS服务】0x28服务_通信控制
最新发布
Gagaaaaaa的博客
08-22 1964
uds 0x28详解
计算机网络协议 第五课 IP
mcyuuji的博客
03-20 968
计算机网络协议 第五课第四章网际协议IP4.1 IPv4数据报首部长度与总长度TTL与协议帧与MTU分片与重组4.2 IP首部选项选项的格式无操作选项选项结束选项记录路由选项时间戳选项源路由选项源路由选项处理过程 第四章网际协议IP 4.1 IPv4数据报 首部长度与总长度 问：某路由器接收到一个IP数据报，前8位如下：01000010，请解释它的含义 答：将其看成0100,0010，前者值是4，后者值是2，前者是版本，4代表IPv4协议；后者是首部长度，以4字节为单位计数，所以首部长度为8字节，可是8
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值