首页 > 其他分享 >PAM

PAM

时间：2024-03-21 21:12:55浏览次数：12  
标签：nxt int tot len fail now PAM

F-[APIO2014]回文串

 一个板子题， 维护一下每个节点出现次数，倒着把次数往 fail 上推， 长度可以直接维护

#include<bits/stdc++.h>
using namespace std;
#define endl "\n"
#define int long long
typedef long long ll;

const int N = 3e5 + 100;
struct Palindromic_AutoMaton {
    //basic
    int s[N], now;
    int nxt[N][26], fail[N], len[N], last, tot;
    // extension
    int num[N];/*节点代表的所有回文串出现次数*/
    void clear() {
        // 1节点 ： 奇数长度 root 
        // 0节点 ： 偶数长度 root
        s[0] = len[1] = -1;
        fail[0] = tot = now = 1;
        last = len[0] = 0;
        memset(nxt[0], 0, sizeof nxt[0]);
        memset(nxt[1], 0, sizeof nxt[1]);
    }
    Palindromic_AutoMaton() {clear();}
    // 建一个新节点, 长度为 nowlen
    int newnode(int nowlen) {
        tot++;
        memset(nxt[tot], 0, sizeof nxt[tot]);
        fail[tot] = num[tot] = 0;
        len[tot] = nowlen;
        return tot;
    }
    // 找后缀回文
    int get_fail(int x) {
        // now - 1 是当前节点
        // x 是 s 串中 now - 1 的前一个节点
        // 设当前节点为 p, 那么 s[p] 对称节点就是 s[p - len[x] - 1]
        // check 出最长回文后缀
        while (s[now - len[x] - 2] != s[now - 1]) x = fail[x];
        return x;
    }
    void add(int ch) {
        s[now++] = ch;
        int cur = get_fail(last);
        if (!nxt[cur][ch]) {
            int tt = newnode(len[cur] + 2);
            fail[tt] = nxt[get_fail(fail[cur])][ch];
            nxt[cur][ch] = tt;
        }
        last = nxt[cur][ch]; num[last]++;
    }
    void build() {
        //fail[i] < i，拓扑更新可以单调扫描。
        for (int i = tot; i >= 2; i--) {
            num[fail[i]] += num[i];
        }
        num[0] = num[1] = 0;
    }
    void init(char* ss) {
        while (*ss) {
            add(*ss - 'a'); ss++;
        }
    }
    void init(string str) {
        for (int i = 0; i < str.size(); i++) {
            add(str[i] - 'a');
        }
    }
    void query() {
        int ans = 1;
        for (int i = 2; i <= tot; i++) ans = max(ans, len[i] * num[i]);
        cout << ans << endl;
    }
} PAM;

char s[N];

void solve() {
    int n; cin >> n;
    cin >> s;
    PAM.init(s);
    PAM.build();
    PAM.query();
}

signed main() {
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    solve();
    return 0;
}
View Code

G-Colorful String

 板子题，开个桶维护一下每个节点字母出现情况就行

#include<bits/stdc++.h>
using namespace std;
#define endl "\n"
#define int long long
typedef long long ll;

