POJ3040 Allowance 贪心

两种思路计算结果，最后输出最大的

#include <iostream>
#include <algorithm>
using namespace std;
struct Node
{
    int num, count;
    Node(int num = 0, int count = 0) : num(num), count(count) {}
};
bool compare(const Node &a, const Node &b)
{
    return a.num < b.num;
}
Node nodes[27], nodes1[27];
int occupy[27], ans = 0, ans1 = 0, N, C;
void input()
{
    scanf("%d%d", &N, &C);
    for (int i = 1; i <= N; i++)
    {
        scanf("%d%d", &nodes[i].num, &nodes[i].count);
    }
    sort(nodes + 1, nodes + N + 1, compare);
    for (int i = 1; i <= N; i++)
    {
        nodes1[i].num = nodes[i].num, nodes1[i].count = nodes[i].count;
    }
}
void preHandle()
{
    for (int i = N; i >= 1; i--)
    {
        if (nodes[i].num >= C)
        {
            ans += nodes[i].count;
            ans1 += nodes1[i].count;
            nodes[i].count = 0;
            nodes1[i].count = 0;
        }
        else
        {
            return;
        }
    }
}
void flushOccupy()
{
    for (int i = 1; i <= N; i++)
    {
        occupy[i] = 0;
    }
}
bool isPossible()
{
    int k = C;
    for (int i = N; i >= 1; i--)
    {
        if (nodes[i].count <= 0)
        {
            continue;
        }
        if (k % nodes[i].num == 0)
        {
            k = k - min(k / nodes[i].num, nodes[i].count) * nodes[i].num;
        }
        else if (k % nodes[i].num != 0)
        {
            k = k - min(k / nodes[i].num + 1, nodes[i].count) * nodes[i].num;
        }
        if (k <= 0)
        {
            return true;
        }
    }
    return false;
}
void findGroup()
{
    int k = C;
    for (int i = N; i >= 1; i--)
    {
        if (nodes[i].count <= 0)
        {
            continue;
        }
        if (k % nodes[i].num == 0)
        {
            occupy[i] = min(k / nodes[i].num, nodes[i].count);
            k = k - min(k / nodes[i].num, nodes[i].count) * nodes[i].num;
        }
        else if (k % nodes[i].num != 0)
        {
            k = k - nodes[i].num;
            occupy[i] = 1;
        }
        if (k <= 0)
        {
            return;
        }
    }
    for (int i = 1; i <= N; i++)
    {
        if (nodes[i].count <= 0 || nodes[i].count <= occupy[i])
        {
            continue;
        }
        if (k % nodes[i].num == 0)
        {
            occupy[i] += min(nodes[i].count - occupy[i], k / nodes[i].num);
            k = k - min(nodes[i].count - occupy[i], k / nodes[i].num) * nodes[i].num;
        }
        else
        {
            occupy[i] += min(nodes[i].count - occupy[i], k / nodes[i].num + 1);
            k = k - min(nodes[i].count - occupy[i], k / nodes[i].num + 1) * nodes[i].num;
        }
        if (k <= 0)
        {
            return;
        }
    }
}
void findGroup1()
{
    int k = C;
    for (int i = N; i >= 1; i--)
    {
        if (nodes1[i].count <= 0)
        {
            continue;
        }
        occupy[i] = min(k / nodes1[i].num, nodes1[i].count);
        k = k - min(k / nodes1[i].num, nodes1[i].count) * nodes1[i].num;
        if (k <= 0)
        {
            return;
        }
    }
    for (int i = 1; i <= N; i++)
    {
        if (nodes1[i].count <= 0 || nodes1[i].count <= occupy[i])
        {
            continue;
        }
        if (k % nodes1[i].num == 0)
        {
            occupy[i] += min(nodes1[i].count - occupy[i], k / nodes1[i].num);
            k = k - min(nodes1[i].count - occupy[i], k / nodes1[i].num) * nodes1[i].num;
        }
        else
        {
            occupy[i] += min(nodes1[i].count - occupy[i], k / nodes1[i].num + 1);
            k = k - min(nodes1[i].count - occupy[i], k / nodes1[i].num + 1) * nodes1[i].num;
        }
        if (k <= 0)
        {
            return;
        }
    }
}
bool isPossible1()
{
    int k = C;
    for (int i = N; i >= 1; i--)
    {
        if (nodes1[i].count <= 0)
        {
            continue;
        }
        if (k % nodes1[i].num == 0)
        {
            k = k - min(k / nodes1[i].num, nodes1[i].count) * nodes1[i].num;
        }
        else if (k % nodes1[i].num != 0)
        {
            k = k - min(k / nodes1[i].num + 1, nodes1[i].count) * nodes1[i].num;
        }
        if (k <= 0)
        {
            return true;
        }
    }
    return false;
}
void updateOccupy()
{
    int updateScale = 0x3f3f3f3f;
    for (int i = 1; i <= N; i++)
    {
        if (nodes[i].count <= 0 || occupy[i] <= 0)
        {
            continue;
        }
        updateScale = min(nodes[i].count / occupy[i], updateScale);
    }
    for (int i = 1; i <= N; i++)
    {
        if (nodes[i].count <= 0 || occupy[i] <= 0)
        {
            continue;
        }
        nodes[i].count = nodes[i].count - updateScale * occupy[i];
    }
    if (updateScale != 0x3f3f3f3f)
    {
        ans += updateScale;
    }
}
void updateOccupy1()
{
    int updateScale = 0x3f3f3f3f;
    for (int i = 1; i <= N; i++)
    {
        if (nodes1[i].count <= 0 || occupy[i] <= 0)
        {
            continue;
        }
        updateScale = min(nodes1[i].count / occupy[i], updateScale);
    }
    for (int i = 1; i <= N; i++)
    {
        if (nodes1[i].count <= 0 || occupy[i] <= 0)
        {
            continue;
        }
        nodes1[i].count = nodes1[i].count - updateScale * occupy[i];
    }
    if (updateScale != 0x3f3f3f3f)
    {
        ans1 += updateScale;
    }
}
void solve()
{
    preHandle();
    while (isPossible())
    {
        flushOccupy();
        findGroup();
        updateOccupy();
    }
    while (isPossible1())
    {
        flushOccupy();
        findGroup1();
        updateOccupy1();
    }
}
int main()
{
    input();
    solve();
    printf("%d\n", max(ans, ans1));
    return 0;
}