2020牛客多校第一场补题博客

一、Minimum-cost Flow (H)

题目链接： Minimum-cost Flow
题目大意： 这是一道最小费用流问题，现在存在一张图，有n个点，m条边，然后告诉你每条边的节点以及费用信息，并且每条边的容量都是相同的。现在有q次询问，每次给出边的容量，问你每次接收1单位流量的最小费用是多少。
解题思路： 前提条件：知道怎么求解最小费用流问题，并对其中的细节较为熟悉。 这道题你要知道在容量为$\frac{u}{v}$,总流量为1的情况和容量为u，总流量为v的情况，这两个情况的最小费用流的增广路情况是一样的，那么也就是说我们只需要跑一遍最小费用流，求出增广路的信息，然后费用进行放缩就可以了。这里我们把每一条边的容量设为1，然后求出最大流最小费用增广路的信息，现在我们的每一条增广路都代表1容量，但是我们其实是想把每条边的容量变成u，最后总容量为v,这样方便计算，也就是说v/u取下整代表充分利用的增广路的数量，v%u代表最后这条增广路只用到v%u容量。现在我们算出来的是总容量v的最小费用，我们只需要将这个费用除以v就得到，总容量为1的最小费用了。那么什么情况下，是不能满足条件的呢？很简单，那就是增广路的数量*每条增广路的容量小于总容量的情况就是不能满足条件的情况（具体细节看代码）
代码：

#include<iostream>
#include<iomanip>
#include<cmath>
#include<map>
#include<string>
#include<vector>
#include<set>
#include<queue>
#include<algorithm>
#include<string.h>
 
 
#define MAXN 55
#define INF 0x3f3f3f3f
#define P pair<int,int>
 
using namespace std;
struct edge
{
    int to, cap, cost, rev;
};
vector<edge> G[MAXN];
int h[MAXN];
int dist[MAXN], prevv[MAXN], preve[MAXN]; //dist：假最短距离
                                        //在最短路径中：prevv[i]表示i的前倾节点，preve[i]表示邻接表中的具体位置 
int n, m, s, t;//n顶点数\m边数\s源点\t汇点
 
long long  maxFlow, minCost; //当f为INF maxflow有效且为最大流。
vector<long long > Cost;
vector<long long > Sum;
 
void addedge(int from, int to, int cap, int cost)
{
    edge temp1 = { to, cap, cost, (int)G[to].size() };
    edge temp2 = { from, 0, -cost, (int)G[from].size() };
    G[from].push_back(temp1);
    G[to].push_back(temp2);
}
void MCMF(int s, int t, long long  f) //当f为INF时可以求出最大流最小费用
{
    fill(h + 1, h + 1 + n, 0);  //顶点编号从1开始 （1-n）
    while (f > 0)
    {
        //Dijkstra算法实现
        priority_queue<P, vector<P>, greater<P> > D;
        memset(dist, INF, sizeof dist);
        dist[s] = 0; D.push(P(0, s));
        while (!D.empty())
        {
            P now = D.top(); D.pop();
            if (dist[now.second] < now.first) continue;
            int v = now.second;
            for (int i = 0; i<(int)G[v].size(); ++i)
            {
                edge &e = G[v][i];
                if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to])
                {
                    dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
                    prevv[e.to] = v;
                    preve[e.to] = i;
                    D.push(P(dist[e.to], e.to));
                }
            }
        }
        if (dist[t] == INF) break;
        for (int i = 1; i <= n; ++i) h[i] += dist[i];
 
        Cost.push_back((long long)h[t]);  //我们将每一条增广路的信息存放起来 
        for (int v = t; v != s; v = prevv[v])
        {
            edge &e = G[prevv[v]][preve[v]];
            e.cap -= 1;
            G[v][e.rev].cap += 1;
        }
    }
}
void init()
{
    for(int i=1;i<=n;i++)
    G[i].clear();
    Cost.clear();
    Sum.clear();
}
int main()
{
    int q;
    int a[105]={0},b[105]={0},cost[105]={0};
    int u,v;
    long long ans;
    while(~scanf("%d%d",&n,&m))
    {
 
        init();
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&a[i],&b[i],&cost[i]);
            addedge(a[i],b[i],1,cost[i]);
        }
        MCMF(1,n,INF);
        Sum.push_back(Cost[0]);
        for(int i=1;i<Cost.size();i++)
        {
            Sum.push_back(Sum[i-1]+Cost[i]); //前缀和优化计算 
        }
        scanf("%d",&q);
        for(int i=0;i<q;i++)
        {
            ans=0;
            int flag;
            scanf("%d%d",&u,&v);
            if(Cost.size()*1ll*u<v) //增广路的数量*每条增广路的数量 
            printf("NaN\n");
            else
            {
//              for(int i=0;i<v/u;i++)
//              {
//                  ans+=Cost[i];
//                  flag=i+1;
//              }
                ans+=Sum[(v/u)-1];  //先算出有多少条边是满载的 
                ans*=u;
                ans+=Cost[v/u]*(v%u); //最后这条边的流量只有v%u  
                
                long long temp=__gcd(ans,(long long)v); //最后的费用 除以V就是总流量为1的最小费用 
                printf("%lld/%lld\n",ans/temp,v/temp);
            }  
        }
}
    return 0;
}