const int N = 3e5 + 100;
struct Palindromic_AutoMaton {
    //basic
    int s[N], now;
    int nxt[N][26], fail[N], len[N], last, tot;
    // extension
    int num[N][26], cnt[N];
    void clear() {
        // 1节点 ： 奇数长度 root 
        // 0节点 ： 偶数长度 root
        s[0] = len[1] = -1;
        fail[0] = tot = now = 1;
        last = len[0] = 0;
        memset(nxt[0], 0, sizeof nxt[0]);
        memset(nxt[1], 0, sizeof nxt[1]);
    }
    Palindromic_AutoMaton() {clear();}
    // 建一个新节点, 长度为 nowlen
    int newnode(int nowlen) {
        tot++;
        memset(nxt[tot], 0, sizeof nxt[tot]);
        fail[tot] = 0;
        len[tot] = nowlen;
        return tot;
    }
    // 找后缀回文
    int get_fail(int x) {
        // now - 1 是当前节点
        // x 是 s 串中 now - 1 的前一个节点
        // 设当前节点为 p, 那么 s[p] 对称节点就是 s[p - len[x] - 1]
        // check 出最长回文后缀
        while (s[now - len[x] - 2] != s[now - 1]) x = fail[x];
        return x;
    }
    void add(int ch) {
        s[now++] = ch;
        int cur = get_fail(last);
        if (!nxt[cur][ch]) {
            int tt = newnode(len[cur] + 2);
            fail[tt] = nxt[get_fail(fail[cur])][ch];
            nxt[cur][ch] = tt;
            for (int i = 0; i < 26; i++) num[tt][i] = num[cur][i];
            num[tt][ch] = 1;
        }
        last = nxt[cur][ch]; cnt[last]++;
    }
    void build() {
        //fail[i] < i，拓扑更新可以单调扫描。
        for (int i = tot; i >= 2; i--) cnt[fail[i]] += cnt[i];
        cnt[1] = cnt[0] = 1;
        int ans = 0;
        for (int i = tot; i >= 2; i--) {
            int sum = 0;
            for (int j = 0; j < 26; j++) {
                if (num[i][j]) sum++;
            }
            ans += sum * cnt[i];
        }
        cout << ans << endl;
    }
    void init(char* ss) {
        while (*ss) {
            add(*ss - 'a'); ss++;
        }
    }
    void init(string str) {
        for (int i = 0; i < str.size(); i++) {
            add(str[i] - 'a');
        }
    }
} PAM;

void solve() {
    string s; cin >> s;
    PAM.init(s); PAM.build();
}

signed main() {
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    solve();
    return 0;
}
View Code

 

 

P4287 [SHOI2011] 双倍回文

引入了 trans 数组概念， trans 指针指向不超过回文串长度一半的最长回文后缀节点

我们对于每个节点检查是否长度为偶数，trans是否刚好是当前节点代表字符串长度一半

#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define int long long

const int N = 5e5 + 100;
struct Palindromic_AutoMaton {
    //basic
    int s[N], now;
    int nxt[N][26], fail[N], len[N], tran[N], last, tot;
    // extension
    int num[N];/*节点代表的所有回文串出现次数*/
    void clear() {
        // 1节点 ： 奇数长度 root 
        // 0节点 ： 偶数长度 root
        s[0] = len[1] = -1;
        fail[0] = tot = now = 1;
        last = len[0] = 0;
        memset(nxt[0], 0, sizeof nxt[0]);
        memset(nxt[1], 0, sizeof nxt[1]);
    }
    Palindromic_AutoMaton() {clear();}
    // 建一个新节点, 长度为 nowlen
    int newnode(int nowlen) {
        tot++;
        memset(nxt[tot], 0, sizeof nxt[tot]);
        fail[tot] = num[tot] = 0;
        len[tot] = nowlen;
        return tot;
    }
    // 找后缀回文
    int get_fail(int x) {
        // now - 1 是当前节点
        // x 是 s 串中 now - 1 的前一个节点
        // 设当前节点为 p, 那么 s[p] 对称节点就是 s[p - len[x] - 1]
        // check 出最长回文后缀
        while (s[now - len[x] - 2] != s[now - 1]) x = fail[x];
        return x;
    }
    // tran 指针指向不超过回文串长度一半的最长回文后缀节点
    void trans(int x, int y, int pos, int ch) {
        if (len[x] <= 2) tran[x] = fail[x];
        else {
            int t = tran[y];
            while (s[pos - 1 - len[t]] != s[pos] || (len[t] + 2) * 2 > len[x]) t = fail[t]; 
            tran[x] = nxt[t][ch];
        }
    }
    void add(int ch, int pos) {
        s[now++] = ch;
        int cur = get_fail(last);
        if (!nxt[cur][ch]) {
            int tt = newnode(len[cur] + 2);
            fail[tt] = nxt[get_fail(fail[cur])][ch];
            nxt[cur][ch] = tt;
            trans(tt, cur, pos, ch);
        }
        last = nxt[cur][ch];
    }
    void build() {
        //fail[i] < i，拓扑更新可以单调扫描。
        for (int i = tot; i >= 2; i--) {
            num[fail[i]] += num[i];
        }
        num[0] = num[1] = 0;
    }
    void init(char* str, int n) {
        for (int i = 1; i <= n; i++) add(str[i] - 'a', i);
    }
    void init(string str, int n) {
        for (int i = 1; i <= n; i++) {
            add(str[i] - 'a', i);
        }
    }
    // 拓扑遍历trie树
    void topo() {
        queue<int> q;
        for (int i = 0; i < 26; i++) {
            // 长度为奇数的
            if (nxt[1][i]) q.push(nxt[1][i]);
            // 长度为偶数的
            if (nxt[0][i]) q.push(nxt[0][i]);
        }
        while (!q.empty()) {
            int x = q.front(); q.pop();
            for (int i = 0; i < 26; i++) {
                int y = nxt[x][i];
                if (!y) continue;
                q.push(y);
            }
        }
    }
    void query() {
        int ans = 0;
        for (int i = 2; i <= tot; i++) {
            int x = tran[i];
            if (len[x] % 2 == 0 && len[i] == len[x] * 2) ans = max(ans, len[i]);
        }
        cout << ans << endl;
    }
} PAM;

