【数位dp】刷题集（更新中）

最新推荐文章于 2022-04-18 17:11:01 发布
最新推荐文章于 2022-04-18 17:11:01 发布
阅读量228 收藏 1
点赞数
分类专栏： # 动态规划综合 知识整理 # 数位DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kaka03200/article/details/113792468
版权

目录

模板

应用范围：[l, r]中满足某种情况的数个数

ll dfs(int pos, int pre, bool limit, bool lead) {
    if (pos == -1) return 1;
    if (!limit && !lead && dp[pos][...][...] != -1) return dp[pos][...][...];
    int End = limit ? a[pos] : 9;
    ll ans = 0;
    for (int i = 0; i <= End; i++) {
        ******//操作1
    }
    if (!limit && !lead) dp[pos][...][...] = ans;
    return ans;
}
ll calc(ll x) {
    int pos = 0;
    while (x) {
        a[pos++] = x % 10;
        x /= 10;
    }
    return dfs(pos-1, 0, true, true);
}

基础例题

不要62

#include <bits/stdc++.h>
using namespace std;
//#define ACM_LOCAL
const int N = 2e5 + 10;
const int M = 5e5 + 10;
const int INF = 0x3f3f3f3f;
const double eps = 1e-4;
const int MOD = 1e9 + 7;
typedef long long ll;
typedef pair<int, int> PII;
ll n, m, a[20], dp[20][20];
ll dfs(int pos, int pre, bool limit, bool lead) {
    if (pos == -1) return 1;
    if (!limit && !lead && dp[pos][pre] != -1) return dp[pos][pre];
    int End = limit ? a[pos] : 9;
    ll ans = 0;
    for (int i = 0; i <= End; i++) {
        if (pre == 6) {
            if (i != 2 && i != 4) ans += dfs(pos-1, i, limit && i == End, lead && i == 0);
        } else {
            if (i != 4) ans += dfs(pos-1, i, limit && i == End, lead && i == 0);
        }
    }
    if (!limit && !lead) dp[pos][pre] = ans;
    return ans;
}
ll calc(ll x) {
    int pos = 0;
    while (x) {
        a[pos++] = x % 10;
        x /= 10;
    }
    return dfs(pos-1, 0, true, true);
}
void solve(){
    memset(dp, -1, sizeof dp);
    while (cin >> n >> m) {
        if (n == 0 && m == 0) break;
        printf("%lld\n", calc(m) - calc(n-1));
    }
}
signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

windy数

#include <bits/stdc++.h>
using namespace std;
//#define ACM_LOCAL
const int N = 2e5 + 10;
const int M = 5e5 + 10;
const int INF = 0x3f3f3f3f;
const double eps = 1e-4;
const int MOD = 1e9 + 7;
typedef long long ll;
typedef pair<int, int> PII;
ll n, m, a[20], dp[20][20];
ll dfs(int pos, int pre, bool limit, bool lead) {
    if (pos == -1) return 1;
    if (!limit && !lead && dp[pos][pre] != -1) return dp[pos][pre];
    int End = limit ? a[pos] : 9;
    ll ans = 0;
    for (int i = 0; i <= End; i++) {
        if (lead) ans += dfs(pos-1, i, limit && i == End, lead && i == 0);
        else {
            if (abs(i - pre) >= 2) ans += dfs(pos-1, i, limit && i == End, lead && i == 0);
        }
    }
    if (!limit && !lead) dp[pos][pre] = ans;
    return ans;
}
ll calc(ll x) {
    int pos = 0;
    while (x) {
        a[pos++] = x % 10;
        x /= 10;
    }
    return dfs(pos-1, 0, true, true);
}
void solve() {
    memset(dp, -1, sizeof dp);
    cin >> n >> m;
    printf("%lld\n", calc(m) - calc(n - 1));
}
signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

手机号码

