最大收益问题 线性规划网络流

最大收益问题

一批实验 E={E1,E2…} 需要仪器集合 I={I1,I2,I3…}
进行Ei可盈利 pi 购入仪器Ii要花费ci
进行实验可盈利一定金额 没买一种仪器也要花费一定金额
怎样选实验 使得盈利最大?
实验净收益=选中实验项目收益 - 选中的仪器费用
选中实验项目收益=全部项目收益 - 未选中的项目收益
实验净收益= 全部项目收益 - (未选中的项目收益+选中的仪器费用)
切割线将图分为两部分 S T, S :选中的实验项目与仪器 T:未选中的实验项目与仪器
未选中的项目收益+选中的仪器费用= 切割线切中的边的容量
需要求出最小割 则 应该求出最大流

网络结构:
左为源点 右为汇点
中间从左到右有两层节点 第一层为实验项目 第二层为仪器
边:源点–>实验项目 容量为收益
每个实验项目到其依赖的仪器有边容量为正无穷
仪器–>汇点 容量为其花费

#include <iostream>
#include <queue>
#include <cstring>
using namespace std;
const int INF = 0x3fffffff;
const int N = 100;
const int M = 10000;
int top;
int h[N], pre[N], g[N];
bool flag[N]; //记录是否被选中
struct Vertex
{
    int first;
} V[N];
struct Edge
{
    int v, next;
    int cap, flow;
} E[N];
void init();
void add_edge(int u, int v, int c);
void add(int u, int v, int c);
void set_h(int t, int n);
int Isap(int s, int t, int n);
void DFS(int s);
void print(int m,int n);

int main(int argc, char **argv)
{
    int n, m, sum = 0, total;
    int cost, num;
    memset(flag, 0, sizeof(flag));
    cout << "输入实验数m和仪器数量n:\n";
    cin >> m >> n;
    init();
    total = m + n;
    cout << "依次输入实验产生的效益以及其需要的仪器编号 以0结束\n";
    for (int i = 1; i <= m; i++)
    {
        cin >> cost;
        sum += cost;
        add(0, i, cost);
        while (cin >> num, num)
        {
            add(i, m + num, INF);
        }
    }
    cout << "依次输入所有仪器的费用\n";
    for (int j = m + 1; j <= total; j++)
    {
        cin >> cost;
        add(j, total + 1, cost);
    }
    cout << "最大净收益为:" << sum - Isap(0, total + 1, total + 2) << endl;
    //输出一个最佳方案
	print(m,n);
    return 0;
}

void init()
{
    memset(V, -1, sizeof(V)); //初始化V[all].first=-1
    top = 0;                  //记录E[]使用到了那里了
}
//-->
void add_edge(int u, int v, int c)
{ //添加单条边
    //参数 u v及u-->v边的容量c
    E[top].v = v;
    E[top].cap = c;
    E[top].flow = 0;
    //头插法
    E[top].next = V[u].first;
    V[u].first = top;
    top++;
}
void add(int u, int v, int c)
{ //添加正负两边
    add_edge(u, v, c);
    add_edge(v, u, 0);
}
//-->
void set_h(int t, int n)
{                             //标高函数,t源点 n汇点
    queue<int> Q;             //广度优先搜索
    memset(h, -1, sizeof(h)); //初始化各结点的高为-1
    memset(g, 0, sizeof(g));  //全部高度的结点数量为0
    h[t] = 0;                 //汇点高度为0
    Q.push(t);                //汇点入队列
    while (!Q.empty())
    {
        int v = Q.front();
        Q.pop();   //对头出队列
        ++g[h[v]]; //高度为h[v]的数量+1
        for (int i = V[v].first; i != -1; i = E[i].next)
        { //遍历结点v的临界点及v-->some
            int u = E[i].v;
            if (h[u] == -1)
            { //还没有标记过
                h[u] = h[v] + 1;
                Q.push(u); //入队列
            }
        }
    }
    cout << "Init hight Value\n";
    cout << "h[ ]=";
    for (int i = 1; i <= n; i++)
    {
        cout << " " << h[i];
    }
    cout << endl;
}

