CSDN编程竞赛第32期题解

 CSDN编程竞赛报名地址：https://edu.csdn.net/contest/detail/46

1.  题目名称：传奇霸业

        传奇霸业，是兄弟就来干。小春(HP == a)遇到了一只黄金哥布林(HP == x)。小春每次能对哥布林造成b点伤害，哥布林每次能对小春造成y点伤害。作为玩家的小春怎么可能随便让哥布林打死呢！他有治疗神药，每次能恢复c点HP。 HP无上限。小春需要操作多少次才能打死哥布林？（治疗+攻击） 

        数据范围小，直接模拟。

#include <bits/stdc++.h>
using namespace std;
int main()
{
    int a, b, c, x, y;
    scanf("%d%d%d%d%d", &a, &b, &c, &x, &y);
    int ans = 0;
    while (x > 0)
    {
        if (b < x && y >= a)
            a += c, a -= y;
        else
        {
            a -= y;
            x -= b;
        }
        ++ans;
    }
    printf("%d\n", ans);
    return 0;
}

2. 题目名称：严查枪火 

        X国最近开始严管枪火。像是“ak”,“m4a1”,“skr”。都是明令禁止的。 现在小Q查获了一批违禁物品其中部分是枪支。小Q想知道自己需要按照私藏枪火来关押多少人。（只有以上三种枪被视为违法） 

        根据题意直接判断输入的字符串即可。

#include <bits/stdc++.h>
using namespace std;
int main()
{
    string s;
    int n, ans = 0;
    cin >> n;
    for (int i = 0; i < n; ++i)
    {
        cin >> s;
        if (s == "ak" || s == "m4a1" || s == "skr")
            ++ans;
    }
    cout << ans << endl;
    return 0;
}

3. 题目名称：蚂蚁家族 

        小蚂蚁群是一个庞大的群体，在这个蚂蚁群中有n只小蚂蚁 ，为了保证所有蚂蚁在消息传送的时候都能接收到消息，需要在他们之间建立通信关系。就是要求小蚂蚁都可以通过多只或者直接联系到其他人。已知几条小蚂蚁之间有通信关系，请问还需要再新建至少多少条关系？ 

         根据题意，已知几条小蚂蚁之间有通信关系可以构成若干个连通块，问最少要加几条边使得所有的连通块连通，那么需要的边数就是连通块的数目减一。可以用并查集维护连通块。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
int fa[maxn];
int find(int x)
{
    return fa[x] == x ? x : fa[x] = find(fa[x]);
}
void unite(int x, int y)
{
    int fx = find(x), fy = find(y);
    if (fx == fy)
        return;
    fa[fx] = fy;
}
int main()
{
    int n, m, x, y;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i)
        fa[i] = i;
    for (int i = 0; i < m; ++i)
    {
        scanf("%d%d", &x, &y);
        unite(x, y);
    }
    int ans = 0;
    for (int i = 1; i <= n; ++i)
        if (find(i) == i)
            ++ans;
    printf("%d\n", ans - 1);
    return 0;
}

4. 题目名称：运输石油 

        某石油公司需要向A、B两地运输石油。两地的需求量不同，而一辆车只能装载一定量的石油。经过计算A地需要a辆车，B 地需要b辆车运输才能满足需求。现在一共有n辆车分布在各地，每辆车前往A、B两地运输石油均可以获得一定不等的利润。现在请你安排a辆车前往A地，b辆车前往B地运输石油，使得在满足A、B两地石油需求的前提下，获得最大的利润。 每辆车只能前往一地运输石油。 

        我的做法是最小费用流，建图如下：

S是源点，T是汇点，S1和S2分别用来表示需要a辆车和b辆车。C1到Cn是辅助节点，C_i到T容量1表示每辆车只能选择去A地或者B地。S1->a_i的边容量为1，费用为-A_i。跑最小费用最大流即可。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 3010;
const int maxm = 200010;
const int INF = 0x3f3f3f3f;
struct E
{
    int to, next, cap, flow, cost;
} edge[maxm];
int head[maxn], tol;
inline void Addedge(int u, int v, int w, int c)
{
    edge[tol].to = v;
    edge[tol].cap = w;
    edge[tol].flow = 0;
    edge[tol].cost = c;
    edge[tol].next = head[u];
    head[u] = tol++;
    edge[tol].to = u;
    edge[tol].cap = edge[tol].flow = 0;
    edge[tol].cost = -c;
    edge[tol].next = head[v];
    head[v] = tol++;
    return;
}
struct Spfaflow
{
    int d[maxn], cur[maxn], s, t, n;
    bool vis[maxn];
    queue<int> Q;
    inline void init()
    {
        memset(head, -1, sizeof(head));
        tol = 0;
    }
    inline bool spfa()
    {
        memset(d, 0x3f, sizeof(int) * n);
        memset(vis, 0, sizeof(bool) * n);
        d[s] = 0;
        Q.push(s);
        while (!Q.empty())
        {
            int u = Q.front();
            Q.pop();
            vis[u] = 0;
            for (int i = head[u]; i != -1; i = edge[i].next)
            {
                int v = edge[i].to;
                if (edge[i].cap > edge[i].flow && d[v] > d[u] + edge[i].cost)
                {
                    d[v] = d[u] + edge[i].cost;
                    if (!vis[v])
                    {
                        vis[v] = 1;
                        Q.push(v);
                    }
                }
            }
        }
        return d[t] != INF;
    }
    inline int dfs(int u, int a)
    {
        if (u == t)
            return a;
        int f = 0;
        vis[u] = 1;
        for (int &i = cur[u]; i != -1; i = edge[i].next)
        {
            int v = edge[i].to;
            if (!vis[v] && edge[i].cap > edge[i].flow && d[v] == d[u] + edge[i].cost)
            {
                int tmp = dfs(v, min(a, edge[i].cap - edge[i].flow));
                if (tmp)
                {
                    edge[i].flow += tmp;
                    edge[i ^ 1].flow -= tmp;
                    f += tmp;
                    a -= tmp;
                    if (!a)
                        break;
                }
            }
        }
        return f;
    }
    inline int Maxflow(int s, int t, int n, int &cost)
    {
        this->s = s, this->t = t, this->n = n;
        int ans = 0;
        while (spfa())
        {
            memcpy(cur, head, sizeof(int) * n);
            while (1)
            {
                memset(vis, 0, sizeof(bool) * n);
                int tmp = dfs(s, INF);
                if (!tmp)
                    break;
                ans += tmp;
                cost += tmp * d[t];
            }
        }
        return ans;
    }
} S;
int main()
{
    int n, a, b, x, y;
    S.init();
    scanf("%d%d%d", &n, &a, &b);
    int s = 0, s1 = 3 * n + 1, s2 = s1 + 1, t = s2 + 1;
    Addedge(s, s1, a, 0);
    Addedge(s, s2, b, 0);
    for (int i = 1; i <= n; ++i)
    {
        scanf("%d%d", &x, &y);
        Addedge(s1, i, 1, -x);
        Addedge(s2, i + n, 1, -y);
        Addedge(i, i + 2 * n, 1, 0);
        Addedge(i + n, i + 2 * n, 1, 0);
        Addedge(i + 2 * n, t, 1, 0);
    }
    int cost = 0;
    S.Maxflow(s, t, t + 1, cost);
    printf("%d\n", -cost);
    return 0;
}