GP of China H Inner Product: 边分治 + 虚树dp

最新推荐文章于 2023-03-24 15:47:16 发布
最新推荐文章于 2023-03-24 15:47:16 发布
阅读量335 收藏
点赞数
分类专栏： 专题练习 文章标签： 边分治 GP of China
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/calabash_boy/article/details/102577347
版权

题意

给出两棵树 T T T和 T ′ T' T′，求
∑ i , j ∈ [ 1 , n ] d i s ( i , j ) ∗ d i s ′ ( i , j ) \sum_{i,j \in [1,n]}{dis(i,j) * dis'(i,j)} i,j∈[1,n]∑​dis(i,j)∗dis′(i,j)

题解

对 T T T进行边分治，当前分治的边为 < u , v > <u,v> <u,v>，边权为 w w w时，设 u u u一侧的点集为 L L L， v v v一侧的点集是 R R R，则经过当前边的 d i s ( i , j ) dis(i,j) dis(i,j)对答案的贡献是：
A N S = ∑ i ∈ L , j ∈ R ( d i s ( i , u ) + d i s ( j , v ) + w ) ⋅ d i s ′ ( i , j ) = ∑ i ∈ L , j ∈ R ( d i s [ i ] + d i s [ j ] ) ⋅ d i s ′ ( i , j ) + w ⋅ ∑ i ∈ L , j ∈ R d i s ′ ( i , j ) = ∑ i ∈ L , j ∈ R ( d i s [ i ] + d i s [ j ] ) ⋅ ( d e p ′ [ i ] + d e p ′ [ j ] − 2 ⋅ d e p ′ [ l c a ′ ( i , j ) ] ) + w ⋅ ∑ i ∈ L , j ∈ R d i s ′ ( i , j ) = ∑ i ∈ L , j ∈ R ( d i s [ i ] + d i s [ j ] ) ⋅ ( d e p ′ [ i ] + d e p ′ [ j ] ) − 2 ⋅ ∑ i ∈ L , j ∈ R ( d i s [ i ] + d i s [ j ] ) ⋅ d e p ′ [ l c a ′ ( i , j ) ] + w ⋅ ∑ i ∈ L , j ∈ R d i s ′ ( i , j ) = ∑ i ∈ L , j ∈ R ( d i s [ i ] ⋅ d e p ′ [ i ] + d i s [ j ] ⋅ d e p ′ [ j ] ) + ∑ i ∈ L , j ∈ R ( d i s [ i ] ⋅ d e p ′ [ j ] + d i s [ j ] ⋅ d e p ′ [ i ] )        − 2 ⋅ ∑ i ∈ L , j ∈ R ( d i s [ i ] + d i s [ j ] ) ⋅ d e p ′ [ l c a ′ ( i , j ) ] + w ⋅ ∑ i ∈ L , j ∈ R d i s ′ ( i , j ) = ∣ R ∣ ⋅ ∑ i ∈ L d i s [ i ] ⋅ d e p ′ [ i ] + ∣ L ∣ ⋅ ∑ j ∈ R d i s [ j ] ⋅ d e p ′ [ j ] + ∑ i ∈ L d i s [ i ] ⋅ ∑ j ∈ R d e p ′ [ j ] + ∑ i ∈ L d e p ′ [ i ] ⋅ ∑ j ∈ R d i s [ j ]        − 2 ⋅ ∑ i ∈ L , j ∈ R ( d i s [ i ] + d i s [ j ] ) ⋅ d e p ′ [ l c a ′ ( i , j ) ] + w ⋅ ∑ i ∈ L , j ∈ R d i s ′ ( i , j ) \begin{aligned} ANS &= \sum_{i \in L,j \in R}{(dis(i,u) + dis(j,v) + w)\cdot dis'(i,j)}\\ &= \sum_{i \in L,j\in R}{(dis[i] + dis[j])\cdot dis'(i,j)} + w\cdot \sum_{i \in L,j\in R}{dis'(i,j)}\\ &= \sum_{i \in L,j\in R}{(dis[i] + dis[j])\cdot (dep'[i] + dep'[j] - 2 \cdot dep'[lca'(i,j)])} + w\cdot \sum_{i \in L,j\in R}{dis'(i,j)}\\ &= \sum_{i \in L,j\in R}{(dis[i] + dis[j])\cdot (dep'[i] + dep'[j])} - 2 \cdot\sum_{i \in L,j \in R}{(dis[i] + dis[j])\cdot dep'[lca'(i,j)]} + w\cdot \sum_{i \in L,j\in R}{dis'(i,j)}\\ &= \sum_{i \in L,j\in R}{(dis[i] \cdot dep'[i] + dis[j] \cdot dep'[j])} + \sum_{i \in L,j \in R}{(dis[i] \cdot dep'[j] + dis[j] \cdot dep'[i])}\\ &\ \ \ \ \ \ - 2 \cdot\sum_{i \in L,j \in R}{(dis[i] + dis[j])\cdot dep'[lca'(i,j)]} + w\cdot \sum_{i \in L,j\in R}{dis'(i,j)}\\ &= |R| \cdot\sum_{i \in L}{dis[i] \cdot dep'[i]} + |L| \cdot \sum_{j \in R}{dis[j] \cdot dep'[j]} + \sum_{i \in L}{dis[i]} \cdot \sum_{j \in R}{dep'[j]}+ \sum_{i \in L}{dep'[i]} \cdot \sum_{j \in R}{dis[j]}\\ &\ \ \ \ \ \ - 2 \cdot\sum_{i \in L,j \in R}{(dis[i] + dis[j])\cdot dep'[lca'(i,j)]} + w\cdot \sum_{i \in L,j\in R}{dis'(i,j)} \end{aligned} ANS​=i∈L,j∈R∑​(dis(i,u)+dis(j,v)+w)⋅dis′(i,j)=i∈L,j∈R∑​(dis[i]+dis[j])⋅dis′(i,j)+w⋅i∈L,j∈R∑​dis′(i,j)=i∈L,j∈R∑​(dis[i]+dis[j])⋅(dep′[i]+dep′[j]−2⋅dep′[lca′(i,j)])+w⋅i∈L,j∈R∑​dis′(i,j)=i∈L,j∈R∑​(dis[i]+dis[j])⋅(dep′[i]+dep′[j])−2⋅i∈L,j∈R∑​(dis[i]+dis[j])⋅dep′[lca′(i,j)]+w⋅i∈L,j∈R∑​dis′(i,j)=i∈L,j∈R∑​(dis[i]⋅dep′[i]+dis[j]⋅dep′[j])+i∈L,j∈R∑​(dis[i]⋅dep′[j]+dis[j]⋅dep′[i])      −2⋅i∈L,j∈R∑​(dis[i]+dis[j])⋅dep′[lca′(i,j)]+w⋅i∈L,j∈R∑​dis′(i,j)=∣R∣⋅i∈L∑​dis[i]⋅dep′[i]+∣L∣⋅j∈R∑​dis[j]⋅dep′[j]+i∈L∑​dis[i]⋅j∈R∑​dep′[j]+i∈L∑​dep′[i]⋅j∈R∑​dis[j]      −2⋅i∈L,j∈R∑​(dis[i]+dis[j])⋅dep′[lca′(i,j)]+w⋅i∈L,j∈R∑​dis′(i,j)​
每个求和式都是可以直接DP的。。。所以用点集 L ∪ R L \cup R L∪R在 T ′ T' T′上建虚树做01DP即可。
复杂度大概。。 O ( n l o g 2 n ) O(nlog^2n) O(nlog2n)。。那么问题来了。。为什么不用点分呢

#pragma GCC optimize(3)
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 100;
int n;
vector<pair<int,int> > E2[maxn];
namespace HLD{
    int wson[maxn],sz[maxn],depth[maxn];
    ll dep[maxn];
    int fa[maxn],top[maxn];
    int dfs_clock,l[maxn],r[maxn];
    void dfs1(int u,int Fa){
        l[u] = ++dfs_clock;
        depth[u] = depth[Fa] + 1;
        sz[u] = 1;
        wson[u] = 0;
        fa[u] = Fa;
        for (auto e : E2[u]){
            int v,len;
            tie(v,len) = e;
            if (v == Fa)continue;
            dep[v] = dep[u] + len;
            if (dep[v] >= mod)dep[v] -= mod;
            dfs1(v,u);
            sz[u] += sz[v];
            if (sz[v] > sz[wson[u]])wson[u] = v;
        }
        r[u] = dfs_clock;
    }
    void dfs2(int u,int Fa,int chain){
        top[u] = chain;
        if (wson[u])dfs2(wson[u],u,chain);
        for (auto e : E2[u]){
            int v,len;
            tie(v,len) = e;
            if (v == Fa || v == wson[u])continue;
            dfs2(v,u,v);
        }
    }
    void init(int root){
        dfs_clock = 0;
        dep[root] = 0;
        dfs1(root,0);
        dfs2(root,0,root);
    }
    int lca(int x,int y){
        while (top[x] != top[y]){
            if (depth[top[x]] < depth[top[y]])swap(x,y);
            x = fa[top[x]];
        }
        if (depth[x] < depth[y])swap(x,y);
        return y;
    }
}
vector<pair<int,int> > EE1[maxn];
int first[maxn*3],des[maxn*6],llen[maxn*6],edgeid[maxn*6],nxt[maxn*6],tot;
inline void add_edge_(int u,int v,int w,int id){
    tot ++;
    des[tot] = v;
    llen[tot] = w;
    edgeid[tot] = id;
    nxt[tot] = first[u];
    first[u] = tot;
}
int cnt,edge_cnt;
bool banned[maxn * 3];
int pos[maxn * 3];
int id[maxn * 3];
ll ans = 0;
void clear(){
    tot = 0;
    for (int i=1;i<=cnt;i++)first[i] = 0;
    cnt = 0;
    for (int i=1;i<=n;i++){
        EE1[i].clear();
        E2[i].clear();
    }
    for (int i=1;i<=edge_cnt;i++)banned[i] = false;
    edge_cnt = 0;
    ans = 0;
}
inline void add_edge(int u,int v,int w){
    edge_cnt ++;
    add_edge_(u,v,w,edge_cnt);
    add_edge_(v,u,w,edge_cnt);
}
int dfs3d(int u, int fa){
    int now = ++cnt;
    pos[u] = now;
    id[now] = u;
    int pre = now;
    for (auto e : EE1[u]){
        int v,len;
        tie(v,len) = e;
        if (v == fa)continue;
        int temp = ++cnt;
        id[temp] = 0;
        add_edge(pre,temp,0);
        int vid = dfs3d(v,u);
        add_edge(temp,vid,len);
        pre = temp;
    }
    return now;
}
int sz[maxn * 3];
void dfs_sz(int u,int fa){
    sz[u] = 1;
    for (int t = first[u];t;t=nxt[t]){
        int v = des[t],e_id = edgeid[t];
        if (v == fa || banned[e_id])continue;
        dfs_sz(v,u);
        sz[u] += sz[v];
    }
}
void dfs_edge(int u,int fa,int tot_node,
              int &uu,int &vv,int &ww,int &edge_id,int &max_sz){
    for (int t = first[u];t;t=nxt[t]){
        int v = des[t],len = llen[t],e_id = edgeid[t];
        if (v == fa || banned[e_id])continue;
        int max_sz_t = max(sz[v],tot_node - sz[v]);
        if (max_sz_t < max_sz){
            max_sz = max_sz_t;
            uu = u;vv = v;
            ww = len;
            edge_id = e_id;
        }
        dfs_edge(v,u,tot_node,uu,vv,ww,edge_id,max_sz);
    }
}
ll dis[maxn * 3];
void dfs_node(int u,int fa,ll length,vector<int> &nodes){
    if (id[u])nodes.push_back(id[u]);
    dis[u] = length;
    for (int t = first[u];t;t=nxt[t]){
        int v = des[t],len = llen[t],e_id = edgeid[t];
        if (v == fa || banned[e_id])continue;
        int le = length + len;
        if (le >= mod) le -= mod;
        dfs_node(v,u,le, nodes);
    }
}
int vis[maxn];
int stk[maxn];
int fa[maxn];
ll dp_sum[maxn][2], dp_cnt[maxn][2],dp[maxn];
int color[maxn];
inline void clear(int x){
    dp[x] = 0;
    for (int c = 0;c < 2;c ++){
        dp_sum[x][c] = dp_cnt[x][c] = 0;
    }
}
void calc(int u, int v, int w){
    vector<int> L(0),R(0),nodes(0);
    dfs_node(u,0,0,L);dfs_node(v,0,0,R);
    if (L.size() == 0 || R.size() == 0)return;
    for (int x : L){
        color[x] = 1;
        vis[x] = 1;
        nodes.push_back(x);
    }
    for (int y : R){
        color[y] = 2;
        vis[y] = 1;
        nodes.push_back(y);
    }
    sort(nodes.begin(),nodes.end(),[](int x,int y){
        return HLD::l[x] < HLD::l[y];
    });
    int SZ = nodes.size();
    for (int i=1;i<SZ;i++){
        int temp = HLD::lca(nodes[i-1],nodes[i]);
        if (!vis[temp]){
            nodes.push_back(temp);
            vis[temp] = 2;
        }
    }
    if (!vis[1]){
        nodes.push_back(1);
        vis[1] = 2;
    }
    sort(nodes.begin(),nodes.end(),[](int x,int y){
        return HLD::l[x] < HLD::l[y];
    });
    int top = 1;
    stk[0] = nodes.front();
    for (int i=1;i<nodes.size(); i ++){
        while (HLD::l[nodes[i]] > HLD::r[stk[top-1]]) top--;
        fa[nodes[i]] = stk[top-1];
        stk[top ++] = nodes[i];
    }
    for (int x : nodes)clear(x);
    ll temp_ans = 0;
    ll sum = 0;
    for (int x : L) sum += 1ll * (dis[pos[x]] + w) * HLD::dep[x] % mod;
    temp_ans += sum % mod * R.size();
    sum = 0;
    for (int y : R) sum += 1ll * (dis[pos[y]] + w) * HLD::dep[y] % mod;
    temp_ans += sum % mod * L.size();
    ll sum1 = 0,sum2 = 0;
    for (int x : L)sum1 += dis[pos[x]];
    for (int y : R)sum2 += HLD::dep[y];
    sum1 %= mod;sum2 %= mod;
    temp_ans += sum1 * sum2 % mod;
    sum1 = sum2 = 0;
    for (int x : L)sum1 += HLD::dep[x];
    for (int y : R)sum2 += dis[pos[y]];
    sum1 %= mod;sum2 %= mod;
    temp_ans += sum1 * sum2 % mod;
    for (int i = nodes.size() - 1;i >=0; i--){
        int u = nodes[i], c = vis[u] == 1?color[u] - 1 : -1;
        if (c != -1){
            ll A = dis[pos[u]];
            dp[u] += A * dp_cnt[u][!c] % mod;
            dp[u] += dp_sum[u][!c];
            dp[u] += dp_cnt[u][!c] * w % mod;
            dp[u] %= mod;
            dp_sum[u][c] += A;
            if (dp_sum[u][c] >= mod)dp_sum[u][c] -= mod;
            dp_cnt[u][c] ++;
        }
        temp_ans -= 2ll * dp[u] * HLD::dep[u] % mod;
        dp[fa[u]] += dp_sum[u][0] * dp_cnt[fa[u]][1]% mod + dp_sum[fa[u]][1] * dp_cnt[u][0]% mod;
        dp[fa[u]] += dp_sum[u][1] * dp_cnt[fa[u]][0]% mod + dp_sum[fa[u]][0] * dp_cnt[u][1]% mod;
        dp[fa[u]] += (dp_cnt[fa[u]][1] * dp_cnt[u][0]% mod + dp_cnt[fa[u]][0] * dp_cnt[u][1] % mod) * w % mod;
        dp[fa[u]] %= mod;
        for (int c = 0;c < 2;c ++){
            dp_cnt[fa[u]][c] += dp_cnt[u][c];
            dp_sum[fa[u]][c] += dp_sum[u][c];
            if(dp_cnt[fa[u]][c] >= mod)dp_cnt[fa[u]][c] -= mod;
            if(dp_sum[fa[u]][c] >= mod)dp_sum[fa[u]][c] -= mod;
        }
    }
    ans += (temp_ans % mod) + mod;
    for (int x : nodes){
        vis[x] = 0;
    }
}
void dfs(int root){
    dfs_sz(root,0);
    int uu,vv,ww,e_id,max_sz = mod;
    int node_cnt = sz[root];
    if (node_cnt == 1)return;
    dfs_edge(root,0,node_cnt,uu,vv,ww,e_id,max_sz);
    banned[e_id] = true;
    calc(uu, vv, ww);
    dfs(uu);dfs(vv);
}
inline void read(int &x){
    x = 0;
    char ch = getchar();
    while (ch < '0' || ch > '9')ch = getchar();
    while (ch >= '0' && ch <= '9')x = x * 10 + ch - '0',ch = getchar();
}
void work(){
    read(n);
    for (int i=1;i<n;i++){
        int u,v,len;
        read(u);read(v);read(len);
        EE1[u].push_back(make_pair(v,len));
        EE1[v].push_back(make_pair(u,len));
    }
    for (int i=1;i<n;i++){
        int u,v,len;
        read(u);read(v);read(len);
        E2[u].push_back(make_pair(v,len));
        E2[v].push_back(make_pair(u,len));
    }
    HLD::init(1);
    int root = dfs3d(1,0);
    int max_d = -1;
    for (int i=1;i<=cnt;i++){
        int d = 0;
        for (int t = first[i];t;t=nxt[t]){
            d ++;
        }
        max_d = max(max_d,d);
    }
    dfs(root);
    ans %= mod;
    ans = ans * 2 % mod;
    printf("%lld\n",ans);
}
int main(){
    int T;
    read(T);
    while (T--){
        work();
        clear();
    }
    return 0;
}
calabash_boy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Proteus仿真】51单片机+红外测距仪(GP2D12)+ADC0808模数转换
perseverance51博客
05-29 1万+
【Proteus仿真】51单片机+红外测距仪(GP2D12)+ADC0809模数转换
2018 China Collegiate Programming Contest Final (CCPC-Final 2018) 部分题解及AC代码
Adolphrocs的博客
07-12 1652
2018 China Collegiate Programming Contest Final (CCPC-Final 2018) A - Mischievous Problem Setter 题意：一些题目的有难度值d,和需要花费的时间t,只能按难度递增的顺序解决问题，问在T时间内最多解决几题 题解：贪心 按难度值排序，然后能做就做，这题的意思是不能跳着做 #include <...
php在线客服：TP6+workerman实现
热门推荐
BaiQi
07-13 8万+
php在线客服： TP6 + workerman实现在线客服
【Pytorch神经网络理论篇】 23 对抗神经网络：概述流程 + WGAN模型 + WGAN-gp模型 + 条件GAN + WGAN-div + W散度
小李的研究生学习日记
03-24 1万+
1 对抗神经简介 1.1 对抗神经网络的基本组成 1.1.1 基本构成 对抗神经网络（即生成式对抗网络，GAN)一般由两个模型组成： 生成器模型(generator):用于合成与真实样本相差无几的模拟样本。 判别器模型(discriminator）:用于判断某个样本是来自真实世界还是模拟生成的。 1.1.2 不同模型的在GAN中的主要作用 生成器模型的目的是，让判别器模型将合成样本当成直实样本。 判别器模的目的是，将合成样本与真实样本区分开。 1.1.3 独立任务 若将两个模型放在一起同
30【源码】数据可视化大屏：基于 Echarts + Python Flask 实现的32-9超宽大屏 - 中国&国际疫情实时追踪
YYDataV的博客
04-26 1万+
我是 YYDataV数据可视化 专注于数据可视化大屏，工厂扫码装箱系统等 我的微信 6550523，多多交流 ~ 前言：本案例爬取数据源为腾讯疫情数据, 对数据进行分析归类处理，然后制作成32：9超宽分辨率的可视化大屏。 效果展示 1.动态实时更新数据效果图 2.鼠标右键切换主题 代码中预置了12个主题风格，实际开发中可根据实际情况二次增加。 切换主题，我们可以看到：主题的配色变化了另一种风格。 一.确定需求方案 1. 屏幕分辨率 ...
如何做一个本地漫画党：了解漫画＋下载漫画＋漫画APP推荐
阿虚同学的博客
07-18 3万+
最近《进击的巨人》漫画终于完结了 但结局真的叫那个离谱、恶心、伤害读者… 刚看完结局我的痛苦面具就戴上了，真的直到现在都还没拿下来 都说爱得越真，伤得越深，何况我对巨人的爱原本有「千岛海沟」那么深 阿虚在这里的话，也劝那些还没看过《进击的巨人》这部漫画的人，请记得：123话它就完结了，没有了，后面它没有剧情了！这时停下来，它还是神作！！ 年龄大了，加上经历了这种级别的烂尾后，我觉得我再也无法去追连载漫画了 我现在只想去看那些已经完结的故事 再也不想遇到一部看了让我后悔的漫画了！ 今天就是想来推荐大家
大概率（5重方法）解决RuntimeError: CUDA out of memory. Tried to allocate ... MiB
定期分享我的发现和想法，感谢你的陪伴和支持
03-24 2万+
主机中的内存，有两种存在方式，一是锁页，二是不锁页，锁页内存存放的内容在任何情况下都不会与主机的虚拟内存进行交换（注：虚拟内存就是硬盘），而不锁页内存在主机内存不足时，数据会存放在虚拟内存中。显卡中的显存全部是锁页内存,当计算机的内存充足的时候，可以设置pin_memory=True。pin_memory就是锁页内存，创建DataLoader时，设置pin_memory=True，则意味着生成的Tensor数据最开始是属于内存中的锁页内存，这样将内存的Tensor转义到GPU的显存就会更快一些。
poj 3345 Bribing FIPA[树形dp+背包]
smallfish的专栏
07-20 1万+
Bribing FIPA Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 3207   Accepted: 1014 Description There is going to be a voting at FIPA (Fédération Internationa
WGAN-GP：进阶的WGAN
张先生－您好的博客
11-24 4521
WGAN-GP 前言 ​ 　　从GAN到WGAN，我们通过使用新的距离（推土机距离）来衡量PgP_gPg​和PrP_rPr​的到底有多接近，并且使用了权重裁剪来使得我们的生成器满足约束，但是作者也在论文中提到了这是一种暴力的手段，在现实的实验过程中，我们也发现Critic的权重会逐渐向裁剪因子靠拢，出现两极化的现象（如下图 c = 0.01），然而本身ccc的取值很难有一个界定，我们必须不断地调...
java中servlet dal bll model_GitHub - Tolerating/leave-jsp-Servlet: 使用jsp + Servlet搭建的mvc,学习java web 开...
weixin_39600885的博客
02-25 7万+
开发工具为IntelliJ IDEA 2019.1.3 x64数据库为 Sql Server 2008R2该项目并非完整的,只是对Servlet和java和jdbc学习的实践项目结构![src目录](data:img/jpg;base64,iVBORw0KGgoAAAANSUhEUgAAAccAAAGlCAYAAACPwD3jAAAgAElEQVR4nO3dfXRTZ34v+q+MzTAGwovz...
gp2toot：进行G +外卖转储并将其发送到Mastodon实例
02-04
gp2toot 读取Google+（G +）外卖（Takeaway）下载的存档，并将其发送给Mastodon。状态当前状态：需要用户测试和反馈我已经添加了我计​​划在此时添加的所有功能，我正在等待反馈。变更日志初始代码原型。 0.5功能：...
GP System in C/C++:C / C ++中的GP系统-开源
04-28
【GP System】 GP，全称为Genetic Programming，是一种基于进化算法的计算方法，它模拟了生物进化过程来解决复杂的编程问题。在这个C/C++实现的GP系统中，重点在于利用遗传算法进行符号回归，这是一种寻找数学函数...
keras-gp:硬+高斯过程
05-01
Keras的高斯过程 KGP通过高斯过程（GP）层扩展了 。 它允许人们使用由Keras构建的网络构造的内核构建灵活的GP模型。 模型的结构化部分（神经网络）在或上运行。 GP层使用基于库的自定义后端，并基于和构建。 可以...
celerite：C ++，Python和Julia中的可伸缩一维高斯过程
01-30
在数据分析和机器学习领域，高斯过程（Gaussian Processes，简称GP）是一种强大的非参数统计工具，常用于回归分析和不确定性建模。`celerite`是一个专门为解决一维时间序列问题设计的高效库，它支持在C++、Python和...
摩托罗拉GP328D+写频软件MOTOTRBO CPS 2.0
01-25
摩托罗拉GP328D+是一款专业级的对讲机，主要应用于商业、公共安全以及工业环境。这款设备以其出色的通信性能和耐用性而受到用户的欢迎。与之配套的写频软件MOTOTRBO CPS（Customer Programming Software）则是对讲机...
Codeforces 图论板刷总结（更新中）
辣鸡葫芦娃
09-07 1931
图论太菜了呀，那怎么办呀，刷点题吧，写下来可以以后复习，或者造福后人？ 大概就从这开始刷吧：Link 题目对应简略思路+题解786B 区间图最段路741C 构造题 二分图567E 最短路DAG必经边527E 欧拉回路 786B 区间图最段路 没啥好说的，标准的区间图最短路，建议整理板子。我的板子：Link 741C 构造题 二分图 很容易被搞到2-sat上去，但是猜到一定有解的情况下， 构造出二分...
业界毒瘤仙人掌一条龙服务
辣鸡葫芦娃
04-17 1122
本slide是为了NJU集训队准备。。。。未完待续。。。 正经定义 ： 无向图中的每条边至多位于一个简单环上，且任意两点可达。 由此可知仙人掌的构造方式很“优美”，即生成一棵树，把树的某些节点，都各自变成一个简单环，就变成了仙人掌。因此仙人掌大体围绕两个重点：树边、简单环。 入门篇 简单环判定 : codeforces 962F 题意：给出无向图，找到所有...
第二类斯特林数合集
辣鸡葫芦娃
04-08 963
留坑。。HDU2643求一个n人参加的比赛，最终的排名情况有多少种，注意可以并列。思路1：直接DP。dp[i][j]表示i个人，总共有j种名次。dp[i][j] =j*(dp[i-1][j-1]+dp[i-1][j]) 如果第i个人单独占有了一个名次，则i-1个人占有j-1个名次，否则，i-1个人占有j个名次，然后枚举第i个人在哪一个名次。答案=sigma{dp[n][i]}(1&lt;=i&lt...
莫比乌斯反演、容斥 题集
辣鸡葫芦娃
02-01 538
洛谷 P2257 题意 求x∈[1,N]x \in[1,N]x∈[1,N],y∈[1,M]y \in [1,M]y∈[1,M],且(x,y)=质数(x,y) = 质数(x,y)=质数的点对个数 \begin{equation} \sum \end{equation}
逐句解释这段matlab代码：%递推估计初值 thetaek=zeros(na+nb+d+nc,d); P=10^6*eye(na+nb+d+nc); for k = 1:L time(k) = k; y(k)=-a(2:na+1)*yk(1:na)+b*uk(d:d+nb)+c*[xi(k);xik];%采集输出数据 %递推增广最小二乘法 phie=[yk(d:d+ng);uk(d:d+nf);-yek(1:nc)]; K=P*phie/(1+phie'*P*phie); thetae(:,k)=thetaek(:,1)+K*(y(k)-phie'*thetaek(:,1)); P= (eye(na+nb+ d+ nc)- K* phie') * P; ye= phie'* thetaek(:,d);%最优预测输出的估计值 %提高辨识参数 ge=thetae(1:ng + 1 ,k)'; fe = thetae(ng + 2:ng + nf + 2,k)'; ce = [1 thetae(ng + nf + 3:ng + nf + 2 + nc,k)']; if abs(ce(2))>0.9 ce(2)=sign(ce(2))* 0.9; end if fe(1)<0.1%设 f0 的下界为 0.1 fe(1)=0.1; end CQ= conv(ce,Q); FP = conv(fe,Pw); CR = conv(ce,R); GP = conv(ge,Pw); u(k) =(- Q(1) * CQ(2:nc + nq +1) * uk(1:nc + nq)/fe(1) -FP(2:np + nf + 1) * uk(1:np+nf)+CR*[yr(k+ d:-1:k+d- min(d,nr + nc)); yrk(1:nr + nc-d)]- GP*[y(k);yk(1:np +ng)])/(Q(1) * Q(1)/fe(1) + fe(1));
最新发布
06-10
以下是逐句解释这段 MATLAB 代码的含义和作用： ``` %递推估计初值 thetaek=zeros(na+nb+d+nc,d); ``` 该行代码用于初始化系统参数的初值，其中 na、nb、d 和 nc 分别是系统的参数维度。 ``` P=10^6*eye(na+nb+d+nc); ``` 该行代码用于初始化协方差矩阵 P，其中 P 是一个 (na+nb+d+nc)×(na+nb+d+nc) 的对角矩阵，每个对角元素的初始值为 10^6。 ``` for k = 1:L ``` 该行代码用于循环采集系统的输出数据，其中 L 是采集数据的长度。 ``` time(k) = k; ``` 该行代码用于记录当前时间步 k。 ``` y(k)=-a(2:na+1)*yk(1:na)+b*uk(d:d+nb)+c*[xi(k);xik]; ``` 该行代码用于采集系统的输出数据 y(k)，其中 a、b 和 c 分别是系统的系数向量，yk 和 uk 是历史输入输出数据，xi(k) 和 xik 分别是当前时刻的输入和历史输入数据。 ``` %递推增广最小二乘法 phie=[yk(d:d+ng);uk(d:d+nf);-yek(1:nc)]; K=P*phie/(1+phie'*P*phie); ``` 该行代码用于实现递推增广最小二乘法，其中 phie 是增广矩阵，包含了历史输入输出数据和前 d 个时刻的参数估计值。K 是增益矩阵，用于调整参数估计值。 ``` thetae(:,k)=thetaek(:,1)+K*(y(k)-phie'*thetaek(:,1)); ``` 该行代码用于更新参数估计值 thetae，其中 thetaek(:,1) 是参数的初值，y(k) 是采集到的系统输出值。 ``` P= (eye(na+nb+ d+ nc)- K* phie') * P; ye= phie'* thetaek(:,d); ``` 该行代码用于更新协方差矩阵 P 和最优预测输出的估计值 ye。 ``` %提高辨识参数 ge=thetae(1:ng + 1 ,k)'; fe = thetae(ng + 2:ng + nf + 2,k)'; ce = [1 thetae(ng + nf + 3:ng + nf + 2 + nc,k)']; if abs(ce(2))>0.9 ce(2)=sign(ce(2))* 0.9; end if fe(1)<0.1%设 f0 的下界为 0.1 fe(1)=0.1; end ``` 该行代码用于提高辨识参数，其中 ge、fe 和 ce 分别是提高辨识参数的向量。如果 ce(2) 的绝对值大于 0.9，则将其限制在 [-0.9, 0.9] 的范围内。如果 fe(1) 的值小于 0.1，则将其设为 0.1。 ``` CQ= conv(ce,Q); FP = conv(fe,Pw); CR = conv(ce,R); GP = conv(ge,Pw); ``` 该行代码用于计算控制输入的不同部分，其中 CQ、FP、CR 和 GP 分别是增广矩阵和滤波器系数的卷积。 ``` u(k) =(- Q(1) * CQ(2:nc + nq +1) * uk(1:nc + nq)/fe(1) -FP(2:np + nf + 1) * uk(1:np+nf)+CR*[yr(k+ d:-1:k+d- min(d,nr + nc)); yrk(1:nr + nc-d)]- GP*[y(k);yk(1:np +ng)])/(Q(1) * Q(1)/fe(1) + fe(1)); ``` 该行代码用于计算控制输入 u(k)，其中 Q、Pw 和 R 分别是给定的参数，分别是控制器的权重系数、滤波器系数和误差权重系数。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值