费用流模板+splay模板(数组实现)

最新推荐文章于 2022-07-05 17:40:54 发布
最新推荐文章于 2022-07-05 17:40:54 发布
阅读量298 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yancy_/article/details/79318459
版权

BZOJ 1877 最小费用流

#include<bits/stdc++.h>
using namespace std;
#define inf 0x7fffffff
#define N 410
#define M 42000
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
int n, m;
struct node {  int from, to, next, v, c;  }  e[M];
int ans1, ans2, dis[N], from[N], head[N], q[N << 2], S, T, cnt = 1;
bool inq[N];
void ins(int u, int v, int w, int c)  {
    cnt++;
    e[cnt].from = u; e[cnt].to = v;
    e[cnt].v = w; e[cnt].c = c;
    e[cnt].next = head[u];  head[u] = cnt;
}
void insert(int u, int v, int w, int c)  {
    ins(u, v, w, c); ins(v, u, 0, -c);
}
bool spfa()  {
    for(int i = S; i <= T; i++) dis[i] = inf, inq[i] = false;
    queue<int> q;
    q.push(S); dis[S] = 0; inq[S] = true;
    while(!q.empty())  {
        int now = q.front(); q.pop();
        inq[now] = false;
        int k = head[now];
        while(k)  {
            if (e[k].v && e[k].c + dis[now] < dis[e[k].to])  {
                dis[e[k].to] = dis[now] + e[k].c;
                from[e[k].to] = k;
                if (!inq[e[k].to])  inq[e[k].to] = true, q.push(e[k].to);
            }
            k = e[k].next;
        }
    }
    return dis[T] != inf;
}
void mcf()  {
    int x = inf;
    int k = from[T];
    while(k)  {
        x = min(x, e[k].v);
        k = from[e[k].from];
    }
    ans1++;
    k = from[T];
    while(k)  {
        ans2 += x * e[k].c;
        e[k].v -= x;
        e[k ^ 1].v += x;
        k = from[e[k].from];
    }
}
int main()  {
    scanf("%d%d", &n, &m);
    S = 1, T = n + n;
    for(int i = 1; i <= m; i++)  {
        int x, y, z;
        scanf("%d%d%d", &x, &y, &z);
        insert(x + n, y, 1, z);
    }
    for(int i = 2; i < n; i++) insert(i, i + n, 1, 0);
    insert(S, S + n, inf, 0);
    insert(n, T, inf, 0);
    while(spfa()) mcf();
    printf("%d %d", ans1, ans2);
    return 0;
}

BZOJ3224 splay