char s[N];

void solve() {
    int n; cin >> n;    
    cin >> (s + 1);
    // string s; cin >> s;
    // int n = s.size();
    // s = " " + s;
    PAM.init(s, n);
    PAM.query();
}

signed main() {
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    // int T; cin >> T;
    // while (T--) solve();
    solve();
    return 0;  
}
View Code

P4762 [CERC2014] Virus synthesis

做法是利用 trans 数组性质进行 dp

 

 显然这个串会是一个回文串 + 左右两边加一些字符形式，转移大概这样（洛谷题解上的）

 

#include<bits/stdc++.h>
using namespace std;
#define endl "\n"
#define int long long
typedef long long ll;

const int N = 1e5 + 100;

int f[N];
map<char, int> mp;

struct Palindromic_AutoMaton {
    //basic
    int s[N], now;
    int nxt[N][5], fail[N], len[N], last, tot;
    // extension
    int tran[N];
    void clear() {
        // 1节点 ： 奇数长度 root 
        // 0节点 ： 偶数长度 root
        s[0] = len[1] = -1;
        fail[0] = tot = now = 1;
        last = len[0] = 0;
        memset(nxt[0], 0, sizeof nxt[0]);
        memset(nxt[1], 0, sizeof nxt[1]);
    }
    Palindromic_AutoMaton() {clear();}
    // 建一个新节点, 长度为 nowlen
    int newnode(int nowlen) {
        tot++;
        memset(nxt[tot], 0, sizeof nxt[tot]);
        fail[tot] = 0;
        len[tot] = nowlen;
        return tot;
    }
    // 找后缀回文
    int get_fail(int x) {
        // now - 1 是当前节点
        // x 是 s 串中 now - 1 的前一个节点
        // 设当前节点为 p, 那么 s[p] 对称节点就是 s[p - len[x] - 1]
        // check 出最长回文后缀
        while (s[now - len[x] - 2] != s[now - 1]) x = fail[x];
        return x;
    }
    // tran 指针指向不超过回文串长度一半的最长回文后缀节点
    void trans(int x, int y, int pos, int ch) {
        if (len[x] <= 2) tran[x] = fail[x];
        else {
            int t = tran[y];
            while (s[pos - 1 - len[t]] != s[pos] || (len[t] + 2) * 2 > len[x]) t = fail[t]; 
            tran[x] = nxt[t][ch];
        }
    }
    void add(int ch, int pos) {
        s[now++] = ch;
        int cur = get_fail(last);
        if (!nxt[cur][ch]) {
            int tt = newnode(len[cur] + 2);
            fail[tt] = nxt[get_fail(fail[cur])][ch];
            nxt[cur][ch] = tt;
            trans(tt, cur, pos, ch);
        }
        last = nxt[cur][ch];
    }
    void build(int n) {
        //fail[i] < i，拓扑更新可以单调扫描。
        for (int i = 2; i <= tot; i++) f[i] = len[i];
        queue<int> q;
        int ans = n;
        for (int i = 1; i <= 4; i++) {
            if (nxt[0][i]) q.push(nxt[0][i]);
        }
        while (!q.empty()) {
            int x = q.front(); q.pop();
            f[x] = min(f[x], len[x] / 2 - len[tran[x]] + f[tran[x]] + 1);
            ans = min(ans, f[x] + n - len[x]);
            for (int i = 1; i <= 4; i++) {
                int y = nxt[x][i];
                if (!y) continue;
                f[y] = min(f[y], f[x] + 1);
                q.push(y);
            }
        }
        cout << ans << endl;
    }
    void init(string str, int n) {
        for (int i = 1; i <= n; i++) {
            add(mp[str[i]], i);
        }
    }
    void init(char* ss, int n) {
        for (int i = 1; i <= n; i++) add(mp[ss[i]], i);
    }
} PAM;

