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

最新推荐文章于 2024-08-08 08:00:00 发布
最新推荐文章于 2024-08-08 08:00:00 发布
阅读量401 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 专题练习 文章标签： 边分治 GP of China
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/calabash_boy/article/details/102577347
本文详细解析了一种结合边分治与01动态规划算法解决特定树上距离求和问题的方法。通过在两个树TTT和T′T′上计算所有节点对之间的距离乘积之和，采用边分治策略处理复杂度，并在虚树上应用01DP进行高效求解。文章深入分析了算法实现细节，包括数据结构设计、状态转移方程和复杂度分析。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

题意

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

题解

对TTT进行边分治，当前分治的边为<u,v><u,v><u,v>，边权为www时，设uuu一侧的点集为LLL，vvv一侧的点集是RRR，则经过当前边的dis(i,j)dis(i,j)dis(i,j)对答案的贡献是：
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∈Rdis′(i,j)=∑i∈L,j∈R(dis[i]+dis[j])⋅(dep′[i]+dep′[j]−2⋅dep′[lca′(i,j)])+w⋅∑i∈L,j∈Rdis′(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∈Rdis′(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∈Rdis′(i,j)=∣R∣⋅∑i∈Ldis[i]⋅dep′[i]+∣L∣⋅∑j∈Rdis[j]⋅dep′[j]+∑i∈Ldis[i]⋅∑j∈Rdep′[j]+∑i∈Ldep′[i]⋅∑j∈Rdis[j]      −2⋅∑i∈L,j∈R(dis[i]+dis[j])⋅dep′[lca′(i,j)]+w⋅∑i∈L,j∈Rdis′(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∪RL \cup RL∪R在T′T'T′上建虚树做01DP即可。
复杂度大概。。O(nlog2n)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;
}
佳博热敏打印：蓝牙打印商品价签和交易小票的模版，实现自动连接最近使用的打印机 (针对佳博GP-2120TU型号为例子进行展开) 【包含完整demo源码】 佳博GP-H430F工业机标签条码打印
专注于计算机研发知识和资讯分享
01-03 1万+
code 获取打印命令 -(NSData *)price_tscCommand{ TscCommand *command = [[TscCommand alloc]init]; [command addSize:40 :60]; [command addGapWithM:2 withN:0]; [command addReference: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 1720
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超宽大屏 - 中国&国际疫情实时追踪
HelloCode5110的博客
04-26 1万+
我是 YYDataV数据可视化 专注于数据可视化大屏，工厂扫码装箱系统等 我的微信 6550523，多多交流 ~ 前言：本案例爬取数据源为腾讯疫情数据, 对数据进行分析归类处理，然后制作成32：9超宽分辨率的可视化大屏。 效果展示 1.动态实时更新数据效果图 2.鼠标右键切换主题 代码中预置了12个主题风格，实际开发中可根据实际情况二次增加。 切换主题，我们可以看到：主题的配色变化了另一种风格。 一.确定需求方案 1. 屏幕分辨率 ...
如何做一个本地漫画党：了解漫画＋下载漫画＋漫画APP推荐
阿虚同学的博客
07-18 3万+
最近《进击的巨人》漫画终于完结了 但结局真的叫那个离谱、恶心、伤害读者… 刚看完结局我的痛苦面具就戴上了，真的直到现在都还没拿下来 都说爱得越真，伤得越深，何况我对巨人的爱原本有「千岛海沟」那么深 阿虚在这里的话，也劝那些还没看过《进击的巨人》这部漫画的人，请记得：123话它就完结了，没有了，后面它没有剧情了！这时停下来，它还是神作！！ 年龄大了，加上经历了这种级别的烂尾后，我觉得我再也无法去追连载漫画了 我现在只想去看那些已经完结的故事 再也不想遇到一部看了让我后悔的漫画了！ 今天就是想来推荐大家
内存不足：解决大模型训练时的CUDA Out of Memory错误
最新发布
沉淀所学，分享所思，让热爱与成长同行。商务记录AI实战经验，助力开发者快速成长。 热爱AI，希望做出有影响力的技术成果。 技术点亮生活，分享连接价值与机会。 专注AI落地实战，陪你走好技术每一步。
08-08 2万+
大家好，我是默语，擅长全栈开发、运维和人工智能技术。今天我将和大家分享在大模型训练时如何解决CUDA Out of Memory错误的解决方案。这个问题在深度学习领域非常常见，尤其是在处理大型数据集和复杂模型时。希望这篇文章能帮助大家更好地解决这一问题，提高模型训练的效率和稳定性。CUDA Out of Memory错误是指在使用NVIDIA 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
大概率（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的显存就会更快一些。
WGAN-GP：进阶的WGAN
张先生－您好的博客
11-24 4946
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 8万+
开发工具为IntelliJ IDEA 2019.1.3 x64数据库为 Sql Server 2008R2该项目并非完整的,只是对Servlet和java和jdbc学习的实践项目结构![src目录](data:img/jpg;base64,iVBORw0KGgoAAAANSUhEUgAAAccAAAGlCAYAAACPwD3jAAAgAElEQVR4nO3dfXRTZ34v+q+MzTAGwovz...
一起学画图：散点图+边缘分布统计图形-密度图-直方图-箱型图-小提琴图
NewComerSyt的博客
03-10 4045
Part 1 ：散点图+变量边缘分布图形 公众号原文点我，感谢支持 许多文章的散点图中，在散点图的周围还会有额外的单变量边缘分布统计图形（如下图）。前面几期我们介绍过，散点图主要反映的是两个变量之间的关系，而额外的边缘分布图则能直观反映每个变量的分布情况。本期就来介绍实现这类图形的常见方法。 示例： Abundance of antibiotic resistance genes, intI1 gene and crAssphage in human fecal metagenomes. [1]示例图中散
我的课程表（技术栈：Vue+node+vant+mysql）
weixin_43964148的博客
10-06 2788
1.首页： 可惜不能放视频 只能贴图为敬 先看一波首页 如图 所示，首页为课程通知页面，提醒今日和明日上什么课。 先贴上代码： <template> <div class="index"> <!--头部采用vant组件--> <van-nav-bar title="课程通知...
持续集成环境的搭建：Gitlab+Jenkins+sonar+Nexus
m0_37208669的博客
11-30 3205
文章目录主要内容gitlab什么是gitlab使用docker进行安装基本使用项目组与项目的创建邮件服务的配置nexus什么是nexus使用docker进行安装基本使用小结sonar什么是sonarqube使用docker进行安装Jenkins安装插件安装配置JDKMaven邮件配置sonargitlab仪表盘简介Jenkins基本使用手动集成hook触发自动构建流水线Pipeline分布式构建 ...
Codeforces 图论板刷总结（更新中）
辣鸡葫芦娃
09-07 2665
图论太菜了呀，那怎么办呀，刷点题吧，写下来可以以后复习，或者造福后人？ 大概就从这开始刷吧：Link 题目对应简略思路+题解786B 区间图最段路741C 构造题 二分图567E 最短路DAG必经边527E 欧拉回路 786B 区间图最段路 没啥好说的，标准的区间图最短路，建议整理板子。我的板子：Link 741C 构造题 二分图 很容易被搞到2-sat上去，但是猜到一定有解的情况下， 构造出二分...
业界毒瘤仙人掌一条龙服务
辣鸡葫芦娃
04-17 1239
本slide是为了NJU集训队准备。。。。未完待续。。。 正经定义 ： 无向图中的每条边至多位于一个简单环上，且任意两点可达。 由此可知仙人掌的构造方式很“优美”，即生成一棵树，把树的某些节点，都各自变成一个简单环，就变成了仙人掌。因此仙人掌大体围绕两个重点：树边、简单环。 入门篇 简单环判定 : codeforces 962F 题意：给出无向图，找到所有...
第二类斯特林数合集
辣鸡葫芦娃
04-08 1039
留坑。。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 628
洛谷 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}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值