/**************************************************************
    Problem: 3224
    User: YuHsin
    Language: C++
    Result: Accepted
    Time:672 ms
    Memory:24740 kb
****************************************************************/

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
#define N 1000007
int ch[N][2], f[N], size[N], cnt[N], key[N];
int sz, root;
inline void clear(int x)  {
    ch[x][0] = ch[x][1] = f[x] = size[x] = cnt[x] = key[x] = 0;
}
inline bool get(int x)  {
    return ch[f[x]][1] == x;
}
inline void update(int x)  {
    if (x)  {
        size[x] = cnt[x];
        if (ch[x][0]) size[x] += size[ch[x][0]];
        if (ch[x][1]) size[x] += size[ch[x][1]];
    }
}
inline void rotate(int x)  {
    int old = f[x], oldf = f[old], whichx = get(x);
    ch[old][whichx] = ch[x][whichx^1]; f[ch[old][whichx]] = old;
    ch[x][whichx^1] = old; f[old] = x;
    f[x] =  oldf;
    if (f[x]) ch[oldf][ch[oldf][1] == old] = x;
    update(old); update(x);
}
inline void splay(int x)  {
    for(int fa; (fa = f[x]); rotate(x))
        if (f[fa]) rotate((get(x) == get(fa)) ? fa : x);
     root = x;
}
inline void insert(int x)  {
    if (root == 0)  {
        sz++; ch[sz][0] =  ch[sz][1] = f[sz] = 0;
        size[sz] = cnt[sz] = 1;
        key[sz] = x; root = sz; return;
    }
    int now = root, fa = 0;
    while(true)  {
        if (x == key[now]) {
            cnt[now]++; update(now); update(fa); splay(now); break;
        }
        fa = now;
        now = ch[now][x > key[now]];
        if (now == 0)  {
            sz++; ch[sz][0] = ch[sz][1] = 0;
            f[sz] = fa; key[sz] = x;
            size[sz] = cnt[sz] = 1;
            ch[fa][key[fa]<x] = sz;
            update(fa); splay(sz); break;
        }
    }
}
inline int find(int x)  {
    int now = root, ans = 0;
    while(true)  {
        if (x < key[now]) now = ch[now][0];
        else {
            ans += (ch[now][0]?size[ch[now][0]]:0);
            if (x == key[now]) {  splay(now); return ans + 1;  }
            ans += cnt[now];
            now = ch[now][1];
        }
    }
}
inline int findx(int x)  {
    int now = root;
    while(true)  {
        if (ch[now][0] && x <= size[ch[now][0]]) now = ch[now][0];
        else {
            int temp = cnt[now] + (ch[now][0]?size[ch[now][0]]:0);
            if (x <= temp) return key[now];
            x -= temp; now = ch[now][1];
        }
    }
}
inline int pre()  {
    int now = ch[root][0];
    while(ch[now][1]) now = ch[now][1];
    return now;
}
inline int nxt()  {
    int now = ch[root][1];
    while(ch[now][0]) now = ch[now][0];
    return now;
}
inline void del(int x)  {
    int whatever = find(x);
    if (cnt[root] > 1) {
        cnt[root]--; update(root); return;
    }
    if (!ch[root][0] && !ch[root][1]) {  clear(root); root = 0; return;  }
    if (!ch[root][0])  {
        int oldroot = root; root = ch[root][1]; f[root] = 0;
        clear(oldroot); return;
    }
    if (!ch[root][1])  {
        int oldroot = root;  root = ch[root][0]; f[root] = 0;
        clear(oldroot);  return ;
    }
    int leftbig = pre(), oldroot =  root;
    splay(leftbig);
    f[ch[oldroot][1]] = root;
    ch[root][1] = ch[oldroot][1];
    clear(oldroot);
    update(root); return;
}
int main(){
    int n,opt,x;
    scanf("%d",&n);
    for (int i=1;i<=n;++i){
        scanf("%d%d",&opt,&x);
        switch(opt){
            case 1: insert(x); break;
            case 2: del(x); break;
            case 3: printf("%d\n",find(x)); break;
            case 4: printf("%d\n",findx(x)); break;
            case 5: insert(x); printf("%d\n",key[pre()]); del(x); break;
            case 6: insert(x); printf("%d\n",key[nxt()]); del(x); break;
        }
    }
    return 0;
}

BZOJ1834 裸最大流+费用流