#include <bits/stdc++.h>
using namespace std;
//#define ACM_LOCAL
const int N = 2e5 + 10;
const int M = 5e5 + 10;
const int INF = 0x3f3f3f3f;
const double eps = 1e-4;
const int MOD = 1e9 + 7;
typedef long long ll;
typedef pair<int, int> PII;
ll n, m, a[20], dp[20][20][20][2][2][2];
ll dfs(int pos, int pre1, int pre2, bool limit, bool lead1, bool lead2, bool eight, bool four, bool flag) {
    if (pos == -1) return flag && !(eight && four);
    if (!limit && !lead2 && !lead2 && dp[pos][pre1][pre2][eight][four][flag] != -1) return dp[pos][pre1][pre2][eight][four][flag];
    int End = limit ? a[pos] : 9;
    ll ans = 0;
    for (int i = 0; i <= End; i++) {
        if (!lead2) {
            ans += dfs(pos-1, i, pre1, limit && i == End, lead1 && i == 0, lead1, eight || i == 8, four || i == 4, flag || (i == pre1 && i == pre2 && pre1 == pre2));
        } else {
            ans += dfs(pos-1, i, pre1, limit && i == End, lead1 && i == 0, lead1, eight || i == 8, four || i == 4, flag);
        }
    }
    if (!limit && !lead1 && !lead2) dp[pos][pre1][pre2][eight][four][flag] = ans;
    return ans;
}
ll calc(ll x) {
    int pos = 0;
    while (x) {
        a[pos++] = x % 10;
        x /= 10;
    }
    return dfs(pos-1, 0, 0, true, true, true, false, false, false);
}
void solve() {
    memset(dp, -1, sizeof dp);
    cin >> n >> m;
    printf("%lld\n", calc(m) - calc(n - 1));
}
signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

烦人的数学作业