二、1 or 2（I）

题目链接： 1 or 2
题目大意： 给你一个图，有n个点，m条边，和一组每个点被要求的度，问你能不能从这个图中选择几条边来满足这个度的情况。
解题思路： 这个题可以构造成一个二分图匹配问题，把每个点分成两个点，其中一个与源点s相连，另一个与汇点y相连，这两条边的容量都是被要求的度的大小，在原来的图中，如果有两个点相连，那么在这个新图中也相连且容量为1（例如原来图中1和3相连，那么在新图中1和3*相连,3和1*相连）那么最后对这个新图求最大流，如果最大流刚好等于所有度的和，那么就可以满足条件，输出yes，否则输出no，这里还存在一个特殊情况 也就是度数之和不能为奇数，如果为奇数直接输出no。有人可能会问，为什么可以构造成这个样子，我们可以这样想，每个点的度，也就是所连的边的数量，我们把每条边假设有流量通过，在构造的新图中那么对于每个点来说，他可以选择一些边有流量通过，使得本身这个点总共的流量与所需求的度数相等，那么有流量的边就是被选中的边。（具体细节看代码）
代码：

#include<iostream>
#include<iomanip>
#include<cmath>
#include<map> 
#include<string>
#include<vector>
#include<set> 
#include<queue> 
#include<algorithm>
#include<string.h>
using namespace std;

const int INF=0x3f3f3f3f;
const int MAX_V=1e4;
struct edge{
    int to,cap,rev;     //终点，容量，反向边
};
vector<edge> G[MAX_V];  //图的邻接表表示
int level[MAX_V];       //顶点到原点的距离标号
int iter[MAX_V];        //当前弧，在其之前的边已经没有用了
int n,m;
int D[MAX_V];
//增加一条从from到to的容量为cap的边
void add_edge(int from,int to,int cap){
 
    G[from].push_back((edge){to,cap,G[to].size()});
 
    G[to].push_back((edge){from,0,G[from].size()-1});
 
}
 
//通过BFS计算从原点出发的距离标号
void bfs(int s){
    memset(level,-1,sizeof(level));
    queue<int > que;
    level[s]=0;
    que.push(s);
    while(!que.empty()){
        int v=que.front(); que.pop();
        for(int i=0;i<G[v].size();i++){
            edge& e=G[v][i];
            if(e.cap>0&&level[e.to]<0){
                level[e.to]=level[v]+1;
                que.push(e.to);
            }
        }
    }
}
 
 
//通过DFS寻找增广路
int dfs(int v,int t,int f){
    if(v==t) return f;
    for(int& i=iter[v]; i<G[v].size(); i++){
        edge& e=G[v][i];
        if(e.cap>0 && level[v]<level[e.to]){
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0){
                e.cap -= d;
                G[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}
 
 
//求解从s到t的最大流
int dinic(int s,int t){
    int flow=0;
    for(;;){
        bfs(s);
        if(level[t]<0) return flow;
        memset(iter,0,sizeof(iter));
        int f;
        while((f=dfs(s,t,INF))>0){
            flow+=f;
        }
    }
}
int main()
{
	int a,b,ans,tmp;
	int s,t;
	while(cin>>n>>m)
	{
		s=0;
		t=2*n+1;
		tmp=ans=0;
		for(int i=0;i<=2*n+1;i++)
		G[i].clear();
		for(int i=1;i<=n;i++) //每个点与源点汇点的信息 
		{
			scanf("%d",&D[i]);
			tmp+=D[i];
			add_edge(0,i,D[i]);
			add_edge(i+n,2*n+1,D[i]);
		}
		if(tmp%2==1)
		{
			printf("No\n");
		 	continue;
		}
		 
		for(int i=0;i<m;i++) //每个点之间的边的信息 
		{
			scanf("%d%d",&a,&b);
			add_edge(a,b+n,1);
			add_edge(b,a+n,1);
		}
		ans=dinic(s,t);  //算出最大流的的结果 
		if(tmp==ans)
		printf("Yes\n");
		else
		printf("No\n");
	}
	return 0;
}