有10个人排队购一件价为5元的商品，其中一半人拿一张10元人民币，另一半人拿一张5元的人民币，要使售货员在售货中，不发生找钱困难，假设售货员一开始就没有准备零钱。.问这10个人应该如何排队?

这个问题可以通过让拿10元人民币的人先排队，再让拿5元人民币的人排队来解决。这样，当每个人购买商品时，他们会给售货员一张10元或5元的人民币，而售货员会先用10元的人民币找零给前面排队的顾客，这样后面排队的顾客就可以使用5元的人民币购买商品了。因此，排队的顺序应该是：5元、10元、5元、10元、5元、10元、5元、10元、5元、10元。

相关问题

基于java的用递归法十个人排队买一个五元的商品，五个人拿五元，五个人拿十元，可以给每个人都找零，假设售货员一开始没有零钱

这个问题可以使用递归实现，具体思路如下：

1. 定义一个递归函数，输入为当前队列中需要找零的人数、需要找的零钱数、已有的零钱数、队列中每个人持有的钱数。

2. 如果当前队列中需要找零的人数为0，则表示所有人都找零完成，返回true。

3. 如果需要找的零钱数为0，则表示当前队列中的人都已经找到了零钱，进入下一个递归，递归的输入参数为队列中需要找零的人数减1、需要找的零钱数为当前队列中下一个人持有的钱数与售货员手中的零钱数之差、已有的零钱数等于当前队列中下一个人持有的钱数。

4. 如果队列中第一个人持有的钱数小于等于售货员手中的零钱数，则尝试给他找零。找零的方法是，判断售货员手中是否有足够的零钱找给他，如果有，则进入下一个递归，递归的输入参数为队列中需要找零的人数减1、需要找的零钱数为当前队列中下一个人持有的钱数与售货员手中的零钱数之差、已有的零钱数等于当前队列中下一个人持有的钱数加上售货员手中的零钱数减去当前队列中第一个人持有的钱数。

5. 如果第一个人持有的钱数大于售货员手中的零钱数，则无法给他找零，返回false。

6. 如果以上所有条件都不满足，则表示无法完成找零，返回false。

下面是Java语言实现的代码片段：

public boolean makeChange(int num, int change, int cash, int[] queue) {
    if (num == 0) {
        return true;
    }
    if (change == 0) {
        return makeChange(num - 1, queue[num - 1] - cash, queue[num - 1], queue);
    }
    if (queue[0] <= cash) {
        if (makeChange(num, change - queue[0], cash - queue[0] + queue[num], queue)) {
            return true;
        }
    }
    if (cash >= 5 && makeChange(num, change - 5, cash - 5, queue)) {
        return true;
    }
    if (cash >= 10 && change >= 10 && makeChange(num, change - 10, cash - 10, queue)) {
        return true;
    }
    return false;
}

17、利用线程实现以下功能：模拟三个人排队买票，张某、李某和赵某买电影票，售票员只有三张五元的钱，电影票5元钱一张。张某拿二十元一张的新人民币排在李的前面买票，李某排在赵的前面拿一张10元的人民币买票，赵某拿一张5元的人民币买票。

以下是基于 Java 语言的代码实现：

public class TicketSellingDemo {
    private static int money = 3 * 5; // 初始售票员的钱
    private static Object lock = new Object(); // 共享对象锁

    public static void main(String[] args) {
        Thread zhang = new Thread(new Zhang()); // 张某买票线程
        Thread li = new Thread(new Li()); // 李某买票线程
        Thread zhao = new Thread(new Zhao()); // 赵某买票线程
        zhang.start();
        li.start();
        zhao.start();
    }

    static class Zhang implements Runnable {
        @Override
        public void run() {
            synchronized (lock) { // 加锁
                while (money < 5) { // 判断是否有足够的钱找零
                    try {
                        lock.wait(); // 等待售票员找钱
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("张某买了一张票，给售票员一张20元的人民币");
                money += 20; // 收钱
                lock.notifyAll(); // 唤醒其他线程
            }
        }
    }

    static class Li implements Runnable {
        @Override
        public void run() {
            synchronized (lock) { // 加锁
                while (money < 10) { // 判断是否有足够的钱找零
                    try {
                        lock.wait(); // 等待售票员找钱
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("李某买了一张票，给售票员一张10元的人民币");
                money += 10; // 收钱
                lock.notifyAll(); // 唤醒其他线程
            }
        }
    }

    static class Zhao implements Runnable {
        @Override
        public void run() {
            synchronized (lock) { // 加锁
                while (money < 5) { // 判断是否有足够的钱找零
                    try {
                        lock.wait(); // 等待售票员找钱
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("赵某买了一张票，给售票员一张5元的人民币");
                money += 5; // 收钱
                lock.notifyAll(); // 唤醒其他线程
            }
        }
    }
}

程序中使用了一个共享对象锁 `lock` 实现线程同步，每个买票线程在买票前都会先获取锁，判断是否有足够的钱找零，如果没有则等待售票员找零，如果有则进行买票操作，收钱后唤醒其他线程。每个线程执行完毕后都会释放锁。