#include <bits/stdc++.h>
using namespace std;
//#define ACM_LOCAL
#define fi first
#define se second
#define il inline
#define re register
const int N = 1e5 + 10;
const int M = 5e5 + 10;
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const int MOD = 1e9+7;
typedef long long ll;
typedef pair<int, int> PII;
typedef unsigned long long ull;
ll a[20], dp[20][250];
ll dfs(int pos, bool lead, bool limit, ll sum) {
    if (pos == -1) return sum;
    if (!limit && !lead && dp[pos][sum] != -1) return dp[pos][sum];
    int End = limit ? a[pos] : 9;
    ll ans = 0;
    for (int i = 0; i <= End; i++) {
        ans += dfs(pos-1, lead && i == 0, limit && i == End, sum + i);
        ans %= MOD;
    }
    if (!limit && !lead) dp[pos][sum] = ans;
    return ans;
}
ll calc(ll x) {
    int pos = 0;
    while (x) {
        a[pos++] = x % 10;
        x /= 10;
    }
    return dfs(pos-1, true, true, 0);
}
void solve() {
    memset(dp, -1, sizeof dp);
    int T; cin >> T; while (T--) {
        ll n, m; cin >> n >> m;
        printf("%lld\n", (calc(m) - calc(n-1) + MOD) % MOD);
    }
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

诡异数字

#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define re register
typedef long long ll;
typedef pair<int, int> PII;
const int N = 1e5 + 100, M = 1e6 + 5, INF = 0x3f3f3f3f;
const int MOD = 20020219;
ll dp[20][20][20];
int a[20], lim[20];
ll dfs(int pos, int pre, int cnt, bool limit) {
    if (pos == -1) return 1;
    if (!limit && dp[pos][pre][cnt] != -1) return dp[pos][pre][cnt];
    int End = limit ? a[pos] : 9;
    ll ans = 0;
    for (int i = 0; i <= End; i++) {
        if (i == pre) {
            if (cnt + 1 <= lim[i]) ans = (ans + dfs(pos-1, i, cnt+1, limit && (i == End))) % MOD;
        } else {
            if (1 <= lim[i]) ans = (ans + dfs(pos-1, i, 1, limit && (i == End))) % MOD;
        }
    }
    if (!limit) dp[pos][pre][cnt] = ans;
    return ans;
}
ll calc(ll x) {
    int pos = 0;
    if (x < 0) return 0;
    while (x) {
        a[pos++] = x % 10;
        x /= 10;
    }
    return dfs(pos-1, 0, 0, true);
}
void solve() {
    int T; cin >> T; while (T--) {
        ll n, m, q; cin >> n >> m >> q;
        memset(dp, -1, sizeof dp);
        memset(lim, 0x3f, sizeof lim);
        for (int i = 1; i <= q; i++) {
            int x, y; cin >> x >> y;
            lim[x] = min(lim[x], y);
        }
        cout << (calc(m) - calc(n-1) + MOD) % MOD << endl;
    }
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

进阶例题

萌数

存在回文数只要满足相邻两个相同或间隔一个数相同

#include <bits/stdc++.h>
using namespace std;
//#define ACM_LOCAL
#define fi first
#define se second
#define il inline
#define re register
const int N = 1e5 + 10;
const int M = 5e5 + 10;
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const int MOD = 1e9+7;
typedef long long ll;
typedef pair<int, int> PII;
typedef unsigned long long ull;
ll a[1005], dp[1005][20][20][2];
ll dfs(int pos, bool limit, bool lead1, bool lead2, int pre1, int pre2, bool flag) {
    if (pos == -1) return flag;
    if (!limit && !lead1 && !lead2 && dp[pos][pre1][pre2][flag] != -1) return dp[pos][pre1][pre2][flag];
    int End = limit ? a[pos] : 9;
    ll ans = 0;
    for (int i = 0; i <= End; i++) {
        if (!lead2) ans += dfs(pos-1, limit && i == End, lead1 && i == 0, lead1, i, pre1, flag || (i == pre2 || i == pre1));
        else if (!lead1) ans += dfs(pos-1, limit && i == End, lead1 && i == 0, lead1, i, pre1, flag || (i == pre1));
        else ans += dfs(pos-1, limit && i == End, lead1 && i == 0, lead1, i, pre1, flag);
        ans %= MOD;
    }
    if (!limit && !lead1 && !lead2) dp[pos][pre1][pre2][flag] = ans;
    return ans;
}
ll calc(string s) {
    for (int i = 0; i < s.size(); i++) a[i] = s[s.size() - i - 1] - '0';
    return dfs(s.size()-1, true, true, true, 0, 0, false);
}
bool judge(string s) {
    for (int i = 1; i < s.size(); i++) {
        if (s[i] == s[i-1]) return true;
        else if (i >= 2 && s[i] == s[i-2]) return true;
    }
    return false;
}
void solve() {
    memset(dp, -1, sizeof dp);
    string n, m; cin >> n >> m;
    printf("%lld\n", (calc(m) - calc(n) + judge(n) + MOD) % MOD);
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

[AHOI2009]同类分布

枚举数字和，用dig来存模上数字和之后的值，最后数字和和模数相同而且dig为0说明可以整除原数

#include <bits/stdc++.h>
using namespace std;
//#define ACM_LOCAL
#define fi first
#define se second
#define il inline
#define re register
const int N = 1e5 + 10;
const int M = 5e5 + 10;
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const int MOD = 1e9+7;
typedef long long ll;
typedef pair<int, int> PII;
typedef unsigned long long ull;
ll a[1005], dp[20][250][250];
ll dfs(int pos, int dig, bool limit, int sum, int mod) {
    if (pos == -1) return (sum == mod && dig == 0);
    if (!limit && dp[pos][dig][sum] != -1) return dp[pos][dig][sum];
    int End = limit ? a[pos] : 9;
    ll ans = 0;
    for (int i = 0; i <= End; i++) {
        ans += dfs(pos-1, (dig * 10 + i) % mod, limit && i == End, sum + i, mod);
    }
    if (!limit) dp[pos][dig][sum] = ans;
    return ans;
}
ll calc(ll x) {
    int pos = 0;
    while (x) {
        a[pos++] = x % 10;
        x /= 10;
    }
    ll ans = 0;
    for (int i = 1; i <= pos*9; i++) {
        memset(dp, -1, sizeof dp);
        ans += dfs(pos-1, 0, true, 0, i);
    }
    return ans;
}

void solve() {
    ll n, m; cin >> n >> m;
    printf("%lld\n", calc(m) - calc(n-1));
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

Sum-of-Log

i&j = 0可以推出i和j在二进制相同位上只有一个为1，log2(i+j)+1表示一个数二进制的最高位数，因此枚举最高位找出所有满足i&j=0的个数乘上位数即可

#include <bits/stdc++.h>
using namespace std;
//#define ACM_LOCAL
#define fi first
#define se second
#define il inline
#define re register
const int N = 1e5 + 10;
const int M = 5e5 + 10;
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const int MOD = 1e9+7;
typedef long long ll;
typedef pair<int, int> PII;
typedef unsigned long long ull;
ll a[50], b[50], dp[50][2][2];
ll dfs(int pos, bool limit1, bool limit2) {
    if (pos == -1) return 1;
    if (dp[pos][limit1][limit2] != -1) return dp[pos][limit1][limit2];
    int up1 = limit1 ? a[pos] : 1, up2 = limit2 ? b[pos] : 1;
    ll ans = 0;
    for (int i = 0; i <= up1; i++) {
        for (int j = 0; j <= up2; j++) {
            if (i && j) continue;
            ans += dfs(pos-1, limit1 && i == up1, limit2 && j == up2);
            ans %= MOD;
        }
    }
    dp[pos][limit1][limit2] = ans;
    return ans;
}
ll calc(ll x, ll y) {
    memset(dp, -1, sizeof dp);
    memset(a, 0, sizeof a);
    memset(b, 0, sizeof b);
    int pos1 = 0, pos2 = 0;
    while (x) {
        a[pos1++] = x % 2;
        x /= 2;
    }
    while (y) {
        b[pos2++] = y % 2;
        y /= 2;
    }
    ll ans = 0;
    for (int i = 0; i < max(pos1, pos2); i++) {
        ll res = 0;
        if (i < pos1) res += dfs(i-1, i == pos1-1, i >= pos2);//x的i位为1，y的i位为0
        if (i < pos2) res += dfs(i-1, i >= pos1, i == pos2-1);//x的i位为0，y的i位为1
        res %= MOD;
        ans = (ans + 1ll*(i+1) * res % MOD) % MOD;
    }
    return ans;
}

void solve() {
    int T; cin >> T; while (T--) {
        ll n, m; cin >> n >> m;
        printf("%lld\n", calc(n, m));
    }
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}
kaka0010
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
蓝桥杯刷题总结-合集(持续更新)
Destiny_159的博客
12-08 2279
蓝桥杯刷题总结 待办： 0. 刷题前须知 1. 递归与递推 2. 二分 3. 前缀和 4. 数学 5. 枚举 6. 模拟 7. 排序 8. 双指针 9. BFS 10. 图论 11. 树状数组 12. 线段树 13. 贪心 14. 数论 15. 简单DP 16. 复杂DP 17. 杂题 18. 十一届蓝桥杯真题 19. 十二届蓝桥杯真题 BaseOn ： https://www.acwing.com 0、刷提前的须知 1、输入 in.next()和in.ne
dp动态规划刷题总结
weixin_45743707的博客
10-16 694
背包问题 01背包 采药 辰辰是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。 为此，他想拜附近最有威望的医师为师。 医师为了判断他的资质，给他出了一个难题。 医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。” 如果你是辰辰，你能完成这个任务吗？ 输入格式 输入文件的第一行有两个整数T和M，用一个空格隔开，T代表
数位DP题集
weixin_43353639的博客
03-15 132
1.D. Beautiful numbers 这题总结一下就是状态的压缩,容易知道如果不经过压缩,那么DP状态数会非常多,我们需要将无限的状态压缩成有限的状态,这样可以同时降低时间和空间复杂度,比如这题就将1~9中任意个数的lcm取出来,共计49个状态,最大lcm为5x7x8x9=2520,共计2520个模数. 所以dp状态会被压缩为dp[20][49][2520],时间复杂度同状态一致。 传送门 #include <bits/stdc++.h> using namespace std; usi
【数位DP——题集及提示】
..
04-28 1214
4207 -- 【模拟试题】不要62    最简单数位DP 不解释 4600 -- 【模拟试题】迷信的黄学长   挺坑！注意有正反向两种连续，传递序列里是否有2,4这两个参数，另外还要传有没有连续，所以DFS到下一层时要写作  Is_four||i==4;   Is_two||i==8;    Is_continuous||((i==pre+2&&i==last+1)||(pre
数位dp入门刷题记录
蒲公英殇的博客
10-01 171
记录一些数位dp的入门题，dp种类之一
01背包（降维 + 常数级优化）
weixin_34279246的博客
07-15 1113
题目：共n个物体，第i个重量为w[i]，价值v[i]，背包最多能背不超过W的物体，求最大的价值分析：每个物体只有一个，在容量允许时（W>w[i]），则对于每个物体只有取、不取两种选择状态：dp[i][j]：前i个物体，在容量为j的时候，最大的价值状态转移：dp[i][j]=max(dp[i-1][j],dp[i-1]...
数位DP 题集
671coder的专栏
06-17 9160
数位DP 题集 /*-------------------------------------------------------------------------*/ 常用数位DP写法： int dfs(int i, int s, bool e) { if(i==-1) return s==target_s; if(!e && ~f[i][s]) re
[宫水三叶的刷题日记]：数位DP1
08-03
本文将围绕LeetCode上的600题——不含连续1的非负整数，深入探讨数位DP的应用及其解题策略。 首先，数位DP问题的核心在于对每个数字位进行独立处理，并通过构建状态转移方程来解决复杂的问题。在本题中，目标是找到...
[宫水三叶的刷题日记]：状压 DP1
08-03
在状态压缩DP中，用一个二进制数表示已选择的数字，通过位运算快速检查和更新状态。例如，(000...0101)2 表示选择了1和3，未选择2。在转移过程中，我们需要定义f[i][state]表示考虑前i个数且当前选择方案为state时的...
Leetcode刷题笔记-大厂面试突破集
最新发布
08-15
1012题《至少有1位重复的数字》则用通用数位DP求解；1044题《最长重复子串》结合了字符串哈希和二分查找；1206题《设计跳表》则是数据结构实现题，涉及到高效查找和插入的问题。 双指针技巧在许多题目中都有应用，...
C++中memset()函数的用法详解
热门推荐
lyj2014211626的博客
03-23 9万+
头文件：cstring 或 memory 话说刚开始使用memset的时候一直以为memset是对每一个int赋值的，心里想有了memset还要for循环对数组进行初始化干嘛。但其实memset这个函数的作用是将数字以单个字节逐个拷贝的方式放到指定的内存中去 memset(dp,0,sizeof(dp)); int类型的变量一般占用4个字节，对每一个字节赋值0的话就变成了
memset()函数初始化问题
SYITwin的博客
05-29 4517
总来源:点击打开链接话说刚开始使用memset的时候一直以为memset是对每一个int赋值的，心里想有了memset还要for循环对数组进行初始化干嘛。但其实memset这个函数的作用是将数字以单个字节逐个拷贝的方式放到指定的内存中去 memset(dp,0,sizeof(dp)); int类型的变量一般占用4个字节，对每一个字节赋值0的话就变成了“00000000 00000000 000...
【hdu3652】数位dp（浅尝ACM-A)
LinnBlanc的博客
07-05 506
向大佬学习第一次写博客有点紧张，也算是小萌新的突破吧 这次主要是总结一下校内的ACM比赛的各种题，主要是新思路以及学到的新知识先放一张 下面开始说正事 题面 A wqb-number, or B-number for short, is a non-negative integer whose decimal form contains the sub- string “13” and
学习总结：区间dp
weixin_51777520的博客
04-24 261
这几天在做有关区间dp的题，在学习中，现在先总结一下，之后就只能靠刷题了。 概念 这里先复述一下区间dp的概念： 同样是求最优解的问题，区间dp就是在区间上进行动态规划，我们可以把大区间转化成小区间来处理，然后合并小区间的 最优解进而得出整个大区间上最优解。主要的方法有两种，记忆化搜索和递推。 一般区间DP实现代码 区间dp的格式一般相差不大： memset(dp, 0x3f, sizeof(dp)); for (int i = 1; i <= n; i++） //区间长度为1的初始化 dp[i][i
Day1(DP)
weixin_30270889的博客
01-01 212
http://codeforces.com/contest/1091/problem/D 题目大意： n个数的全排列按顺序写出来，求为连续n个数且和为n(n+1)/2的子串个数 思路： 对于分别在两个排列中的连续n个数 设其前a个数为前一个排列的末尾a个数，s，后(n-a)个数为后一个排列的开头(n-a)个数 需要满足这两组数无交集 又因为排列按字典序，后一个排列为前一个排列字...
【Weiler-Atherton算法】 计算机图形学多边形裁剪算法
kaka03200的博客
11-16 7246
目录什么是多边形裁剪前置知识算法步骤程序框图代码实现 什么是多边形裁剪 通常来说就是利用多边形来裁剪多边形的一种方法，一般情况下是利用矩形来裁剪凹凸多边形 凸多边形 凹多边形 上面红色划线部分就是裁剪出的部分 前置知识 OPENGL基础语法 基本上就是一些画线和画多边形的操作，难度较低 求两直线交点 较为基础的数学知识 求一个点是否落在多边形内/外 计算几何知识 Weiler-Atherton多边形裁剪算法 这里着重介绍Weiler-Atherton算法，其余不懂的可以先学会再看。 算法步骤
【退役贴】再见了ACM，再会了算法竞赛
kaka03200的博客
04-18 3732
目录写在前面心里话ACM是什么回顾省赛&昆明收获付出选择ACM竞赛的原因对一些ACMer的话 写在前面 心里话 2022ICPC昆明站告一段落，随之结束的是我两年多的ACM生涯。时间真的过得飞快，一个手里拿着蓝皮书一看就是一天的小孩子现在已经惘然地看着未来，从踌躇满志到脚踏实地，也只需要两年的光阴。非常遗憾再一次与银奖失之交臂。但更遗憾的莫过于疫情之下的比赛环境，线下比赛基本上全部取消改为线上，在2020~2022里我打了十来场正式赛，但只有一场在线下举办。除开遗憾，ACM带给我太多课堂上无法获得的
计算机网络实验期末复习（已完结）
kaka03200的博客
12-23 3357
目录实验1 传输介质实验2 DHCP实验3 DNS实验4 HTTP实验5 交换机基本配置实验6 交换机工作原理实验7 交换机Vlan实验9 静态路由 实验1 传输介质 有线传输介质： 双绞线 光纤 同轴电缆 无限传播介质 无线电波 红外线 双绞线制作标准： 568A 标准 白绿|绿|白橙|蓝|白蓝|橙|白粽|棕 568B 标准 白橙|橙|白绿|蓝|白蓝|绿|白粽|棕 直连线：两端都是568A或568B 交叉线：一端是568A，一端是568B 两台相同设备之前通讯通常用交叉线，两台不同设备之前通讯
计算机网络期末复习（已完结）
kaka03200的博客
12-29 2114
目录第一章 概述1.1 计算机网络在信息时代的作用1.2 互联网概述1.3 互联网的组成1.5 计算机网络的类别1.5.2几种不同类别的计算机网络1.6 计算机网络的性能1.6.1 计算机网络的性能指标1.6.2 计算机网络的非性能特征1.7 计算机网络体系结构1.7.2 协议与划分层次1.7.3 具有五层协议的体系结构1.7.4 实体、协议、服务和服务访问点第二章 物理层2.1 物理层的基本概念2.2 数据通信的基础知识2.2.1数据通信的基础知识2.2.2 有关信道的基本概念2.2.3 信道的极限容量2
数位类统计问题与数位DP解析
在数位DP中，关键在于理解数的每一位是如何影响整体数值的。例如，一个数n的最高位小于n，而其他低位不受此限制。这种性质使得我们可以从高位向低位逐步确定数的每一位，同时通过预处理来加速计算。 预处理通常涉及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值