ZOJ 3613

https://cn.vjudge.net/problem/ZOJ-3613

题意：

n 个星球，每个星球 p 个工厂，s 个资源，给出 m 条路及其代价，一个医院只能对应一个工厂，求出可以获得资源的最多工厂数及其对应的最低代价。

分析：

几乎是裸题了。有几个注意点：

如果一个星球既有资源又有工厂，那么不需要建路，直接就可以用，但是用了以后这个星球的资源就没了，被占用了。

最后枚举状态时，check 检查的是这个状态的工厂数和资源数是不是前者大于后者，如果不是就不用做，这点好好想想，因为肯定会浪费嘛。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <bitset>
#include <map>
typedef long long int ll;
const int MOD = (int)1e9 + 7;
const int INF = 99999999;
using namespace std;

struct Edge
{
    int v, w;
    int next;
};

int n, m;
int cnt;
int top;
int head[210];
Edge edge[10010];
int state[210];
int dp1[210][1 << 8];
int dp2[1 << 8];
int vis[210][1 << 8];
int p[210];
int s[210];
int fac[4];
int fac_num;
int res_num;
queue<pair<int, int> > Q;

void add_edge(int u, int v, int w)
{
    edge[cnt].v = v;
    edge[cnt].w = w;
    edge[cnt].next = head[u];
    head[u] = cnt++;

    edge[cnt].v = u;
    edge[cnt].w = w;
    edge[cnt].next = head[v];
    head[v] = cnt++;
}

void spfa()
{
    while (!Q.empty())
    {
        int u = Q.front().first;
        int s = Q.front().second;
        Q.pop();
        vis[u][s] = 0;

        for (int i = head[u]; i != -1; i = edge[i].next)
        {
            int v = edge[i].v;
            int w = edge[i].w;
            int ss = s | state[v];
            if (dp1[v][ss] > dp1[u][s] + w)
            {
                dp1[v][ss] = dp1[u][s] + w;

                if (s == ss && !vis[v][ss])
                {
                    Q.push(make_pair(v, ss));
                    vis[v][ss] = 1;
                }
            }
        }
    }
}

bool check(int s)
{
    int num = 0;
    for (int i = 0; s != 0; i++)
    {
        if (s & 1)
            num += (i < fac_num) ? fac[i] : -1;

        s >>= 1;
    }

    return (num >= 0);
}

int count_res(int s)
{
    int num = 0;
    for (int i = 0; s != 0; i++)
    {
        if (s & 1)
            num += (i < fac_num) ? 0 : 1;

        s >>= 1;
    }

    return num;
}

int main()
{
    while (~scanf("%d", &n))
    {
        int ans = 0;
        cnt = 0;
        fac_num = res_num = 0;
        memset(vis, 0, sizeof(vis));
        memset(head, -1, sizeof(head));
        memset(state, 0, sizeof(state)); // 初始化要记住
        for (int i = 0; i < (1 << 8); i++)
        {
            for (int j = 0; j < n; j++)
                dp1[j][i] = INF;

            dp2[i] = INF;
        }

        for (int i = 0; i < n; i++)
        {
            scanf("%d%d", p + i, s + i);
            if (p[i] && s[i]) // 如果这个星球有工厂且有资源，不用建虫洞直接就可以用
            {
                ans++; // 可以得到资源的工厂数量增加
                p[i]--;
                s[i]--;
            }
            if (p[i])
            {
                state[i] = 1 << fac_num;
                fac[fac_num++] = p[i];
                dp1[i][state[i]] = 0;
            }
        }
        for (int i = 0; i < n; i++)
        {
            if (s[i])
            {
                state[i] = 1 << (fac_num + res_num);
                res_num++;
                dp1[i][state[i]] = 0;
            }
        }

        top = 1 << (fac_num + res_num);

        scanf("%d", &m);
        int u, v, w;
        while (m--)
        {
            scanf("%d%d%d", &u, &v, &w);
            u--, v--;
            add_edge(u, v, w);
        }

        for (int i = 0; i < top; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (state[j] && !(i & state[j]))
                    continue;

                for (int sub = (i - 1) & i; sub != 0; sub = (sub - 1) & i)
                    dp1[j][i] = min(dp1[j][i], dp1[j][sub | state[j]] + dp1[j][(i - sub) | state[j]]);

                if (dp1[j][i] < INF)
                {
                    Q.push(make_pair(j, i));
                    vis[j][i] = 1;
                }
            }

            spfa();
        }

        for (int i = 0; i < top; i++)
            for (int j = 0; j < n; j++)
                dp2[i] = min(dp2[i], dp1[j][i]);

        int min_cost = 0; // 要注意没有可行方案的情况，应该输出 0 0
        int max_num = 0;
        for (int i = 0; i < top; i++)
        {
            if (check(i) && dp2[i] < INF)
            {
                for (int sub = (i - 1) & i; sub != 0; sub = (sub - 1) & i)
                    if (check(sub) && check(i - sub) && dp2[sub] < INF && dp2[i - sub] < INF)
                        dp2[i] = min(dp2[i], dp2[sub] + dp2[i - sub]);

                int res_num = count_res(i);
                if (res_num > max_num || (res_num == max_num && dp2[i] < min_cost))
                {
                    max_num = res_num;
                    min_cost = dp2[i];
                }
            }
        }

        printf("%d %d\n", ans + max_num, min_cost);
    }
    return 0;
}