#include<bits/stdc++.h>
using namespace std;
#define inf 0x7fffffff
#define N 1210
#define M 32000
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
int n, m, k;
struct node {  int from, to, next, v, c, t;  }  e[M];
int ans, ans2, dis[N], from[N], head[N], q[N << 2], S, T, cnt = 1;
bool inq[N];
int h[N];
void ins(int u, int v, int w, int c)  {
    cnt++;
    e[cnt].from = u; e[cnt].to = v;
    e[cnt].v = w; e[cnt].t = c;
    e[cnt].next = head[u];  head[u] = cnt;
}
void insert(int u, int v, int w, int c)  {
    ins(u, v, w, c); ins(v, u, 0, -c);
}
void ins2(int u, int v, int w, int c)  {
    cnt++;
    e[cnt].from = u; e[cnt].to = v;
    e[cnt].v = w; e[cnt].c = c;
    e[cnt].next = head[u];  head[u] = cnt;
}
void insert2(int u, int v, int w, int c)  {
    ins2(u, v, w, c); ins2(v, u, 0, -c);
}
void build()  {
    int tot = cnt;
    for(int i = 2; i <= tot; i+= 2) if (i % 2 == 0)
        insert2(e[i].from, e[i].to, inf, e[i].t);
}
bool bfs()  {
    for(int i = S; i <= T; i++) h[i] = -1;
    queue<int> q;
    q.push(S); h[S] = 0;
    while(!q.empty())  {
        int now = q.front(); q.pop();
        int k = head[now];
        while(k)  {
            if (e[k].v && h[e[k].to] == -1)  h[e[k].to] = h[now] + 1, q.push(e[k].to);
            k = e[k].next;
        }
    }
    return h[T] != -1;
}
int dfs(int x, int f) {
    if (x == T)  return f;
    int k = head[x], used = 0;
    while(k)  {
        if (e[k].v && h[e[k].to] == h[x] + 1)  {
            int w = f - used;
            w = dfs(e[k].to, min(w, e[k].v));
            e[k].v -= w;
            e[k ^ 1].v += w;
            used += w;
            if (used == f)  return f;
        }
        k = e[k].next;
    }
    if (!used) h[x] = -1;
    return used;
}
void dinic()  {
    while(bfs()) ans += dfs(S, inf);
}
bool spfa()  {
    for(int i = S; i <= T; i++) dis[i] = inf, inq[i] = false;
    queue<int> q;
    q.push(S); dis[S] = 0; inq[S] = true;
    while(!q.empty())  {
        int now = q.front(); q.pop();
        inq[now] = false;
        int k = head[now];
        while(k)  {
            if (e[k].v && e[k].c + dis[now] < dis[e[k].to])  {
                dis[e[k].to] = dis[now] + e[k].c;
                from[e[k].to] = k;
                if (!inq[e[k].to])  inq[e[k].to] = true, q.push(e[k].to);
            }
            k = e[k].next;
        }
    }
    return dis[T] != inf;
}
void mcf()  {
    int x = inf;
    int k = from[T];
    while(k)  {
        x = min(x, e[k].v);
        k = from[e[k].from];
    }
    k = from[T];
    while(k)  {
        ans2 += x * e[k].c;
        e[k].v -= x;
        e[k ^ 1].v += x;
        k = from[e[k].from];
    }
}
int main()  {
    scanf("%d%d%d", &n, &m, &k);
    for(int i = 1; i <= m; i++)  {
        int x, y, z, t;
        scanf("%d%d%d%d", &x, &y, &z, &t);
        insert(x, y, z, t);
    }
    S = 1, T = n;
    dinic();
    build();
    insert2(0, 1, k, 0);
    S = 0;
    T = n;
    while(spfa()) mcf();
    printf("%d %d", ans, ans2);
    return 0;
}
YuHsin
关注
splay模板
TUT我好菜啊
06-13 645
1588: [HNOI2002]营业额统计 Time Limit: 5 Sec  Memory Limit: 162 MB Submit: 6923  Solved: 2286 [Submit][Status] Description 营业额统计 Tiger最近被公司升任为营业部经理，他上任后接受公司交给的第一项任务便是统计并分析公司成立以来的营业情况。 Tiger拿出了公司的账
模板 - 费用流
繁凡さん的博客
08-22 661
整理的算法模板合集： ACM模板 文章目录一、最小费用最大流类dinic模板二、最大费用最大流解决二分图带权最大匹配三、费用提前计算+动态开点 一、最小费用最大流 类dinic模板 时间复杂度为O(nmf)O(nmf)O(nmf)， fff 为最大流量， 效率较高，一般不会被卡 #include<iostream> #include<cstdio> #include<algorithm> #include<cstring> #include<queu
splay 模板
09-05
splay经典代码,hdu1890,经典入门题,可作为模板
Splay（splay模板）
li_wen_zhuo的博客
04-08 405
题目描述 给定一个长度为 n 的整数序列，初始时序列为 {1,2,…,n−1,n}。 序列中的位置从左到右依次标号为 1∼n。 我们用 [l,r] 来表示从位置 l 到位置 r 之间（包括两端点）的所有数字构成的子序列。 现在要对该序列进行 m 次操作，每次操作选定一个子序列 [l,r]，并将该子序列中的所有数字进行翻转。 例如，对于现有序列 1 3 2 4 6 5 7，如果某次操作选定翻转子序列为 [3,6]，那么经过这次操作后序列变为 1 3 5 6 4 2 7。 请你求出经过 m 次操作后的序列。
splay【模板】
wpx18182323的博客
08-14 1385
题目描述 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 插入 x 数 删除 x 数(若有多个相同的数，因只删除一个) 查询 x 数的排名(排名定义为比当前数小的数的个数 +1+1 。若有多个相同的数，因输出最小的排名) 查询排名为 x 的数 求 x 的前驱(前驱定义为小于 x ，且最大的数) 求 x 的后继(后继定义为大于 x ，且最小的数) 输入输...
费用流（模板）
gyr
01-11 295
费用流模板 spfa不停找当前从s到t的最小费用路，然后刷新最大流 这里把每条边的cost为0，同样就可以求最大流，不过有点慢 #include #include #include #include #include #include #include #include #include #include #include #include using namespa
算法题C&C++模板.zip
最新发布
07-03
AC自动机、hash函数、splay、划分树、后缀数组、字典树、并查集、树状数组、线段树 动态规划、图论、字符串、数学、数据结构、杂题、计算几何 AC自动机、hash函数、splay、划分树、后缀数组、字典树、并查集、树状...
C++一些提高+的模板
08-26
包括树剖，线段树，splay，Treap，网络流，RMQ，数论函数求值，主席树，树状数组，LCA，CRT，BSGS，树套树等模板。（注：其中的两个cdq模板都没用的，整体二分写错了，其余模板可以自行测试。 p.s.有些可能与一些已...
ACM程序设计竞赛模板完全版
03-09
ACM程序设计竞赛模板完全版是一份针对ACM国际大学生程序设计竞赛（ACM-ICPC）的综合算法和数据结构实现的模板参考。这些模板是竞赛中常用的算法和数据结构的高效实现，包括但不限于动态规划、莫队算法、数据结构等。...
Splay（伸展树）模板
01-10
Splay模板包括旋转，主函数Splay，插入，删除，最大值，最小值，查询k大，查询排名
acm-icpc模板
05-02
根据提供的文件信息，可以看出这是一份关于ACM-ICPC竞赛中的编程模板和技术知识点的概述。下面将对这些知识点进行详细的解释与总结。 ### ACM-ICPC模板 #### Introduction ACM-ICPC（国际大学生程序设计竞赛）是...
权值线段树模板+练习题整理（刷题中）
蒲公英殇的博客
03-09 860
权值线段树自己的一些练习
Splay模板及部分理解
addmission的博客
02-24 627
Splay模板及部分理解 理解 Splay树在所有的操作中，其实都没有对于val进行比较，它维护的是一个序列的中序遍历，这满足一个的左根右的顺序，那么只要我们在插入时以左根右顺序找位置插入，那么最后的结果就是，中序遍历是一个从小到大的过程，即也维护了左小右大。（个人理解，不知正确与否） 代码模板 #include <cstdio> #include <cstring> #include <iostream> #include <algorithm> usin
splay模板（功能最全）
huzujun的博客
08-03 3760
回想起来splay大概是高中时的噩梦吧，手敲splay的确挑战太大了，不过到了acm时期，其实应该是不用惧怕splay的，把板子准备好就问题不大。 poj3580 虽然不是最简单的题，但是可以作为板子题 https://vjudge.net/problem/POJ-3580 题目大意： 要求实现一种数据结构，支持对一个数字序列的 6 种操作： ADD x y val：第 x...
图解splay / splay模板 / p3369
m0_54646258的博客
07-05 320
splay 解决了平衡树中的很多问题， 用图的方式将 splay 算法展示出来
Splay终极模板
zz_ylolita
04-04 1741
写了各种Splay，以下这个版本最让我满意：）。。所以叫“终极”。。。风格飘逸，时间短，代码短也没有恶意缩行。融合各神犇之精华。46 437391(5) SpaceQ 1328 KB 136 MS C++ 1557 B 2013-06-19 23:05:14 非常满意。不加读入优化BZOJ46名。一会儿我试试读入优化的效果。加读入优化以后22 437435(6) SpaceQ
【模板】伸展树Splay（数组实现）
zxyoi_dreamer的博客（不定期诈尸）
10-03 282
参考题目：LOJ107 解析： 联赛完后统一更模板题题解。 代码： #include&amp;lt;bits/stdc++.h&amp;gt; using namespace std; #define ll long long #define re register #define gc getchar #define pc putchar #define cs const inline int getin...
ACM-ICPC算法比赛模板大全
10. **数据结构**：如并查集、树状数组、线段树、字典树、Splay树、ST表和划分树、树链剖分及Link-Cut Tree等，这些数据结构用于高效处理各种查询和更新操作。 11. **图论**：包括强连通分量、最短路算法（Dijkstra...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值