//参数  s:源点 t:汇点 n:总结点个数
//返回值  网络最大流
int Isap(int s, int t, int n)
{ //isap增广算法
    //初始化标高
    set_h(t, n);        //从t-->n
    int ans = 0, u = s; //ans最大流量,u当前探索到的结点
    int d;
    while (h[s] < n)
    {
        int i = V[u].first;
        if (u == s)
        { //当前在源点时
            d = INF;
        }
        //搜索当前结点的邻接边
        for (; i != -1; i = E[i].next)
        {
            int v = E[i].v; //u-->v
            //判断是否满足探索条件：有可增量 且 h[u]-1=h[v]
            if (E[i].cap > E[i].flow && h[u] - 1 == h[v])
            {
                u = v;      //满足条件则当前位置移到v           E[i]
                pre[v] = i; //设置v结点的前驱为i 即记录边u------->v
                //迭代最小增量
                d = min(d, E[i].cap - E[i].flow);
                if (u == t)
                { //探索到了汇点
                    printf("增广路径:%d", t);
                    while (u != s)
                    {
                        int j = pre[u];     //即增广路汇点的前驱边E[j]
                        E[j].flow += d;     //E[j]流量增d
                        E[j ^ 1].flow -= d; //j的反向边流量-d
                        /*
                        ^1:创建边时是成对创建的0^1=1 1^1=0 2^1=3 3^1=2
                        */
                        u = E[j ^ 1].v;
                        cout << "---" << u;
                    }
                    printf("增流: %d\n", d);
                    ans += d;
                    d = INF;
                }
                break; //找到一条可行邻接边，退出for循环，停止寻找可行邻接边
            }
        }
        if (-1 == i)
        { //所有邻接边搜索完毕,无法前行
            if (--g[h[u]] == 0)
            { //该高度结点只有1个，算法结束
                break;
            }
            int hmin = n - 1;
            for (int j = V[u].first; j != -1; j = E[j].next)
            { //搜索u的邻接边
                if (E[j].cap > E[j].flow)
                { //有可增量
                    hmin = min(hmin, h[E[j].v]);
                }
            }
            h[u] = hmin + 1;
            printf("重贴标签后的高度\n");
            printf("h[ ]=");
            for (int i = 1; i <= n; i++)
            {
                printf(" %d", h[i]);
            }
            printf("\n");
            ++g[h[u]]; //重新贴标签后该高度的结点数+1
            if (u != s)
            {                        //当前结点不是源点
                u = E[pre[u] ^ 1].v; //退回一步
            }
        }
    }
    return ans;
}

//分集合S与T 深度优先探索 
//s:源点 
void DFS(int s){
	for(int i=V[s].first;~i;i=E[i].next){//遍历当前节点的邻接表 
		//容量大于流量  容量>流量这个项目肯定能盈利 但净盈利不能说是容量-流量 
		//可能这个实验的仪器费用被计费到了其他实验中，这个实验就不用花费这个仪器的钱了 
		//且cap==flow的项目也可能被选中的虽然看似不盈利但为别的项目做出了贡献 
		//但遍历到一个仪器节点时 这个仪器节点可能由多个实验共同承担费用 则 仪器到其实验节点有 cap=0 flow为负数 
		//则可以遍历到相关项目节点 
		if(E[i].cap>E[i].flow){
			int u=E[i].v;
			if(!flag[u]){
				flag[u]=true;
				DFS(u);
			} 
		}
	}
}

//输出选中方案 
void print(int m,int n){
	DFS(0);
	cout<<"选中实验:\n";
	for(int i=1;i<=m;i++){
		if(flag[i]){
			cout<<i<<" ";
		}
	}
	cout<<"\n选中的仪器:\n";
	for(int i=m+1;i<=m+n;i++){
		if(flag[i]){
			cout<<i-m<<" ";
		}
	}
	cout<<"\n";
}

/*
test sample
5 15
20 2 4 8 11 0
38 1 5 14 0
25 2 5 7 15 0
17 1 3 6 9 13 0
22 10 12 15 0
2 7 4 8 10 1 3 7 5 9 15 6 12 17 8

result:
最大净收益为:23
选中实验:
2 3 5
选中的仪器:
1 2 5 7 10 12 14 15
*/