思路

  此题最简单的办法那就是直接二分，因为数据量有限，我们可以对答案进行二分，每次求出一个mid后，将大于mid的红砖和蓝砖全部合成，若最后三砖数量均大于等于mid，则将左端点置为mid，否则将右端点置为mid-1

代码

c++

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        ll a,b,c,x,y;
        cin>>a>>b>>c>>x>>y;
        ll l=0,r=1e9;
        while(l<r)
        {
            int mid=(l+r+1)/2;
            ll a1=a;
            ll b1=b;
            ll c1=c;
            if(a1>mid)
            {
                int f=(a1-mid)/x;
                a1-=x*f;
                b1+=f;
            }
            if(b1>mid)
            {
                int f=(b1-mid)/y;
                b1-=y*f;
                c1+=f;
            }
            if(a1>=mid&&b1>=mid&&c1>=mid)
                l=mid;
            else r=mid-1;
        }
        cout<<l<<endl;
    }
    return 0;
}

java

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();

        while (T-- > 0) {
            long a = sc.nextLong();
            long b = sc.nextLong();
            long c = sc.nextLong();
            long x = sc.nextLong();
            long y = sc.nextLong();

            long l = 0;
            long r = (long) 1e9;

            while (l < r) {
                long mid = (l + r + 1) / 2;
                long a1 = a;
                long b1 = b;
                long c1 = c;

                if (a1 > mid) {
                    long f = (a1 - mid) / x;
                    a1 -= x * f;
                    b1 += f;
                }
                if (b1 > mid) {
                    long f = (b1 - mid) / y;
                    b1 -= y * f;
                    c1 += f;
                }

                if (a1 >= mid && b1 >= mid && c1 >= mid) {
                    l = mid;
                } else {
                    r = mid - 1;
                }
            }

            System.out.println(l);
        }
    }
}

python

def main():
    T = int(input())

    for _ in range(T):
        a, b, c, x, y = map(int, input().split())

        l = 0
        r = 10**9

        while l < r:
            mid = (l + r + 1) // 2
            a1 = a
            b1 = b
            c1 = c

            if a1 > mid:
                f = (a1 - mid) // x
                a1 -= x * f
                b1 += f

            if b1 > mid:
                f = (b1 - mid) // y
                b1 -= y * f
                c1 += f

            if a1 >= mid and b1 >= mid and c1 >= mid:
                l = mid
            else:
                r = mid - 1

        print(l)

if __name__ == "__main__":
    main()

题目内容

小美有$a$个红砖、$b$个蓝砖和$c$个绿砖。每$x$个红砖可以合成$1$个蓝砖，每$y$个蓝砖可以合成$1$个绿砖。砖块只能正向合成，不能反向分解。 一套砖块包含$1$个红砖、$1$个蓝砖和$1$个绿砖。请计算小美最多可以收集多少套砖块。

输入描述

每个测试文件均包含多组测试数据。第一行输入一个整数$T(1≤T≤10^5)$代表数据组数，每组测试数据描述如下: 在一行上输入五个整数$a,b,c,x,y(0≤a,b,c≤10^9,1≤x,y≤10^9)$，分别表示红砖、蓝砖、绿砖的数量及合成的比例。

输出描述

对于每一组测试数据，在一行上输出一个整数，代表小美最多可以收集到的砖块套数。

样例1

输入

2
1 2 3 4 2
10 2 1 4 2

输出

1
2

说明

对于第一组测试数据，无法进行合成转换，故只能收集初始的一套。 对于第二组测试数据，可以把$8$个红砖转为$2$个蓝砖、把$2$个蓝砖转化为$1$个绿砖。这样每种的砖块数量分别为$[2, 2,2]$，刚好凑成$2$套。