void solve() {
    string s; cin >> s;
    int n = s.size();
    s = " " + s;
    mp['A'] = 1; mp['T'] = 2; mp['C'] = 3; mp['G'] = 4;
    PAM.clear();
    PAM.init(s, n); PAM.build(n);
}

signed main() {
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    int T; cin >> T;
    while (T--) solve();
    return 0;
}
View Code

 

 

P5555 秩序魔咒

简化下题意大概就是给你两个字符串，找出两字符串所有公共回文字符串中的最大长度， 以及有多少种公共回文串是最大长度

这种题有两种做法一种是建一个 PAM，开两个数组表示第一个串中是否有这个节点，另外一个就是表示第二个串是否有这个节点

第一个串加完节点后我们把 PAM 中的 now 清空即可， 代码比较详细

第二种做法就是我们建两个 PAM，一起去跑 dfs，当两串都有某个节点就继续 dfs，有个细节是要dfs 0 ， 1两个节点，因为 PAM 有两个根

这里给出第一种做法代码

#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define int long long

const int N = 6e6 + 100;

int ans, res, vis[N][2];

// 有点逆天， 为什么空间要开十倍?
// 对于两个串之间的连接，并不需要真的去加一个点（虽然不知道为什么真的加只能拿95分）
// 我们在第一个串 add 完以后把 now clear一下就行， 因为 now 是 PAM 存当前串的状态的指针
// 我们把它设置为 1 就相当于清空了板子中 s，getfail就不会是找到两串连接得到的串上面去

struct Palindromic_AutoMaton {
    //basic
    int s[N], now;
    int nxt[N][30], fail[N], len[N], last, tot;
    void clear() {
        // 1节点 ： 奇数长度 root 
        // 0节点 ： 偶数长度 root
        s[0] = len[1] = -1;
        fail[0] = tot = now = 1;
        last = len[0] = 0;
        memset(nxt[0], 0, sizeof nxt[0]);
        memset(nxt[1], 0, sizeof nxt[1]);
    }
    Palindromic_AutoMaton() {clear();}
    // 建一个新节点, 长度为 nowlen
    int newnode(int nowlen) {
        tot++;
        memset(nxt[tot], 0, sizeof nxt[tot]);
        fail[tot] = 0;
        len[tot] = nowlen;
        return tot;
    }
    // 找后缀回文
    int get_fail(int x) {
        // now - 1 是当前节点
        // x 是 s 串中 now - 1 的前一个节点
        // 设当前节点为 p, 那么 s[p] 对称节点就是 s[p - len[x] - 1]
        // check 出最长回文后缀
        while (s[now - len[x] - 2] != s[now - 1]) x = fail[x];
        return x;
    }
    void add(int ch, int op) {
        s[now++] = ch;
        int cur = get_fail(last);
        if (!nxt[cur][ch]) {
            int tt = newnode(len[cur] + 2);
            fail[tt] = nxt[get_fail(fail[cur])][ch];
            nxt[cur][ch] = tt;
        }
        last = nxt[cur][ch];
        vis[last][op] = 1;
    }
} PAM;

char s1[N], s2[N];

void solve() {
    PAM.clear();
    int n, m; cin >> n >> m;
    ans = res = 0;
    cin >> s1 >> s2;
    for (int i = 0; i < n; i++) {
        PAM.add(s1[i] - 'a', 0);
    }
    // PAM.add(29, 0);
    PAM.now = 1;
    for (int i = 0; i < m; i++) {
        PAM.add(s2[i] - 'a', 1);
    }
    auto &len = PAM.len;
    for (int i = 0; i <= PAM.tot; i++) {
        if (vis[i][0] && vis[i][1]) {
            if (len[i] > ans) ans = len[i], res = 1;
            else if (len[i] == ans) res++;
        }
    }
    cout << ans << ' ' << res << endl;
}

signed main() {
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    // int T; cin >> T;
    // while (T--) solve();
    solve();
    return 0;  
}
View Code

P5685 [JSOI2013] 快乐的 JYY

