校招算法笔面试 | 华为机试-汽水瓶

原创于 2025-05-12 09:40:41 发布 · 806 阅读

26 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #面试 #华为 #算法华为 #笔试 #算法华为笔试

题目## 题目

题目链接

解题思路

问题分析：
- 每3个空瓶可以换1瓶汽水
- 喝完后又会产生新的空瓶
- 2个空瓶时可以借1个空瓶换1瓶汽水
- 1个空瓶时无法继续换取

处理流程：

初始状态：10个空瓶
第1轮：10/3=3瓶汽水，剩余1个空瓶，新增3个空瓶，共4个空瓶
第2轮：4/3=1瓶汽水，剩余1个空瓶，新增1个空瓶，共2个空瓶
第3轮：2个空瓶，借1个换1瓶汽水
总计：3+1+1=5瓶汽水

关键点：
- 每轮循环处理3个空瓶换1瓶的情况
- 每轮更新剩余空瓶数 = 换不了的空瓶 + 新喝完的空瓶
- 最后特殊处理2个空瓶的情况

代码

#include <iostream>
using namespace std;

int getDrinks(int bottles) {
    if (bottles < 2) {
        return 0;
    }
    
    // 每3个空瓶换1瓶汽水
    int total = 0;
    while (bottles >= 3) {
        // 当前可以换到的汽水数
        int newDrinks = bottles / 3;
        total += newDrinks;
        // 剩余的空瓶 = 换不了的空瓶 + 新喝完的空瓶
        bottles = bottles % 3 + newDrinks;
    }
    
    // 如果最后剩2个空瓶，还可以找老板借1个空瓶换1瓶汽水
    if (bottles == 2) {
        total += 1;
    }
    
    return total;
}

int main() {
    int n;
    while (cin >> n && n) {
        cout << getDrinks(n) << endl;
    }
    return 0;
}

import java.util.Scanner;

public class Main {
    public static int getDrinks(int bottles) {
        if (bottles < 2) {
            return 0;
        }
        
        // 每3个空瓶换1瓶汽水
        int total = 0;
        while (bottles >= 3) {
            // 当前可以换到的汽水数
            int newDrinks = bottles / 3;
            total += newDrinks;
            // 剩余的空瓶 = 换不了的空瓶 + 新喝完的空瓶
            bottles = bottles % 3 + newDrinks;
        }
        
        // 如果最后剩2个空瓶，还可以找老板借1个空瓶换1瓶汽水
        if (bottles == 2) {
            total += 1;
        }
        
        return total;
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n = sc.nextInt();
            if (n == 0) {
                break;
            }
            System.out.println(getDrinks(n));
        }
        sc.close();
    }
}

def get_drinks(bottles):
    if bottles < 2:
        return 0
    
    # 每3个空瓶换1瓶汽水
    total = 0
    while bottles >= 3:
        # 当前可以换到的汽水数
        new_drinks = bottles // 3
        total += new_drinks
        # 剩余的空瓶 = 换不了的空瓶 + 新喝完的空瓶
        bottles = bottles % 3 + new_drinks
    
    # 如果最后剩2个空瓶，还可以找老板借1个空瓶换1瓶汽水
    if bottles == 2:
        total += 1
        
    return total

def main():
    while True:
        try:
            n = int(input())
            if n == 0:
                break
            print(get_drinks(n))
        except EOFError:
            break

if __name__ == "__main__":
    main()

算法及复杂度

算法：贪心算法
- 每次尽可能多地用3个空瓶换汽水
- 最后处理特殊情况（2个空瓶）
时间复杂度： $\mathcal{O}(\log n)$
- 每次循环瓶子数量至少减少为原来的1/3
- 假设初始n个瓶子，经过k轮后： $n * (1/3)^k < 3$
- 解得： $k < \log_3(n/3)$
- 因此时间复杂度为 $\mathcal{O}(\log n)$
空间复杂度： $\mathcal{O}(1)$
- 只需要常数级别的变量存储
- 不需要额外的数据结构

题目链接

解题思路

这是一个求最小公倍数的问题。最小公倍数可以通过两个数的乘积除以它们的最大公约数得到。

关键点

数据范围： $\leq a,b \leq 100000$
需要先求最大公约数(GCD)
最小公倍数 = $\frac{a \times b}{GCD(a,b)}$

代码

#include <iostream>
using namespace std;

// 求最大公约数 - 使用辗转相除法
int getGCD(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

// 求最小公倍数
int getLCM(int a, int b) {
    int gcd = getGCD(a, b);
    return (long long)a * b / gcd;  // 注意防止溢出
}

int main() {
    int a, b;
    while (cin >> a >> b) {
        cout << getLCM(a, b) << endl;
    }
    return 0;
}

import java.util.Scanner;

public class Main {
    // 求最大公约数 - 使用辗转相除法
    public static int getGCD(int a, int b) {
        while (b != 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }
    
    // 求最小公倍数
    public static int getLCM(int a, int b) {
        int gcd = getGCD(a, b);
        return (int)((long)a * b / gcd);  // 注意防止溢出
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            System.out.println(getLCM(a, b));
        }
    }
}

def get_gcd(a, b):
    # 求最大公约数 - 使用辗转相除法
    while b:
        a, b = b, a % b
    return a

def get_lcm(a, b):
    # 求最小公倍数
    gcd = get_gcd(a, b)
    return a * b // gcd

while True:
    try:
        a, b = map(int, input().split())
        print(get_lcm(a, b))
    except:
        break