【算法】Java脱发题汇总

暴走十八步

已于 2023-03-17 01:06:25 修改

阅读量276

点赞数

文章标签：算法

于 2021-12-10 14:18:30 首次发布

本文链接：https://blog.csdn.net/wayhb/article/details/121854822

版权

算法题:

有一个游乐场，里面有很多灯泡，灯泡一共有三种颜色，白色，红色和蓝色。
白色是未点亮状态，白色点亮以后可以变成红色或者蓝色，但是变成红色或蓝色的代价不同。
现在需要点亮所有灯泡，且最终红色和蓝色数量一样多，实现一种最小代价算法。
提示：当无法做到红色与蓝色一样多时，直接返回-1。

思路：

1，把灯泡抽象成类，在参数中标注原始位置，颜色，变红代价，变蓝代价；
2，白色灯泡是最终要点亮的，点亮数量就是总数/2-红（或蓝）灯泡数量；
3，对白色灯泡代价值差进行排序，值最小的（说明变红代价最小）点红，后面的点蓝

代码：

/**
* 灯泡类
*/
@Data
class lights{
    int sn;//原始排序
    int color;//颜色,0白色，1红色，2蓝色
    int priceRed;//变红代价
    int priceBlue;//变蓝代价
}
/**
 * 执行结果
 */
@Test
public void xiao_hong_shu() {
    System.out.println(pokerLight());
}

/**
 * 具体实现
 */
public String pokerLight(){
    //假设有10个灯泡，进行数据初始化
    int totol = 10;
    List<lights> light = new ArrayList<>();
    for(int i=0;i<totol;i++){
        lights l =new lights();
        Random r = new Random();
        l.setSn(i);//给一个原始排序
        l.setColor(r.nextInt(3));//随机一个灯泡颜色
        l.setPriceBlue(r.nextInt(11));//随机一个变红代价
        l.setPriceBlue(r.nextInt(11));//随机一个变蓝代价
        light.add(l);
    }
    System.out.println("初始化灯泡："+light);
    //1，收集红蓝数量；2，计算白色转换数量；3，代价差排序
    List<lights> lightBai = new ArrayList<>();
    List<lights> lightRed = new ArrayList<>();
    List<lights> lightBlue = new ArrayList<>();
    for(lights list : light){
        if(list.getColor()==0){
            lightBai.add(list);
        }
        if(list.getColor()==1){
            lightRed.add(list);
        }
        if(list.getColor()==2){
            lightBlue.add(list);
        }
    }
    //红或蓝超过一半数量，点亮失败返回-1
    if(lightRed.size()>totol/2 || lightBlue.size()>totol/2){
        return "-1";
    }
    //对白色灯泡代价排序
    Collections.sort(lightBai,new Comparator<lights>(){
        @Override
        public int compare(lights o1, lights o2) {
            int a=o1.getPriceRed()-o1.getPriceBlue();
            int b=o2.getPriceRed()-o2.getPriceBlue();
            return a-b;//升序排序
        }
    });
    int redNum = totol/2-lightRed.size();//点亮红色数
    int blueNum = totol/2-lightBlue.size();//点亮蓝色数
    //前面红色，后面蓝色
    List<lights> lightBaiToRed = new ArrayList<>();
    List<lights> lightBaiToBlue = new ArrayList<>();
    for(int i=0;i<redNum;i++){//记录red
        lightBaiToRed.add(lightBai.get(i));
    }
    for(int i=redNum;i<blueNum;i++){//记录red
        lightBaiToBlue.add(lightBai.get(i));
    }
    return ""+lightBaiToRed.toString()+lightBaiToBlue.toString();
}

输出

初始化灯泡：[BTest.lights(sn=0, color=0, priceRed=0, priceBlue=10), BTest.lights(sn=1, color=1, priceRed=0, priceBlue=10), BTest.lights(sn=2, color=0, priceRed=0, priceBlue=3), BTest.lights(sn=3, color=0, priceRed=0, priceBlue=9), BTest.lights(sn=4, color=0, priceRed=0, priceBlue=2), BTest.lights(sn=5, color=0, priceRed=0, priceBlue=9), BTest.lights(sn=6, color=2, priceRed=0, priceBlue=5), BTest.lights(sn=7, color=0, priceRed=0, priceBlue=3), BTest.lights(sn=8, color=2, priceRed=0, priceBlue=7), BTest.lights(sn=9, color=2, priceRed=0, priceBlue=5)]


点亮成红色的是：[BTest.lights(sn=0, color=0, priceRed=0, priceBlue=10), BTest.lights(sn=3, color=0, priceRed=0, priceBlue=9), BTest.lights(sn=5, color=0, priceRed=0, priceBlue=9)


点亮成蓝色的是：BTest.lights(sn=2, color=0, priceRed=0, priceBlue=3)][]

通过sn（原始位置）就可以去点亮灯泡了
每次运行结果会不同，也会出现-1

线程题：

三个线程并发，给每个线程取名，依次是A，B，C，控制台交替打印出如下结果ABCABCABCABC

思路：

控制线程交替运行

代码：

util.concurrent.locks中的LockSupport可以实现任意位置阻断和恢复线程，效果类似wait/notify但更简单更强大
LockSupport主要是2个静态方法 park：停车（阻断线程），unpark：开车（指定线程放行）
wait/notify都是Object中的方法,在调用这两个方法前必须先获得锁对象，但是park不需要获取某个对象的锁就可以锁住线程。
notify只能随机选择一个线程唤醒，无法唤醒指定的线程，unpark却可以唤醒一个指定的线程。

import org.junit.jupiter.api.Test;
import java.util.concurrent.locks.LockSupport;
public class TestThread2 {

    static Thread t1,t2,t3;

    @Test
    public void test1(){
        t1 = new Thread(()->{
            for (int i=0;i<10;i++){
                System.out.print(Thread.currentThread().getName());
                LockSupport.unpark(t2);//指定线程t2执行
                LockSupport.park();//本线程阻断
            }
        },"a");
        t2 = new Thread(()->{
            for (int i=0;i<10;i++){
                LockSupport.park();
                System.out.print(Thread.currentThread().getName());
                LockSupport.unpark(t3);
            }
        },"b");
        t3 = new Thread(()->{
            for (int i=0;i<10;i++){
                LockSupport.park();
                System.out.print(Thread.currentThread().getName());
                LockSupport.unpark(t1);
            }
        },"c");
        t1.start();
        t2.start();
        t3.start();
    }
}