和上题基本一致，改变一下贡献计算方式即可

这里我用第一种做法不知道为什么一直过不了，改成第二种做法才能通过，所以给出第二种做法代码

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"

const int N = 5e6 + 100;

struct Palindromic_AutoMaton {
    //basic
    int s[N], now;
    int nxt[N][30], fail[N], len[N], tran[N], last, tot;
    // extension
    int num[N];/*节点代表的所有回文串出现次数*/
    void clear() {
        // 1节点 ： 奇数长度 root 
        // 0节点 ： 偶数长度 root
        s[0] = len[1] = -1;
        fail[0] = tot = now = 1;
        last = len[0] = 0;
        memset(nxt[0], 0, sizeof nxt[0]);
        memset(nxt[1], 0, sizeof nxt[1]);
    }
    Palindromic_AutoMaton() {clear();}
    // 建一个新节点, 长度为 nowlen
    int newnode(int nowlen) {
        tot++;
        memset(nxt[tot], 0, sizeof nxt[tot]);
        fail[tot] = num[tot] = 0;
        len[tot] = nowlen;
        return tot;
    }
    // 找后缀回文
    int get_fail(int x) {
        // now - 1 是当前节点
        // x 是 s 串中 now - 1 的前一个节点
        // 设当前节点为 p, 那么 s[p] 对称节点就是 s[p - len[x] - 1]
        // check 出最长回文后缀
        while (s[now - len[x] - 2] != s[now - 1]) x = fail[x];
        return x;
    }
    // tran 指针指向不超过回文串长度一半的最长回文后缀节点
    void trans(int x, int y, int pos, int ch) {
        if (len[x] <= 2) tran[x] = fail[x];
        else {
            int t = tran[y];
            while (s[pos - 1 - len[t]] != s[pos] || (len[t] + 2) * 2 > len[x]) t = fail[t]; 
            tran[x] = nxt[t][ch];
        }
    }

    void build() {
        for (int i = tot; i >= 2; i--) {
            num[fail[i]] += num[i];
        }
        num[0] = num[1] = 0;
    }

    void add(int ch, int pos, int op) {
        s[now++] = ch;
        int cur = get_fail(last);
        if (!nxt[cur][ch]) {
            int tt = newnode(len[cur] + 2);
            fail[tt] = nxt[get_fail(fail[cur])][ch];
            nxt[cur][ch] = tt;
            trans(tt, cur, pos, ch);
        }
        last = nxt[cur][ch];
        num[last]++;
    }
    void init(char* str, int n, int op) {
        for (int i = 1; i <= n; i++) add(str[i] - 'A', i, op);
    }
    // 拓扑遍历trie树
    void topo() {
        queue<int> q;
        for (int i = 0; i < 26; i++) {
            // 长度为奇数的
            if (nxt[1][i]) q.push(nxt[1][i]);
            // 长度为偶数的
            if (nxt[0][i]) q.push(nxt[0][i]);
        }
        while (!q.empty()) {
            int x = q.front( ); q.pop();
            for (int i = 0; i < 26; i++) {
                int y = nxt[x][i];
                if (!y) continue;
                q.push(y);
            }
        }
    }
} P1, P2;

char s1[N], s2[N];

int ans;
void dfs(int x, int y) {
    ans += P1.num[x] * P2.num[y];
    for (int i = 0; i < 26; i++) {
        if (P1.nxt[x][i] && P2.nxt[y][i]) dfs(P1.nxt[x][i], P2.nxt[y][i]);
    }
}

void solve() {
    cin >> (s1 + 1) >> (s2 + 1);
    int n = strlen(s1 + 1), m = strlen(s2 + 1);
    for (int i = 1; i <= n; i++) P1.add(s1[i] - 'A', i, 0);
    P1.build();
    for (int i = 1; i <= m; i++) P2.add(s2[i] - 'A', i, 1);
    P2.build();
    dfs(0, 0); dfs(1, 1);
    cout << ans << endl;
}

signed main() {
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    solve();
    return 0;
}
View Code

 

标签：nxt,int,tot,len,fail,now,PAM
From： https://www.cnblogs.com/zhujio/p/18071421

