GDOI2014 拯救莫莉斯

问题描述

莫莉斯·乔是圣域里一个叱咤风云的人物，他凭借着自身超强的经济头脑，牢牢控制了圣域的石油市场。

圣域的地图可以看成是一个n*m的矩阵。每个整数坐标点(x , y)表示一座城市（1<=x<= n, 1<=y<=m）。两座城市间相邻的定义为：对于城市(Ax, Ay)和城市(Bx, By)，满足(Ax - Bx)2 + (Ay - By)2 = 1。

由于圣域的石油贸易总量很大，莫莉斯意识到不能让每笔石油订购单都从同一个油库里发货。为了提高效率，莫莉斯·乔决定在其中一些城市里建造油库，最终使得每一个城市X都满足下列条件之一：

1.该城市X内建有油库，

2.某城市Y内建有油库，且城市X与城市Y相邻。

与地球类似，圣域里不同城市间的地价可能也会有所不同，所以莫莉斯想让完成目标的总花费尽可能少。如果存在多组方案，为了方便管理，莫莉斯会选择建造较少的油库个数。

输入格式

第一行两个正整数n,m ( n * m <= 50 且m<=n)，表示矩阵的大小。

接下来一个n行m列的矩阵F，Fi, j表示在城市(i,j)建造油库的代价。

输出格式

输出两个数，建造方案的油库个数和方案的总代价。

 

输入样例：	输出样例：
3 3 6 5 4 1 2 3 7 8 9	3 6

数据范围

对于30%数据满足 n * m <= 25;

对于100%数据满足n * m <= 50; 0 <= Fi, j <= 100000

solution：

　　　　很简单的状压dp，然而考试的时候想成了网络流，f[i][j][k]表示到第i层上一层状态为j这一层状态为k的最小花费，

f[i+1][k][x]=min(f[i][j][k]+cost[i+1][x]);这个cost数组需要预处理出来，表示每一层每一个状态对应的花费，还有一个附加数组g[i][j][k]，表示这个状态下的油库数量，最后答案为min（f[i+1][j][0]）

　　　　

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int read() {
    int s=0,f=1;
    char ch=getchar();
    while(ch>'9'||ch<'0') {
        if(ch=='-') {
            f=-1;
        }
        ch=getchar();
    }
    while(ch>='0'&&ch<='9') {
        s=(s<<1)+(s<<3)+(ch^48);
        ch=getchar();
    }
    return s*f;
}
int f[52][1<<7|1][1<<7|1],g[52][1<<7|1][1<<7|1];
int sum[1<<7|1],n,m,val[52][52],cost[52][1<<7|1];
int lowbit(int x) {
    return x&(-x);
}
int get(int x) {
    int ans=0;
    while(x) {
        x-=lowbit(x);
        ans++;
    }
    return ans;
}
void init() {
    for(int i=0; i<=(1<<m); i++) {
        sum[i]=get(i);
    }
    for(int i=1; i<=n; i++) {
        for(int j=0; j<(1<<m); j++) {
            for(int k=1; k<=m; k++) {
                if((1<<(k-1))&j) {
                    cost[i][j]+=val[i][k];
                }
            }
        }
    }
    memset(f,0x5f,sizeof(f));
    memset(g,0x5f,sizeof(g));
    for(int i=0; i<(1<<m); i++) {
        f[1][0][i]=cost[1][i];
        g[1][0][i]=sum[i];
    }
}
void dp() {
    for(int i=1; i<=n; i++) {
        for(int j=0; j<(1<<m); j++) { //shangyiceng
            for(int k=0; k<(1<<m); k++) { //benceng
                if(f[i][j][k]>=1600085850) {
                    continue;
                }
                for(int x=0; x<(1<<m); x++) {
                    if(((x|j|k|(k<<1)|(k>>1))&((1<<m)-1))==((1<<m)-1)) {
                        if(f[i+1][k][x]>=f[i][j][k]+cost[i+1][x]) {
                            if(f[i+1][k][x]==f[i][j][k]+cost[i+1][x]) {
                                g[i+1][k][x]=min(g[i+1][k][x],g[i][j][k]+sum[x]);
                            } else {
                                g[i+1][k][x]=g[i][j][k]+sum[x];
                            }
                            f[i+1][k][x]=f[i][j][k]+cost[i+1][x];
                        }
                    }
                }
            }
        }
    }
}
struct node {
    int f,g;
    friend bool operator < (node a,node b) {
        return (a.f==b.f)?(a.g<b.g):(a.f<b.f);
    }
} proj[1<<7|1];
int main() {
    n=read();
    m=read();
    for(int i=1; i<=n; i++) {
        for(int j=1; j<=m; j++) {
            val[i][j]=read();
        }
    }
    init();
    dp();
    int ans_f=0x7fffffff,ans_g=0x7fffffff;
    int kk=0;
    for(int i=0; i<(1<<m); i++) {
        if(f[n+1][i][0]<=ans_f) {
            if(ans_f==f[n+1][i][0]) {
                ans_g=min(ans_g,g[n+1][i][0]);
            } else {
                ans_g=g[n+1][i][0];
            }
            ans_f=f[n+1][i][0];
        }
    }
    cout<<ans_g<<" "<<ans_f;
    return 0;
}