方格取数问题 线性规划网络流

方格取数问题

有一网格，每个格子有一定价值的物品，拿了某个格子的物品，则不能拿去其上下左右的物品
怎样使得价值最大
将问题抽象为黑白格 取黑则不能取上下左右的格子(白色) 白色则相反

构建网络
源点 黑色方格 白色方格 汇点
源点–>黑色方格 容量:黑色方格价值
白色方格–>汇点 容量:白色方格价值
黑色方格–>白色方格 :两方格相邻，且容量为正无穷

切割线 :切中的边容量为没有选中的方格权值
则使其最小，达到了选中方格总权值最大

#include<iostream>
#include<cstring>
#include<queue>
#include<algorithm>
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 * N];//标记染黑色的节点
bool dfsflag[N * 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, total, sum = 0;
    int map[N][N];
    memset(flag, 0, sizeof(flag));
    memset(dfsflag, 0, sizeof(dfsflag));
    int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};//右下左上四个方向
    cout << "输入行数与列数\n";
    cin >> m >> n;
    init();
    total = m * n;
    cout << "依次输入每行每个商品的价值\n";
    for (int i = 1; i <= m;i++){
        for (int j = 1; j <= n;j++){
            cin >> map[i][j];
            sum += map[i][j];//总价值
        }
    }
    //创建网络
    for (int i = 1; i <= m;i++){
        for (int j = 1; j <= n;j++){
            if((i+j)%2==0){//黑块
                add(0, (i - 1) * n + j, map[i][j]);//源点到黑块
                flag[(i - 1) * n + j] = 1;//标记为黑色
                //向周围的四个相邻的块发出一条有向边,容量为无穷大
                for (int k = 0; k < 4;k++){
                    int x = i + dir[k][0];
                    int y = j + dir[k][1];
                    if(x<=m&&x>0&&y<=n&&x>0){//范围限制
                        add((i - 1) * n + j, (x - 1) * n + y, INF);
                    }
                }
            }else{//白块
                //当前节点到汇点
                add((i - 1) * n + j, total + 1, map[i][j]);
            }
        }
    }
    cout << "最大价值:\n";
    cout << sum - Isap(0, total + 1, total + 2) << endl;
    cout << "最佳方案:\n";
    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;
}


//分割线分割
void DFS(int s){
    for (int i = V[s].first; ~i;i=E[i].next){
        if(E[i].cap>E[i].flow){
            int u = E[i].v;
            if(!dfsflag[u]){
                dfsflag[u] = true;
                DFS(u);
            }
        }
    }
}

void print(int m,int n){
    DFS(0);
    for (int i = 1; i <= m * n;i++){
    	//是被探索到的黑节点(cap>flow)   或者   是白色节点没被割(cap>flow) 
        if((flag[i]&&dfsflag[i])||(!flag[i]&&!dfsflag[i])){
            cout << i << " ";
        }
    }
}

/*test
4 4
10 8 5 2
1 3 9 15
5 10 13 7
24 12 20 14

result:
84
最佳方案:
1 3 8 10 13 15
*/