相关文章

  • kylin v10报错：/usr/lib64/security/pam_console.so: cannot open
    报错如下：PAMunabletodlopen(/usr/lib64/security/pam_console.so):/usr/lib64/security/pam_console.so:cannotopenshaaredobjectfile:No>PAMaddmingfaultymodule:/usr/lib64/security/pam_console.so原因分析：麒麟V10环境没有“pam_console.so”动态库。pam_......
  • 问题记录——/etc/pam.d/common-auth 修改后无法登录服务器系统（SuSE 12 SP5）
    背景：公司三级等保问题整改，要求配置登录失败处理功能，服务器系统为suse12SP5，配置方法如下：在/etc/pam.d/common-auth中配置相关参数策略：authrequiredpam_tally2.so onerr=faildeny=5unlock_time=300even_deny_rootroot_unlock_time=10配置连续登录失败5次，普通账户锁定300......
  • R语言Kmeans聚类、PAM、DBSCAN、AGNES、FDP、PSO粒子群聚类分析iris数据结果可视化比
    全文链接：http://tecdat.cn/?p=32007原文出处：拓端数据部落公众号本文以iris数据和模拟数据为例，帮助客户了比较R语言Kmeans聚类算法、PAM聚类算法、DBSCAN聚类算法、AGNES聚类算法、FDP聚类算法、PSO粒子群聚类算法在iris数据结果可视化分析中的优缺点。结果：聚类算法的聚类结......
  • 第十六天： 利用 sudo 实现授权、PAM、时间同步
    一、sudo组成sudo即superuserdo，允许系统管理员让普通用户执行一些或者全部的root命令的一个工具，如halt，reboot，su等等。这样不仅减少了root用户的登录和管理时间，同样也提高了安全性sudo特性：sudo能够授权指定用户在指定主机上运行某些命令。如果未授权用户尝试使用sudo，会提......
  • 基于温敏性PNIPAm水凝胶体系的构筑及其智能窗应用研究
    HS-DSC-101A差示扫描量热仪是一种测量参比端与样品端的热流差与温度参数关系的热分析仪器，主要应用于测量物质加热或冷却过程中的各种特征参数：玻璃化转变温度Tg、氧化诱导期OIT、熔融温度、结晶温度、比热容及热焓等。改性石墨烯增强有机硅涂层及其性能研究【齐鲁工业大学姚凯】基......
  • PAM：完善的第三方应用
    现如今企业在规划上架新的服务平台时，有很多的顾虑，是否影响现在的稳定环境？是否会给因为人员带来更多运维的不便利等等，归根结底就一点：新管理平台上线时是否会影响现行业务流程的流畅性？部署成本是否太大？特权账号管理系统简单方便的旁路部署方式让企业可以不改变当前的网络环境，在部署成......
  • 简介PAM的认证过程及各PAM文件的作用
    MySQL用户运行MySQL服务时最大能打开的文件数，是由limits.conf文件和pam_limits.so模块共同决定的。pam_limits.so模块是一个PAM（插入式认证模块）的组件，它可以在用户登录时设置一些资源限制，例如打开文件数、内存使用量、进程数等。limits.conf文件是pam_limits.so模块的配置文件，它定......
  • 浅聊PAM市场价值
    随着全球数字化蓬勃发展，云计算、人工智能、大数据、5G等技术的应用范围不断扩大，在企业运用新技术提高自身效率的同时也面临着更多由新技术诱发的网络威胁，全球网络威胁形势愈发严峻。网络入侵行为日趋复杂，构建全面的安全防护体系、制定完善的安全管理策略、提供整体网络安全解决方案......
  • docker部署phpIPAM
    0说明IPAM：IP地址管理系统IP地址管理(IPAM)是指的一种方法IP扫描，IP地址跟踪和管理与网络相关的信息的互联网协议地址空间和IPAM系统。IPAM软件和IP的工具,管理员可以确保分配IP地址仍然是当前和足够的库存先进的IP工具和IPAM服务。IPAM简化并自动化管理的许多任务参与IP空间管......
  • PAM咨询——还是得靠自己
    %定义参数M=2;%定义为M元调制Rs=1000;%定义波特率Rb=Rs*log2(M);%计算比特率Ts=1/Rs;%计算符号发送间隔sample_rate=100*Rs;%采样率EbN0=0:15;%传送每个比特所用能量平均值/噪声单边功率谱密度（单位：dB）%生成随机比特序列num_bits=100000;%比特......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99