flow

ubuntu环境下mitmproxy的安装配置详见： ubuntu环境下使用mitmproxy代理服务器 根据以上的连接，可以成功配置mitmproxy。 接下来，我们就要使用mitmproxy来拦截修改请求。由于猫眼使用的是对webdriver标示进行检测，所以我们可以拦截修改这个标示。拦截配置代码如下，按代码所示，如果拦截成功，会输出100个*的提示 proxy.py def response(flow): if 'webdriver' in flow.response.text: print('*' * 100) print('find web_driver key') flow.response.text = flow.response.text.replace("webdriver", "fuck_that_1") if 'Webdriver' in flow.response.text: print('*' * 100) print('find web_driver key') flow.response.text = flow.response.text.replace("Webdriver", "fuck_that_2") if 'WEBDRIVER' in flow.response.text: print('*' * 100) print('find web

一、介绍说明 mitmproxy是一个支持HTTP和HTTPS的抓包程序，有类似Fiddler、Charles的功能，只不过它是一个控制台的形式操作。 mitmproxy还有两个关联组件。一个是mitmdump,它是mitmproxy的命令行接口，利用它我们可以对接Python脚本，用Python实现监听后的处理。另一个是mitmweb，它是一个Web程序，通过它我们可以清楚观察mitmproxy捕获的请求。 mitmproxy的功能： 1、拦截HTTP和HTTPS请求和响应 2、保存HTTP会话并进行分析 3、模拟客户端发起请求，模拟服务器端返回响应 4、利用反向代理将流量转发给指定的服务器 5、支持Mac和linux上的透明代理 6、利用Python对HTTP请求与响应进行实时处理 mitmproxy运行与自己的PC上，在PC的8080端口运行，然后开启一个代理服务，这个服务实际上是一个HTTP/HTTPS的代理。 手机和PC在一个局域网内，设置代理是mitmproxy的代理地址，这样手机在访问互联网的时候流量数据包就会流经mitmproxy，mitmproxy再去转发这些数据包到真实的服务器，服务器返回数据包时再由mitmproxy转发回手机，这样mitmproxy就相当于起了中间人的作用，抓取到所有request和response，另外这个过程还可以对接mitmproxy

本题可以把求解的目标转换成从1到N两条不相交的路径，回想上一题，通过拆点来限制一边只能过一次，capacity为1，cost为-1来跑最大费用流，注意1点和N点的capacity要为2，因为需要过2次，答案就是最大费用流-2，本题的收获是输出路径，从每个点的出点出发(虚点)枚举其连接的下一个入点(实点)，然后输出该入点，再dfs出点，如果只有一条边但有从1到N的边，也能输出答案，要考虑edge case #include<bits/stdc++.h> using namespace std; #define lowbit(x) ((x)&(-x)) typedef long long LL; const int maxm = 1e5+5; const int INF = 0x3f3f3f3f; struct edge{ int u, v, cap, flow, cost, nex; } edges[maxm]; int head[maxm], cur[maxm], cnt, fa[maxm], d[maxm]; bool inq[maxm], vis[555]; map<string, int> cache; map<int, string> store; void init() { memset(head, -1, sizeof(head)); } void add(int u,

费用流问题，每个样本选一次，就连一条capacity为1，权为给定的值，因为可以重复走，再连capacity为无穷，权为0的边，再一次连接给定的出点和汇点即可 #include<bits/stdc++.h> using namespace std; #define lowbit(x) ((x)&(-x)) typedef long long LL; const int maxm = 3e3+5; const int INF = 0x3f3f3f3f; struct edge{ int u, v, cap, flow, cost, nex; } edges[maxm]; int head[maxm], cur[maxm], cnt, fa[1024], d[1024], p, q; bool inq[1024]; void init() { memset(head, -1, sizeof(head)); } void add(int u, int v, int cap, int cost) { edges[cnt] = edge{u, v, cap, 0, cost, head[u]}; head[u] = cnt++; } void addedge(int u, int v, int cap, int cost) { add(u, v, cap, cost), add(v, u,

有限制的问题，显然考虑全选再根据限制去掉的想法较优，我们发现一个点四周的点受限，其x或者y差一，也就是说奇偶性不同，那我们可以将其分成白点和黑点，就变成了最小割的问题，将每个白点向受限制的黑点连边，capacity为INF，每个黑点向汇点连边，capacity为该点的值，同理，源点向每个白点连边，这样受限的每一组之间都只会选出一个最小的来，通过capacity的限制来实现，最大流=最小割，将总和减去最小割(每一组最小的)就是答案 每一组黑白点，capacity来限制最小权，转换求最小割 #include<bits/stdc++.h> using namespace std; #define lowbit(x) ((x)&(-x)) typedef long long LL; const int maxm = 1e5+5; const int INF = 0x3f3f3f3f; const int dx[] = {1, -1, 0, 0}; const int dy[] = {0, 0, 1, -1}; struct edge{ int u, v, cap, flow, nex; } edges[maxm]; int head[maxm], cur[maxm], cnt, level[10005], buf[105][105], num[105][105], ID; void

简单的费用流问题，每个人对每个任务连边，每个任务对汇点连，源点对每个人连，最大费用取反即可 #include<bits/stdc++.h> using namespace std; #define lowbit(x) ((x)&(-x)) typedef long long LL; const int maxm = 2e4+5; const int INF = 0x3f3f3f3f; struct edge{ int u, v, cap, flow, cost, nex; } edges[maxm]; int head[maxm], cur[maxm], cnt, fa[333], d[333], n, val[105][105]; bool inq[333]; void init() { memset(head, -1, sizeof(head)); } void add(int u, int v, int cap, int cost) { edges[cnt] = edge{u, v, cap, 0, cost, head[u]}; head[u] = cnt++; } void addedge(int u, int v, int cap, int cost) { add(u, v, cap, cost), add(v, u, 0, -cost); } bool spfa

简单的最大流问题，一样的设源点汇点，每个单位向每个餐桌连capacity为1的边，源点向每个单位连capacity为人数的边，每个餐桌向汇点连capacity为座位数的边，跑最大流，若flow=总人数则有方案，遍历每一个单位流量为1的点即可 #include<bits/stdc++.h> using namespace std; #define lowbit(x) ((x)&(-x)) typedef long long LL; const int maxm = 1e5+5; const int INF = 0x3f3f3f3f; struct edge{ int u, v, cap, flow, nex; } edges[maxm]; int head[maxm], cur[maxm], cnt, level[1024]; void init() { memset(head, -1, sizeof(head)); } void add(int u, int v, int cap) { edges[cnt] = edge{u, v, cap, 0, head[u]}; head[u] = cnt++; } void addedge(int u, int v, int cap) { add(u, v, cap), add(v, u, 0); } void bfs(int s) {

题面 题解 选某个点就必须选其他的点 最大权闭合子图 Code #include <algorithm> #include <iostream> #include <cstring> #include <cstdio> #include <queue> const int N = 505; const int INF = 0x3f3f3f3f; using namespace std; int n, x[N], y[N], r[N], S, T, cnt = 1, head[N], d[N], cur[N], sum; struct edge { int to, nxt, flow; } e[N * N * 4]; queue<int> q; template < typename T > inline T read() { T x = 0, w = 1; char c = getchar(); while(c < '0' || c > '9') { if(c == '-') w = -1; c = getchar(); } while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar(); return x * w; } int mabs(int x) { return x > 0 ? x : -x; } inline

第一问可以直接DP来做，联想上一题，线性规划都可以化为网络流？我们可以借助第一问的DP数组，来建立第二问第三问的网络流图，考虑每一种可能，都是dp数组中满足num[i]>=num[j]&&dp[i]=dp[j]+1(i>j)，每一种可能都是从dp为1的点递增到dp为第一问的值的点，那么我们就设一个源点一个汇点，每个源点向dp为1的点连capacity为1的边，每个dp为第一问答案的点向汇点连capacity为1的边，每一个满足dp条件，即num[i]>=num[j]&&dp[i]=dp[j]+1(i>j)，从j向i连一条capacity为1的边，跑最大流即可，但是，我们注意到，题目要求是不同的，不重复的，而我们的做法无法考虑一个点是否重复使用，举个例子(丑图上 在这种情况下，第一个节点重复使用了，显然不满足题意，那我们怎么做呢，要满足不重复的条件，可以把每个点拆成入点和出点，入点向出点连一条capacity为1的边，就能完美的保证每个点只使用一次啦，相同情况如下，能保证只使用一次 #include<bits/stdc++.h> using namespace std; #define lowbit(x) ((x)&(-x)) typedef long long LL; const int maxm = 3e3+5; const int INF = 0x3f3f3f3f;

好像是最大权闭合图，也就是最大流最小割啦，找出最大流的路径输出，这题如何建模呢，一样的先设源点和汇点，源点向每个计划连capacity为赞助数的边，每个计划连相应装置capacity为无穷的边，每个装置向汇点连capacity为支付费用的边，这样，最大利润就是赞助总数-最大流啦，如何证？看两个例子 若是可行方案，相减即为利润，若是不可行方案，相减就为0，数学归纳法可推知n个时也对 另一个问题，如何找到最大权闭合图呢，最后一次分层的level数组就可以帮忙了，我们知道退出dinic算法就是无法到达汇点，考虑如何分层，满足两个条件，capacity大于flow且尚未分层，我们知道，对答案有贡献的是到计划的那条边的capacity比其相应的装置的capacity加起来还要大，最后一次分层时，即已经达到最大流，若从源点到某个计划无法分层，说明其capacity<=对应装置的，那就一定不选，能分层的一定是源有余而汇不进，又计划和装置之间的流量是无穷，则一定可以分层，直接考虑最后一层的level数组并输出即可，附上别个大佬的解释( #include<bits/stdc++.h> using namespace std; #define lowbit(x) ((x)&(-x)) typedef long long LL; const int maxm = 1e4+5; const int INF